LogoLogo
HomeAcademyLoginTry for free
  • Welcome
  • What's new
    • Q2 2025
    • Q1 2025
    • Q4 2024
    • Q3 2024
    • Q2 2024
    • Q1 2024
    • Q4 2023
    • Q3 2023
    • Q2 2023
    • Q1 2023
    • Q4 2022
    • Q3 2022
  • FAQs
    • Accounts
    • Migration to the new platform
    • User & organization setup
    • General
    • Builder
    • Workflows
    • Data Observatory
    • Analytics Toolbox
    • Development Tools
    • Deployment Options
    • CARTO Basemaps
    • CARTO for Education
    • Support Packages
    • Security and Compliance
  • Getting started
    • What is CARTO?
    • Quickstart guides
      • Connecting to your data
      • Creating your first map
      • Creating your first workflow
      • Developing your first application
    • CARTO Academy
  • CARTO User Manual
    • Overview
      • Creating your CARTO organization
      • CARTO Cloud Regions
      • CARTO Workspace overview
    • Maps
      • Data sources
        • Simple features
        • Spatial Indexes
        • Pre-generated tilesets
        • Rasters
        • Defining source spatial data
        • Managing data freshness
        • Changing data source location
      • Layers
        • Point
          • Grid point aggregation
          • H3 point aggregation
          • Heatmap point aggregation
          • Cluster point aggregation
        • Polygon
        • Line
        • Grid
        • H3
        • Raster
        • Zoom to layer
      • Widgets
        • Formula widget
        • Category widget
        • Pie widget
        • Histogram widget
        • Range widget
        • Time Series widget
        • Table widget
      • SQL Parameters
        • Date parameter
        • Text parameter
        • Numeric parameter
        • Publishing SQL parameters
      • Interactions
      • Legend
      • Basemaps
        • Basemap selector
      • AI Agents
      • SQL analyses
      • Map view modes
      • Map description
      • Feature selection tool
      • Search locations
      • Measure distances
      • Exporting data
      • Download PDF reports
      • Managing maps
      • Sharing and collaboration
        • Editor collaboration
        • Map preview for editors
        • Map settings for viewers
        • Comments
        • Embedding maps
        • URL parameters
      • Performance considerations
    • Workflows
      • Workflow canvas
      • Results panel
      • Components
        • Aggregation
        • Custom
        • Data Enrichment
        • Data Preparation
        • Generative AI
        • Input / Output
        • Joins
        • Parsers
        • Raster Operations
        • Spatial Accessors
        • Spatial Analysis
        • Spatial Constructors
        • Spatial Indexes
        • Spatial Operations
        • Statistics
        • Tileset Creation
        • BigQuery ML
        • Snowflake ML
        • Google Earth Engine
        • Google Environment APIs
        • Telco Signal Propagation Models
      • Data Sources
      • Scheduling workflows
      • Sharing workflows
      • Using variables in workflows
      • Executing workflows via API
      • Temporary data in Workflows
      • Extension Packages
      • Managing workflows
      • Workflows best practices
    • Data Explorer
      • Creating a map from your data
      • Importing data
        • Importing rasters
      • Geocoding data
      • Optimizing your data
    • Data Observatory
      • Terminology
      • Browsing the Spatial Data Catalog
      • Subscribing to public and premium datasets
      • Accessing free data samples
      • Managing your subscriptions
      • Accessing your subscriptions from your data warehouse
        • Access data in BigQuery
        • Access data in Snowflake
        • Access data in Databricks
        • Access data in Redshift
        • Access data in PostgreSQL
    • Connections
      • Google BigQuery
      • Snowflake
      • Databricks
      • Amazon Redshift
      • PostgreSQL
      • CARTO Data Warehouse
      • Sharing connections
      • Deleting a connection
      • Required permissions
      • IP whitelisting
      • Customer data responsibilities
    • Applications
    • Settings
      • Understanding your organization quotas
      • Activity Data
        • Activity Data Reference
        • Activity Data Examples
        • Activity Data Changelog
      • Users and Groups
        • Inviting users to your organization
        • Managing user roles
        • Deleting users
        • SSO
        • Groups
        • Mapping groups to user roles
      • CARTO Support Access
      • Customizations
        • Customizing appearance and branding
        • Configuring custom color palettes
        • Configuring your organization basemaps
        • Enabling AI Agents
      • Advanced Settings
        • Managing applications
        • Configuring S3 Bucket for Redshift Imports
        • Configuring OAuth connections to Snowflake
        • Configuring OAuth U2M connections to Databricks
        • Configuring S3 Bucket integration for RDS for PostgreSQL Exports in Builder
        • Configuring Workload Identity Federation for BigQuery
      • Data Observatory
      • Deleting your organization
    • Developers
      • Managing Credentials
        • API Base URL
        • API Access Tokens
        • SPA OAuth Clients
        • M2M OAuth Clients
      • Named Sources
  • Data and Analysis
    • Analytics Toolbox Overview
    • Analytics Toolbox for BigQuery
      • Getting access
        • Projects maintained by CARTO in different BigQuery regions
        • Manual installation in your own project
        • Installation in a Google Cloud VPC
        • Core module
      • Key concepts
        • Tilesets
        • Spatial indexes
      • SQL Reference
        • accessors
        • clustering
        • constructors
        • cpg
        • data
        • http_request
        • import
        • geohash
        • h3
        • lds
        • measurements
        • placekey
        • processing
        • quadbin
        • random
        • raster
        • retail
        • routing
        • s2
        • statistics
        • telco
        • tiler
        • transformations
      • Guides
        • Running queries from Builder
        • Working with Raster data
      • Release notes
      • About Analytics Toolbox regions
    • Analytics Toolbox for Snowflake
      • Getting access
        • Native App from Snowflake's Marketplace
        • Manual installation
      • Key concepts
        • Spatial indexes
        • Tilesets
      • SQL Reference
        • accessors
        • clustering
        • constructors
        • data
        • http_request
        • import
        • h3
        • lds
        • measurements
        • placekey
        • processing
        • quadbin
        • random
        • raster
        • retail
        • s2
        • statistics
        • tiler
        • transformations
      • Guides
        • Running queries from Builder
        • Working with Raster data
      • Release Notes
    • Analytics Toolbox for Databricks
      • Getting access
        • Personal (former Single User) cluster
        • Standard (former Shared) cluster
      • Reference
        • lds
        • tiler
      • Guides
      • Release Notes
    • Analytics Toolbox for Redshift
      • Getting access
        • Manual installation in your database
        • Installation in an Amazon Web Services VPC
        • Core version
      • Key concepts
        • Tilesets
        • Spatial indexes
      • SQL Reference
        • clustering
        • constructors
        • data
        • http_request
        • import
        • lds
        • placekey
        • processing
        • quadbin
        • random
        • s2
        • statistics
        • tiler
        • transformations
      • Guides
        • Running queries from Builder
      • Release Notes
    • Analytics Toolbox for PostgreSQL
      • Getting access
        • Manual installation
        • Core version
      • Key concepts
        • Tilesets
        • Spatial Indexes
      • SQL Reference
        • h3
        • quadbin
        • tiler
      • Guides
        • Creating spatial index tilesets
        • Running queries from Builder
      • Release Notes
    • CARTO + Python
      • Installation
      • Authentication Methods
      • Visualizing Data
      • Working with Data
        • How to work with your data in the CARTO Data Warehouse
        • How to access your Data Observatory subscriptions
        • How to access CARTO's Analytics Toolbox for BigQuery and create visualizations via Python notebooks
        • How to access CARTO’s Analytics Toolbox for Snowflake and create visualizations via Python notebooks
        • How to visualize data from Databricks
      • Reference
    • CARTO QGIS Plugin
  • CARTO for Developers
    • Overview
    • Key concepts
      • Architecture
      • Libraries and APIs
      • Authentication methods
        • API Access Tokens
        • OAuth Access Tokens
        • OAuth Clients
      • Connections
      • Data sources
      • Visualization with deck.gl
        • Basemaps
          • CARTO Basemap
          • Google Maps
            • Examples
              • Gallery
              • Getting Started
              • Basic Examples
                • Hello World
                • BigQuery Tileset Layer
                • Data Observatory Tileset Layer
              • Advanced Examples
                • Arc Layer
                • Extrusion
                • Trips Layer
            • What's New
          • Amazon Location
            • Examples
              • Hello World
              • CartoLayer
            • What's New
        • Rapid Map Prototyping
      • Charts and widgets
      • Filtering and interactivity
      • Summary
    • Quickstart
      • Make your first API call
      • Visualize your first dataset
      • Create your first widget
    • Guides
      • Build a public application
      • Build a private application
      • Build a private application using SSO
      • Visualize massive datasets
      • Integrate CARTO in your existing application
      • Use Boundaries in your application
      • Avoid exposing SQL queries with Named Sources
      • Managing cache in your CARTO applications
    • Reference
      • Deck (@deck.gl reference)
      • Data Sources
        • vectorTableSource
        • vectorQuerySource
        • vectorTilesetSource
        • h3TableSource
        • h3QuerySource
        • h3TilesetSource
        • quadbinTableSource
        • quadbinQuerySource
        • quadbinTilesetSource
        • rasterSource
        • boundaryTableSource
        • boundaryQuerySource
      • Layers (@deck.gl/carto)
      • Widgets
        • Data Sources
        • Server-side vs. client-side
        • Models
          • getFormula
          • getCategories
          • getHistogram
          • getRange
          • getScatter
          • getTimeSeries
          • getTable
      • Filters
        • Column filters
        • Spatial filters
      • CARTO APIs Reference
    • Release Notes
    • Examples
    • CARTO for React
      • Guides
        • Getting Started
        • Views
        • Data Sources
        • Layers
        • Widgets
        • Authentication and Authorization
        • Basemaps
        • Look and Feel
        • Query Parameters
        • Code Generator
        • Sample Applications
        • Deployment
        • Upgrade Guide
      • Examples
      • Library Reference
        • Introduction
        • API
        • Auth
        • Basemaps
        • Core
        • Redux
        • UI
        • Widgets
      • Release Notes
  • CARTO Self-Hosted
    • Overview
    • Key concepts
      • Architecture
      • Deployment requirements
    • Quickstarts
      • Single VM deployment (Kots)
      • Orchestrated container deployment (Kots)
      • Advanced Orchestrated container deployment (Helm)
    • Guides
      • Guides (Kots)
        • Configure your own buckets
        • Configure an external in-memory cache
        • Enable Google Basemaps
        • Enable the CARTO Data Warehouse
        • Configure an external proxy
        • Enable BigQuery OAuth connections
        • Configure Single Sign-On (SSO)
        • Use Workload Identity in GCP
        • High availability configuration for CARTO Self-hosted
        • Configure your custom service account
      • Guides (Helm)
        • Configure your own buckets (Helm)
        • Configure an external in-memory cache (Helm)
        • Enable Google Basemaps (Helm)
        • Enable the CARTO Data Warehouse (Helm)
        • Configure an external proxy (Helm)
        • Enable BigQuery OAuth connections (Helm)
        • Configure Single Sign-On (SSO) (Helm)
        • Use Workload Identity in GCP (Helm)
        • Use EKS Pod Identity in AWS (Helm)
        • Enable Redshift imports (Helm)
        • Migrating CARTO Self-hosted installation to an external database (Helm)
        • Advanced customizations (Helm)
        • Configure your custom service account (Helm)
    • Maintenance
      • Maintenance (Kots)
        • Updates
        • Backups
        • Uninstall
        • Rotating keys
        • Monitoring
        • Change the Admin Console password
      • Maintenance (Helm)
        • Monitoring (Helm)
        • Rotating keys (Helm)
        • Uninstall (Helm)
        • Backups (Helm)
        • Updates (Helm)
    • Support
      • Get debug information for Support (Kots)
      • Get debug information for Support (Helm)
    • CARTO Self-hosted Legacy
      • Key concepts
        • Architecture
        • Deployment requirements
      • Quickstarts
        • Single VM deployment (docker-compose)
      • Guides
        • Configure your own buckets
        • Configure an external in-memory cache
        • Enable Google Basemaps
        • Enable the CARTO Data Warehouse
        • Configure an external proxy
        • Enable BigQuery OAuth connections
        • Configure Single Sign-On (SSO)
        • Enable Redshift imports
        • Configure your custom service account
        • Advanced customizations
        • Migrating CARTO Self-Hosted installation to an external database
      • Maintenance
        • Updates
        • Backups
        • Uninstall
        • Rotating keys
        • Monitoring
      • Support
    • Release Notes
  • CARTO Native App for Snowflake Containers
    • Deploying CARTO using Snowflake Container Services
  • Get Help
    • Legal & Compliance
    • Previous libraries and components
    • Migrating your content to the new CARTO platform
