AlloyDB is Google's PostgreSQL-compatible database built for HTAP and AI workloads — pair pgvector with the alloydb_scann index for ScaNN-powered vector search and the columnar engine for analytics, all enabled with a database flag plus a CREATE EXTENSION call.
vector data type and ivfflat and hnsw access methods
Job scheduler for PostgreSQL
Cheminformatics functionality for PostgreSQL.
Extension to manage partitioned tables by time or ID
Extension to manage partitioned tables by time or ID
Reorganize tables in PostgreSQL databases with minimal locks
Reorganize tables in PostgreSQL databases with minimal locks
PL/JavaScript (v8) trusted procedural language
provides auditing functionality
Changing data capture in JSON format
incremental view maintenance on PostgreSQL
type for storing hyperloglog data
Give PostgreSQL ability to manually force some decisions in execution plans.
Give PostgreSQL ability to manually force some decisions in execution plans.
A tool to remove unused space from a relation.
foreign data wrapper for Oracle access
Functions and operators that emulate a subset of functions and packages from the Oracle RDBMS
Functions and operators that emulate a subset of functions and packages from the Oracle RDBMS
Foreign data wrapper for querying a TDS database (Sybase or Microsoft SQL Server)
Foreign data wrapper for querying a TDS database (Sybase or Microsoft SQL Server)
Logical decoding plugin that delivers WAL stream changes using a Protocol Buffer format
Logical decoding plugin that delivers WAL stream changes using a Protocol Buffer format
Run SQL queries in the background
Database partitioning implemented as procedural language
Database partitioning implemented as procedural language
sampling based statistics of wait events
IPv4/v6 and IPv4/v6 range index type for PostgreSQL
create 2-gram (bigram) index for faster full text search.
create 2-gram (bigram) index for faster full text search.
examine and manage the os buffer cache
Extension to add Global Temporary Tables feature to PostgreSQL
Extension to add Global Temporary Tables feature to PostgreSQL
Exposes the Linux operating-system process table through SQL so load, memory, CPU, and I/O stats can be queried from PostgreSQL.
Exposes the Linux operating-system process table through SQL so load, memory, CPU, and I/O stats can be queried from PostgreSQL.
Provides a means for logging execution plans of slow statements automatically
Provides a means for logging execution plans of slow statements automatically
bloom access method - signature file based index
support for indexing common datatypes in GIN
support for indexing common datatypes in GiST
data type for case-insensitive character strings
connect to other PostgreSQL databases from within a database
connect to other PostgreSQL databases from within a database
text search dictionary template for integers
calculate great-circle distances on the surface of the Earth
determine similarities and distance between strings
data type for storing sets of (key, value) pairs
functions, operators, and index support for 1-D arrays of integers
data types for international product numbering standards
data type for hierarchical tree-like structures
inspect the contents of database pages at a low level
track planning and execution statistics of all SQL statements executed
track planning and execution statistics of all SQL statements executed
text similarity measurement and index searching based on trigrams
text similarity measurement and index searching based on trigrams
examine the visibility map (VM) and page-level visibility info
examine the visibility map (VM) and page-level visibility info
PostGIS geometry and geography spatial types and functions
foreign-data wrapper for remote PostgreSQL servers
functions for implementing referential integrity (obsolete)
functions that manipulate whole tables, including crosstab
functions that manipulate whole tables, including crosstab
SQL-based test/example module for WAL logical decoding
TABLESAMPLE method which accepts number of rows as a limit
TABLESAMPLE method which accepts time in milliseconds as a limit
TABLESAMPLE method which accepts time in milliseconds as a limit
generate universally unique identifiers (UUIDs)
AlloyDB ships with a fixed allow-list of extensions, none of them auto-created. You connect to the primary instance and run CREATE EXTENSION — but a handful of extensions first need an instance-level database flag (for example alloydb.enable_pg_cron or google_columnar_engine.enabled) set before the CREATE EXTENSION call will succeed.
Run from a psql session connected to the primary instance as a user with the alloydbsuperuser role.
-- pgvector needs no flag — just create it
CREATE EXTENSION IF NOT EXISTS vector;
-- ScaNN vector index (depends on vector; CASCADE pulls it in)
CREATE EXTENSION IF NOT EXISTS alloydb_scann CASCADE;
-- Verify what's installed
SELECT extname, extversion FROM pg_extension ORDER BY extname;Flag-gated extensions need the flag set first. Note: --database-flags OVERWRITES the instance's entire flag list, so include every flag you want to keep in one call.
# Set the database flags an extension requires, then CREATE EXTENSION in SQL.
# Example: turn on the columnar engine and pg_cron.
gcloud alloydb instances update INSTANCE_ID \
--database-flags=google_columnar_engine.enabled=on,alloydb.enable_pg_cron=on \
--region=REGION \
--cluster=CLUSTER_ID \
--project=PROJECT_ID
# Then, connected to the primary instance:
# CREATE EXTENSION IF NOT EXISTS pg_cron;Terraform provisions the cluster/instance; extensions themselves are still enabled via the gcloud/API flag mechanism plus CREATE EXTENSION (e.g. through a provisioner or migration step).
resource "google_alloydb_cluster" "default" {
cluster_id = "my-cluster"
location = "us-central1"
database_version = "POSTGRES_16"
}
resource "google_alloydb_instance" "primary" {
cluster = google_alloydb_cluster.default.name
instance_id = "my-primary"
instance_type = "PRIMARY"
# Flag-gated extensions: set their database flags here, then run
# CREATE EXTENSION against the instance (migration/provisioner).
database_flags = {
"google_columnar_engine.enabled" = "on"
}
}These extensions ship enabled by default — no CREATE EXTENSION needed.
Proprietary extensions that exist only on Google Cloud AlloyDB for PostgreSQL, not part of the open-source PostgreSQL ecosystem.
Google's ScaNN-based nearest-neighbor vector index for pgvector columns — high-recall, low-latency similarity search at scale. Available on PG 14-17.
DocsIn-memory columnar acceleration that transparently speeds up analytical and HTAP queries; enable it with the google_columnar_engine.enabled=on database flag.
DocsCall machine-learning models and generate embeddings or predictions directly from SQL, using models hosted by Google, OpenAI, or Anthropic.
DocsAlloyDB AI natural-language-to-SQL — turn plain-English questions into SQL against your schema using built-in LLM tooling.
DocsExtensions you might expect that aren't available on Google Cloud AlloyDB for PostgreSQL, with workarounds where they exist.
timescaledbWhy missing: timescaledb is not part of the AlloyDB extension allow-list, and managed AlloyDB only lets you enable extensions Google has vetted — there is no way to install it yourself.
Alternative: For time-series workloads, lean on native Postgres partitioning with pg_partman (which AlloyDB does support), or run TimescaleDB self-hosted or on a provider like Crunchy Bridge that ships it.
citusWhy missing: citus (distributed/sharded Postgres) is not in the AlloyDB catalog. AlloyDB takes a different scaling approach — a disaggregated storage layer with read pool instances and a columnar engine rather than horizontal sharding.
Alternative: Scale reads with AlloyDB read pool instances and accelerate analytics with the built-in columnar engine; for true sharding, use a dedicated distributed Postgres such as Citus on Azure Cosmos DB for PostgreSQL.
pgsql_httpWhy missing: The http/pgsql-http extension, along with pg_graphql and Supabase's wrappers FDW framework, is not on the AlloyDB allow-list — outbound HTTP and auto-generated GraphQL are not part of the managed surface.
Alternative: Call external services from your application tier, or use google_ml_integration for managed model/embedding calls and the available FDWs (postgres_fdw, oracle_fdw, bigquery_fdw) for cross-system queries.
Managed AlloyDB exposes a fixed allow-list of extensions — every extension on that list is available on every AlloyDB instance, and nothing outside it can be installed. Only a user with the alloydbsuperuser role can run CREATE EXTENSION, and even then only against the vetted list. (AlloyDB Omni, the self-hosted variant, is different — it permits some manual installs such as orafce and PostGIS — but managed AlloyDB does not.)
1bench is a modern GUI client for PostgreSQL — connect to your Google Cloud AlloyDB for PostgreSQL instance, install extensions, write queries, and inspect schemas without leaving the IDE.
Try 1bench for PostgreSQL