Powered by GitBook
On this page
  • RASTER_VALUES
  • RASTER_AGG_VALUES

Was this helpful?

Export as PDF
  1. Data and Analysis
  2. Analytics Toolbox for BigQuery
  3. SQL Reference

raster

PreviousrandomNextretail

Last updated 19 days ago

Was this helpful?

This module contains procedures to access and operate with raster data that has been loaded into BigQuery using , built in collaboration with .

Learn more about loading raster data as raster tables in BigQuery following this .

RASTER_VALUES

RASTER_VALUES(raster_table, vector_query, output_expression, output_table, options)

Description

Returns each pixel and associated values from a output_expression across all bands in a given area of interest of a raster table. The result will include the data from the vector_query as well as from all bands, corresponding to the pixels that intersect each geography.

  • raster_table: STRING the qualified table name of the raster table, e.g. 'project.dataset.raster_table'.

  • vector_query: STRING query containing the area of interest in which to perform the extraction, stored in a column named geom. Additional columns can be included into this query in order to be referenced from the output_expression. It can be NULL, in which case all values stored in the raster table will be extracted.

  • output_expression: STRING contains the bands and values to be extracted from the raster. This expression support alias. It does not support aggregations. If you need to use aggregations, use the function. This expression can be NULL if a pixel column is added using the include_pixel option.

  • output_table: STRING where the resulting table will be stored. It must be a STRING of the form 'project.dataset.output_table'. The dataset must exist and the caller needs to have permissions to create a new table on it. The process will fail if the target table already exists. May be NULL, in which case the table is directly returned as the last result of the procedure.

  • options: STRING a JSON string with additional options:

    Option
    Description

    include_pixel

    BOOLEAN whether to include the pixel column of the extracted pixel values, in quadbin format. Default is false.

    intersect_center

    BOOLEAN whether to extract the pixel values by intersecting the pixel center or instead the pixel boundary. This operation is recommended only for big polygons, relative to the pixel size. It will run faster but provide less accurate results. It does not take effect when vector_query is NULL. Default is false.

When intersecting large polygons with high-resolution pixels, it may encounter BigQuery's computational and memory limits due to the extensive data generated. To mitigate this, we recommend simplifying polygon geometries, reducing pixel resolution, or partitioning data into manageable subsets. These strategies help manage data efficiently and prevent exceeding BigQuery's quotas.

Limitations

In some cases, Big compressed rasters might fail to be decompressed. A "Resources exceeded during query execution: UDF out of memory." will be thrown. In this case, try to upload the raster to BigQuery as uncompressed.

Result

The result is a table with the corresponding values extracted from the output_expression and, if selected, a pixel column with quadbin indexes.

Examples

Extract band_1 values for raster pixels intersected by each point in the vector query.

CALL `carto-un`.carto.RASTER_VALUES(
  'project.dataset.raster_table',
  '''
  SELECT point AS geom
  FROM `project.dataset.vector_table`
  ''',
  'band_1',
  NULL,
  NULL
);
-- The (last) result will return the columns:
-- band_1 (one value per pixel boundary intersecting each point)
CALL `carto-un-eu`.carto.RASTER_VALUES(
  'project.dataset.raster_table',
  '''
  SELECT point AS geom
  FROM `project.dataset.vector_table`
  ''',
  'band_1',
  NULL,
  NULL
);
-- The (last) result will return the columns:
-- band_1 (one value per pixel boundary intersecting each point)
CALL carto.RASTER_VALUES(
  'project.dataset.raster_table',
  '''
  SELECT point AS geom
  FROM `project.dataset.vector_table`
  ''',
  'band_1',
  NULL,
  NULL
);
-- The (last) result will return the columns:
-- band_1 (one value per pixel boundary intersecting each point)

Extract band_1 values for the raster pixels intersected by each polygon in the vector query.

CALL `carto-un`.carto.RASTER_VALUES(
  'project.dataset.raster_table',
  '''
  SELECT polygon AS geom
  FROM `project.dataset.vector_table`
  ''',
  'band_1',
  NULL,
  NULL
);
-- The (last) result will return the columns:
-- band_1 (one value per pixel boundary intersecting each polygon)
CALL `carto-un-eu`.carto.RASTER_VALUES(
  'project.dataset.raster_table',
  '''
  SELECT polygon AS geom
  FROM `project.dataset.vector_table`
  ''',
  'band_1',
  NULL,
  NULL
);
-- The (last) result will return the columns:
-- band_1 (one value per pixel boundary intersecting each polygon)
CALL carto.RASTER_VALUES(
  'project.dataset.raster_table',
  '''
  SELECT polygon AS geom
  FROM `project.dataset.vector_table`
  ''',
  'band_1',
  NULL,
  NULL
);
-- The (last) result will return the columns:
-- band_1 (one value per pixel boundary intersecting each polygon)

Extract band_1, band_2 values wih alias names for the raster pixels intersected by all the geographies in the vector table. It will include the input columns except geom. The output will be stored in a table.

CALL `carto-un`.carto.RASTER_VALUES(
  'project.dataset.raster_table',
  'project.dataset.vector_table', -- columns: id, name, geom (point)
  '''
  band_1 AS alias_1,
  band_2 AS alias_2
  ''',
  'project.dataset.output_table',
  NULL
);
-- The table project.dataset.output_table will be created
-- with columns: id, name, alias_1, alias_2 (one value per pixel boundary intersecting each point)
CALL `carto-un-eu`.carto.RASTER_VALUES(
  'project.dataset.raster_table',
  'project.dataset.vector_table', -- columns: id, name, geom (point)
  '''
  band_1 AS alias_1,
  band_2 AS alias_2
  ''',
  'project.dataset.output_table',
  NULL
);
-- The table project.dataset.output_table will be created
-- with columns: id, name, alias_1, alias_2 (one value per pixel boundary intersecting each point)
CALL carto.RASTER_VALUES(
  'project.dataset.raster_table',
  'project.dataset.vector_table', -- columns: id, name, geom (point)
  '''
  band_1 AS alias_1,
  band_2 AS alias_2
  ''',
  'project.dataset.output_table',
  NULL
);
-- The table project.dataset.output_table will be created
-- with columns: id, name, alias_1, alias_2 (one value per pixel boundary intersecting each point)

Extract band_1 values for raster pixels intersected by each point in the vector table. It will include the input columns except geom. The output will be stored in a table. The option "include_pixel" can be set to true to include the pixel value in quadbin format.

CALL `carto-un`.carto.RASTER_VALUES(
  'project.dataset.raster_table',
  'project.dataset.vector_table', -- columns: id, name, geom (point)
  'band_1',
  'project.dataset.output_table',
  '{"include_pixel": true}'
);
-- The table project.dataset.output_table will be created
-- with columns: id, name, pixel, band_1 (one value per pixel boundary intersecting each point)
CALL `carto-un-eu`.carto.RASTER_VALUES(
  'project.dataset.raster_table',
  'project.dataset.vector_table', -- columns: id, name, geom (point)
  'band_1',
  'project.dataset.output_table',
  '{"include_pixel": true}'
);
-- The table project.dataset.output_table will be created
-- with columns: id, name, pixel, band_1 (one value per pixel boundary intersecting each point)
CALL carto.RASTER_VALUES(
  'project.dataset.raster_table',
  'project.dataset.vector_table', -- columns: id, name, geom (point)
  'band_1',
  'project.dataset.output_table',
  '{"include_pixel": true}'
);
-- The table project.dataset.output_table will be created
-- with columns: id, name, pixel, band_1 (one value per pixel boundary intersecting each point)

RASTER_AGG_VALUES

RASTER_AGG_VALUES(raster_table, vector_query, output_expression, output_table, options)

Description

Returns aggregated values for all pixels intersecting the specified geometries, according to an output_expression.

  • raster_table: STRING the qualified table name of the raster table, e.g. 'project.dataset.raster_table'.

  • vector_query: STRING query containing the area of interest in which to perform the aggregation, stored in a column named geom. Additional columns can be included into this query in order to be referenced from the output_expression. It can be NULL, in which case all values stored in the raster table will be used.

  • output_table: STRING where the resulting table will be stored. It must be a STRING of the form 'project.dataset.output_table'. The dataset must exist and the caller needs to have permissions to create a new table on it. The process will fail if the target table already exists. May be NULL, in which case the table is directly returned as the last result of the procedure.

  • options: STRING a JSON string with additional options.

    Option
    Description

    groupby_vector_columns

    ARRAY group by extra columns included in the vector_query, in addition to the geom column. It does not take effect when vector_query is NULL.

    groupby_raster_columns

    ARRAY group by extra columns included in the raster_table, in addition to the geom column.

    intersect_center

    BOOLEAN whether to extract the pixel values by intersecting the pixel center or instead the pixel boundary. This operation is recommended only for big polygons, relative to the pixel size. It will run faster but provide less accurate results. It does not take effect when vector_query is NULL. Default is false.

When intersecting large polygons with high-resolution pixels, it may encounter BigQuery's computational and memory limits due to the extensive data generated. To mitigate this, we recommend simplifying polygon geometries, reducing pixel resolution, or partitioning data into manageable subsets. These strategies help manage data efficiently and prevent exceeding BigQuery's quotas.

**warning**
The aggregation of duplicated geographies may produce unexpected results. If the data provided in the `vector_query` contains duplicated geographies, either clean duplicates previously or use the option `groupby_vector_columns` with an existing unique-id column.

Limitations

In some cases, Big compressed rasters might fail to be decompressed. A "Resources exceeded during query execution: UDF out of memory." will be thrown. In this case, try to upload the raster to BigQuery as uncompressed.

Result

The result is a table with the corresponding aggregated values from the output_expression.

Examples

Aggregate band_1 values for the raster pixels intersected by each polygon in the vector query.

CALL `carto-un`.carto.RASTER_AGG_VALUES(
  'project.dataset.raster_table',
  '''
  SELECT polygon AS geom
  FROM `project.dataset.vector_table`
  ''',
  'AVG(band_1) AS band_1_avg',
  NULL,
  NULL
);
-- The (last) result will return the columns:
-- band_1_avg (one value per pixel boundary intersecting each polygon)
CALL `carto-un-eu`.carto.RASTER_AGG_VALUES(
  'project.dataset.raster_table',
  '''
  SELECT polygon AS geom
  FROM `project.dataset.vector_table`
  ''',
  'AVG(band_1) AS band_1_avg',
  NULL,
  NULL
);
-- The (last) result will return the columns:
-- band_1_avg (one value per pixel boundary intersecting each polygon)
CALL carto.RASTER_AGG_VALUES(
  'project.dataset.raster_table',
  '''
  SELECT polygon AS geom
  FROM `project.dataset.vector_table`
  ''',
  'AVG(band_1) AS band_1_avg',
  NULL,
  NULL
);
-- The (last) result will return the columns:
-- band_1_avg (one value per pixel boundary intersecting each polygon)

Aggregate band_1, band_2 values wih different aggregations for the raster pixels intersected by all the geographies in the vector table. It will include the input columns. The output will be stored in a table.

CALL `carto-un`.carto.RASTER_AGG_VALUES(
  'project.dataset.raster_table',
  'project.dataset.vector_table', -- columns: id, name, geom (polygon)
  '''
  AVG(band_1) AS band_1_avg,
  SUM(band_2) AS band_2_avg,
  SUM(band_1 + band_2) AS total_sum,
  COUNT(band_1) AS count,
  ''',
  'project.dataset.output_table',
  NULL
);
-- The table project.dataset.output_table will be created
-- with columns: id, name, band_1_avg, band_2_avg, total_sum, count (one value per each pixel center intersecting each polygon)
CALL `carto-un-eu`.carto.RASTER_AGG_VALUES(
  'project.dataset.raster_table',
  'project.dataset.vector_table', -- columns: id, name, geom (polygon)
  '''
  AVG(band_1) AS band_1_avg,
  SUM(band_2) AS band_2_avg,
  SUM(band_1 + band_2) AS total_sum,
  COUNT(band_1) AS count,
  ''',
  'project.dataset.output_table',
  NULL
);
-- The table project.dataset.output_table will be created
-- with columns: id, name, band_1_avg, band_2_avg, total_sum, count (one value per each pixel center intersecting each polygon)
CALL carto.RASTER_AGG_VALUES(
  'project.dataset.raster_table',
  'project.dataset.vector_table', -- columns: id, name, geom (polygon)
  '''
  AVG(band_1) AS band_1_avg,
  SUM(band_2) AS band_2_avg,
  SUM(band_1 + band_2) AS total_sum,
  COUNT(band_1) AS count,
  ''',
  'project.dataset.output_table',
  NULL
);
-- The table project.dataset.output_table will be created
-- with columns: id, name, band_1_avg, band_2_avg, total_sum, count (one value per each pixel center intersecting each polygon)

Aggregate band_1 values for the raster pixels intersected by each polygon in the vector table. It will include the input columns. The option groupby_vector_columns will be set to id (unique-id) to aggregate with duplicated geographies. The output will be stored in a table.

CALL `carto-un`.carto.RASTER_AGG_VALUES(
  'project.dataset.raster_table',
  'project.dataset.vector_table', -- columns: id, name, geom (polygon)
  'AVG(band_1) AS band_1_avg',
  'project.dataset.output_table',
  '{"groupby_vector_columns": ["id"]}'
);
-- The table project.dataset.output_table will be created
-- with columns: id, name, band_1_avg (one value per pixel boundary intersecting each polygon, and grouped by id)
CALL `carto-un-eu`.carto.RASTER_AGG_VALUES(
  'project.dataset.raster_table',
  'project.dataset.vector_table', -- columns: id, name, geom (polygon)
  'AVG(band_1) AS band_1_avg',
  'project.dataset.output_table',
  '{"groupby_vector_columns": ["id"]}'
);
-- The table project.dataset.output_table will be created
-- with columns: id, name, band_1_avg (one value per pixel boundary intersecting each polygon, and grouped by id)
CALL carto.RASTER_AGG_VALUES(
  'project.dataset.raster_table',
  'project.dataset.vector_table', -- columns: id, name, geom (polygon)
  'AVG(band_1) AS band_1_avg',
  'project.dataset.output_table',
  '{"groupby_vector_columns": ["id"]}'
);
-- The table project.dataset.output_table will be created
-- with columns: id, name, band_1_avg (one value per pixel boundary intersecting each polygon, and grouped by id)

output_expression: STRING contains the aggregated values to be computed from the raster. For extracting non-aggregated values, use the function. This expression cannot be NULL.

This project has received funding from the research and innovation programme under grant agreement No 960401.

Raster Loader
Makepath
guide
RASTER_AGG_VALUES
RASTER_VALUES
European Union’s Horizon 2020