Join us on YugabyteDB Community Slack
Star us on
Get Started
Slack
GitHub
Get Started
v2.13 (preview) v2.12 (stable) v2.8 (earlier version) v2.6 (earlier version) v2.4 (earlier version) Unsupported versions
  • YUGABYTEDB CORE
    • Quick start
      • 1. Install YugabyteDB
      • 2. Create a local cluster
      • 3. Explore distributed SQL
      • 4. Build an application
        • Java
        • Node.js
        • Go
        • Python
        • Ruby
        • C#
        • PHP
        • C++
        • C
        • Scala
        • Rust
    • Explore
      • SQL features
        • SQL Feature Support
        • PostgreSQL Compatibility
        • Foreign Data Wrappers
        • Schemas and Tables
        • Data Types
        • Data Manipulation
        • Queries and Joins
        • Expressions and Operators
        • Stored Procedures
        • Triggers
        • Advanced features
          • Cursors
          • Table Partitioning
          • Views
          • Savepoints
          • Collations
        • Going beyond SQL
          • Follower reads
          • Tablespaces
        • PostgreSQL extensions
      • Fault tolerance
      • Horizontal scalability
        • Scaling Transactions
        • Sharding Data
      • Transactions
        • Distributed Transactions
        • Isolation Levels
        • Explicit Locking
      • Indexes and Constraints
        • Primary keys
        • Foreign keys
        • Secondary indexes
        • Unique indexes
        • Partial indexes
        • Expression indexes
        • Covering indexes
        • GIN indexes
        • Other constraints
      • JSON support
      • Multi-region deployments
        • Sync replication (3+ regions)
        • Async Replication (2+ regions)
        • Row-Level Geo-Partitioning
        • Read replicas
      • Query tuning
        • Introduction
        • Get query statistics using pg_stat_statements
        • Viewing live queries with pg_stat_activity
        • Analyzing queries with EXPLAIN
        • Optimizing YSQL queries using pg_hint_plan
      • Cluster management
        • Point-in-time recovery
      • Change data capture (CDC)
        • Debezium connector
        • Java CDC console
      • Security
      • Observability
        • Prometheus Integration
        • Grafana Dashboard
    • Drivers and ORMs
      • Java
        • JDBC drivers
        • Hibernate ORM
        • Supported versions
      • Go
        • Go drivers
        • Go ORMs
        • Supported versions
      • C#
        • C# drivers
        • C# ORMs
        • Supported versions
      • NodeJS
        • NodeJS drivers
        • NodeJS ORMs
        • Supported Versions
      • Python
        • Python drivers
        • Python ORMs
        • Supported versions
      • Rust
        • Diesel ORM
    • Develop
      • Learn app development
        • 1. SQL vs NoSQL
        • 2. Data modeling
        • 3. Data types
        • 4. ACID transactions
        • 5. Aggregations
        • 6. Batch operations
        • 7. Date and time
        • 8. Strings and text
        • 9. TTL for data expiration
      • Real-world examples
        • E-Commerce app
        • IoT fleet management
      • Explore sample apps
      • Best practices
      • Cloud-native development
        • Codespaces
        • Gitpod
    • Migrate
      • Migration process overview
      • Migrate from PostgreSQL
        • Convert a PostgreSQL schema
        • Migrate a PostgreSQL application
        • Export PostgreSQL data
        • Prepare a cluster
        • Import PostgreSQL data
        • Verify Migration
    • Deploy
      • Deployment checklist
      • Manual deployment
        • 1. System configuration
        • 2. Install software
        • 3. Start YB-Masters
        • 4. Start YB-TServers
        • 5. Verify deployment
      • Kubernetes
        • Single-zone
          • Open Source
          • Amazon EKS
          • Google Kubernetes Engine
          • Azure Kubernetes Service
        • Multi-zone
          • Amazon EKS
          • Google Kubernetes Engine
        • Multi-cluster
          • Google Kubernetes Engine
        • Best practices
        • Connect Clients
      • Docker
      • Public clouds
        • Amazon Web Services
        • Google Cloud Platform
        • Microsoft Azure
      • Multi-DC deployments
        • Three+ data center (3DC)
        • Asynchronous Replication
        • Read replica clusters
    • Benchmark
      • TPC-C
      • sysbench
      • YCSB
      • Key-value workload
      • Large datasets
      • Scalability
        • Scaling queries
      • Resilience
        • Jepsen testing
      • Performance Troubleshooting
    • Secure
      • Security checklist
      • Enable authentication
        • Enable users
        • Configure client authentication
      • Authentication methods
        • Password authentication
        • LDAP authentication
        • Host-based authentication
        • Trust authentication
      • Role-based access control
        • Overview
        • Manage users and roles
        • Grant privileges
        • Row-level security
        • Column-level security
      • Encryption in transit
        • Create server certificates
        • Enable server-to-server encryption
        • Enable client-to-server encryption
        • Connect to clusters
        • TLS and authentication
      • Encryption at rest
      • Column-level encryption
      • Audit logging
        • Configure audit logging
        • Session-Level Audit Logging
        • Object-Level Audit Logging
      • Vulnerability disclosure policy
    • Manage
      • Back up and restore
        • Export and import data
        • Snapshot and restore data
        • Point-in-time recovery
      • Migrate data
        • Bulk import
        • Bulk export
      • Change cluster configuration
      • Diagnostics reporting
      • Upgrade a deployment
      • Grow cluster
    • Troubleshoot
      • Troubleshooting
      • Cluster level issues
        • YCQL connection issues
        • YEDIS connection Issues
        • Recover tserver/master
        • Replace a failed YB-TServer
        • Replace a failed YB-Master
        • Manual remote bootstrap when a majority of peers fail
      • Node level issues
        • Check servers
        • Inspect logs
        • System statistics
        • Disk failure
        • Common error messages
    • Contribute
      • Core database
        • Contribution checklist
        • Build the source
        • Configure a CLion project
        • Run the tests
        • Coding style
  • YUGABYTEDB ANYWHERE
    • Overview
      • Install
      • Configure
    • Install
      • Prerequisites
      • Prepare the environment
      • Install software
      • Prepare nodes
      • Uninstall software
    • Configure
      • Create admin user
      • Configure cloud providers
      • Configure backup target
      • Configure alerts
    • Create deployments
      • Multi-zone universe
      • Multi-region universe
      • Multi-cloud universe
      • Read replica cluster
      • Asynchronous replication
    • Manage deployments
      • Start and stop processes
      • Eliminate an unresponsive node
      • Recover a node
      • Enable high availability
      • Edit configuration flags
      • Edit a universe
      • Delete a universe
      • Configure instance tags
      • Upgrade YugabyteDB
      • Migrate to Helm 3
    • Back up universes
      • Configure backup storage
      • Back up universe data
      • Restore universe data
      • Schedule data backups
    • Security
      • Security checklist
      • Configure ports
      • LDAP authentication
      • Authorization
      • Create a KMS configuration
      • Enable encryption at rest
      • Enable encryption in transit
      • Network security
    • Alerts and monitoring
      • Alerts
      • Live Queries dashboard
      • Slow Queries dashboard
    • Troubleshoot
      • Install and upgrade issues
      • Universe issues
    • Administer
      • Back up YugabyteDB Anywhere
      • Authenticate with LDAP
    • Upgrade
      • Upgrade Kubernetes installation
      • Upgrade using Replicated
  • YUGABYTEDB MANAGED
    • Overview
    • Quick start
      • Create a free cluster
      • Connect to the cluster
      • Explore distributed SQL
      • Build an application
        • Before you begin
        • Java
        • Go
        • Python
        • Node.js
        • C
        • C++
        • C#
        • Ruby
        • Rust
        • PHP
    • Deploy clusters
      • Planning a cluster
      • Create a free cluster
      • Create a standard cluster
      • VPC network
        • Overview
        • VPCs
        • Peering connections
        • Create a VPC Network
    • Secure clusters
      • IP allow lists
      • Database authorization
      • Add database users
      • Encryption in transit
      • Audit account activity
    • Connect to clusters
      • Cloud Shell
      • Client shell
      • Connect applications
    • Alerts and monitoring
      • Alerts
      • Performance metrics
      • Live queries
      • Slow YSQL queries
      • Cluster activity
    • Manage clusters
      • Scale and configure clusters
      • Backup and restore
      • Maintenance windows
      • Create extensions
    • Administration and billing
      • Manage account access
      • Manage billing
      • Cluster costs
    • Example applications
      • Connect a Spring application
      • Connect a YCQL Java application
      • Hasura Cloud
      • Deploy a GraphQL application
    • Security architecture
      • Security architecture
      • Shared responsibility model
    • Troubleshoot
    • YugabyteDB Managed FAQ
    • What's new
  • INTEGRATIONS
    • Apache Kafka
    • Apache Spark
    • Debezium
    • Django REST framework
    • Entity Framework
    • Flyway
    • GORM
    • Hasura
      • Application Development
      • Benchmarking
    • JanusGraph
    • KairosDB
    • Liquibase
    • Metabase
    • Presto
    • Prisma
    • Sequelize
    • Spring Framework
      • Spring Data YugabyteDB
      • Spring Data JPA
      • Spring Data Cassandra
    • SQLAlchemy
    • WSO2 Identity Server
    • YSQL Loader
    • YugabyteDB JDBC driver
  • REFERENCE
    • Architecture
      • Design goals
      • Key concepts
        • Universe
        • YB-TServer Service
        • YB-Master Service
      • Core functions
        • Universe creation
        • Table creation
        • Write IO path
        • Read IO path
        • High availability
      • Layered architecture
      • Query layer
        • Overview
      • DocDB transactions layer
        • Transactions overview
        • Transaction isolation levels
        • Explicit locking
        • Read Committed
        • Single-row transactions
        • Distributed transactions
        • Transactional IO path
      • DocDB sharding layer
        • Hash & range sharding
        • Tablet splitting
        • Colocated tables
      • DocDB replication layer
        • Replication
        • xCluster replication
        • Read replicas
        • Change data capture (CDC)
      • DocDB storage layer
        • Persistence
        • Performance
    • APIs
      • YSQL
        • The SQL language
          • SQL statements
            • ABORT
            • ALTER DATABASE
            • ALTER DEFAULT PRIVILEGES
            • ALTER DOMAIN
            • ALTER FOREIGN DATA WRAPPER
            • ALTER FOREIGN TABLE
            • ALTER GROUP
            • ALTER POLICY
            • ALTER ROLE
            • ALTER SEQUENCE
            • ALTER SERVER
            • ALTER TABLE
            • ALTER USER
            • ANALYZE
            • BEGIN
            • CALL
            • COMMENT
            • COMMIT
            • COPY
            • CREATE AGGREGATE
            • CREATE CAST
            • CREATE DATABASE
            • CREATE DOMAIN
            • CREATE EXTENSION
            • CREATE FOREIGN DATA WRAPPER
            • CREATE FOREIGN TABLE
            • CREATE FUNCTION
            • CREATE GROUP
            • CREATE INDEX
            • CREATE MATERIALIZED VIEW
            • CREATE OPERATOR
            • CREATE OPERATOR CLASS
            • CREATE POLICY
            • CREATE PROCEDURE
            • CREATE ROLE
            • CREATE RULE
            • CREATE SCHEMA
            • CREATE SEQUENCE
            • CREATE SERVER
            • CREATE TABLE
            • CREATE TABLE AS
            • CREATE TRIGGER
            • CREATE TYPE
            • CREATE USER
            • CREATE USER MAPPING
            • CREATE VIEW
            • DEALLOCATE
            • DELETE
            • DO
            • DROP AGGREGATE
            • DROP CAST
            • DROP DATABASE
            • DROP DOMAIN
            • DROP EXTENSION
            • DROP FOREIGN DATA WRAPPER
            • DROP FOREIGN TABLE
            • DROP FUNCTION
            • DROP GROUP
            • DROP MATERIALIZED VIEW
            • DROP OPERATOR
            • DROP OPERATOR CLASS
            • DROP OWNED
            • DROP POLICY
            • DROP PROCEDURE
            • DROP ROLE
            • DROP RULE
            • DROP SEQUENCE
            • DROP SERVER
            • DROP TABLE
            • DROP TRIGGER
            • DROP TYPE
            • DROP USER
            • END
            • EXECUTE
            • EXPLAIN
            • GRANT
            • IMPORT FOREIGN SCHEMA
            • INSERT
            • LOCK
            • PREPARE
            • REASSIGN OWNED
            • REFRESH MATERIALIZED VIEW
            • RELEASE SAVEPOINT
            • RESET
            • REVOKE
            • ROLLBACK
            • ROLLBACK TO SAVEPOINT
            • SAVEPOINT
            • SELECT
            • SET
            • SET CONSTRAINTS
            • SET ROLE
            • SET SESSION AUTHORIZATION
            • SET TRANSACTION
            • SHOW
            • SHOW TRANSACTION
            • TRUNCATE
            • UPDATE
            • VALUES
          • WITH clause
            • WITH clause—SQL syntax and semantics
            • recursive CTE
            • case study—traversing an employee hierarchy
            • traversing general graphs
              • graph representation
              • common code
              • undirected cyclic graph
              • directed cyclic graph
              • directed acyclic graph
              • rooted tree
              • Unique containing paths
              • Stress testing find_paths()
            • case study—Bacon Numbers from IMDb
              • Bacon numbers for synthetic data
              • Bacon numbers for IMDb data
        • Data types
          • Array
            • array[] constructor
            • Literals
              • Text typecasting and literals
              • Array of primitive values
              • Row
              • Array of rows
            • FOREACH loop (PL/pgSQL)
            • array of DOMAINs
            • Functions and operators
              • ANY and ALL
              • Array comparison
              • Array slice operator
              • Array concatenation
              • Array properties
              • array_agg(), unnest(), generate_subscripts()
              • array_fill()
              • array_position(), array_positions()
              • array_remove()
              • array_replace() / set value
              • array_to_string()
              • string_to_array()
          • Binary
          • Boolean
          • Character
          • Date and time
            • Conceptual background
            • Timezones and UTC offsets
              • Catalog views
              • Extended_timezone_names
                • Unrestricted full projection
                • Real timezones with DST
                • Real timezones no DST
                • Synthetic timezones no DST
              • Offset/timezone-sensitive operations
                • Timestamptz to/from timestamp conversion
                • Pure 'day' interval arithmetic
              • Four ways to specify offset
                • Name-resolution rules
                  • 1 case-insensitive resolution
                  • 2 ~names.abbrev never searched
                  • 3 'set timezone' string not resolved in ~abbrevs.abbrev
                  • 4 ~abbrevs.abbrev before ~names.name
                  • Helper functions
              • Syntax contexts for offset
              • Recommended practice
            • Typecasting between date-time and text-values
            • Semantics of the date-time data types
              • Date data type
              • Time data type
              • Plain timestamp and timestamptz
              • Interval data type
                • Interval representation
                  • Ad hoc examples
                  • Representation model
                • Interval value limits
                • Declaring intervals
                • Justify() and extract(epoch...)
                • Interval arithmetic
                  • Interval-interval comparison
                  • Interval-interval addition and subtraction
                  • Interval-number multiplication
                  • Moment-moment overloads of "-"
                  • Moment-interval overloads of "+" and "-"
                • Custom interval domains
                • Interval utility functions
            • Typecasting between date-time datatypes
            • Operators
              • Test comparison overloads
              • Test addition overloads
              • Test subtraction overloads
              • Test multiplication overloads
              • Test division overloads
            • General-purpose functions
              • Creating date-time values
              • Manipulating date-time values
              • Current date-time moment
              • Delaying execution
              • Miscellaneous
                • Function age()
                • Function extract() | date_part()
                • Implementations that model the overlaps operator
            • Formatting functions
            • Case study—SQL stopwatch
            • Download & install the date-time utilities
            • ToC
          • JSON
            • JSON literals
            • Primitive and compound data types
            • Code example conventions
            • Indexes and check constraints
            • Functions & operators
              • ::jsonb, ::json, ::text (typecast)
              • ->, ->>, #>, #>> (JSON subvalues)
              • - and #- (remove)
              • || (concatenation)
              • = (equality)
              • @> and <@ (containment)
              • ? and ?| and ?& (key or value existence)
              • array_to_json()
              • jsonb_agg()
              • jsonb_array_elements()
              • jsonb_array_elements_text()
              • jsonb_array_length()
              • jsonb_build_object()
              • jsonb_build_array()
              • jsonb_each()
              • jsonb_each_text()
              • jsonb_extract_path()
              • jsonb_extract_path_text() and json_extract_path_text()
              • jsonb_object()
              • jsonb_object_agg()
              • jsonb_object_keys()
              • jsonb_populate_record()
              • jsonb_populate_recordset()
              • jsonb_pretty()
              • jsonb_set() and jsonb_insert()
              • jsonb_strip_nulls()
              • jsonb_to_record()
              • jsonb_to_recordset()
              • jsonb_typeof()
              • row_to_json()
              • to_jsonb()
          • Money
          • Numeric
          • Range
          • Serial
          • UUID
        • Functions and operators
          • Aggregate functions
            • Informal functionality overview
            • Invocation syntax and semantics
            • grouping sets, rollup, cube
            • Per function signature and purpose
              • avg(), count(), max(), min(), sum()
              • array_agg(), string_agg(), jsonb_agg(), jsonb_object_agg()
              • bit_and(), bit_or(), bool_and(), bool_or()
              • variance(), var_pop(), var_samp(), stddev(), stddev_pop(), stddev_samp()
              • linear regression
                • covar_pop(), covar_samp(), corr()
                • regr_%()
              • mode(), percentile_disc(), percentile_cont()
              • rank(), dense_rank(), percent_rank(), cume_dist()
            • case study—percentile_cont() and the "68–95–99.7" rule
            • case study—linear regression on COVID data
              • Download the COVIDcast data
              • Ingest the COVIDcast data
                • Inspect the COVIDcast data
                • Copy the .csv files to staging tables
                • Check staged data conforms to the rules
                • Join the staged data into a single table
                • SQL scripts
                  • Create cr_staging_tables()
                  • Create cr_copy_from_scripts()
                  • Create assert_assumptions_ok()
                  • Create xform_to_covidcast_fb_survey_results()
                  • ingest-the-data.sql
              • Analyze the COVIDcast data
                • symptoms vs mask-wearing by day
                • Data for scatter-plot for 21-Oct-2020
                • Scatter-plot for 21-Oct-2020
                • SQL scripts
                  • analysis-queries.sql
                  • synthetic-data.sql
          • currval()
          • lastval()
          • nextval()
          • Window functions
            • Informal functionality overview
            • Invocation syntax and semantics
            • Per function signature and purpose
              • row_number(), rank() and dense_rank()
              • percent_rank(), cume_dist() and ntile()
              • first_value(), nth_value(), last_value()
              • lag(), lead()
              • Tables for the code examples
                • table t1
                • table t2
                • table t3
                • table t4
            • case study—analyzing a normal distribution
              • Bucket allocation scheme
              • do_clean_start.sql
              • cr_show_t4.sql
              • cr_dp_views.sql
              • cr_int_views.sql
              • cr_pr_cd_equality_report.sql
              • cr_bucket_using_width_bucket.sql
              • cr_bucket_dedicated_code.sql
              • do_assert_bucket_ok
              • cr_histogram.sql
              • cr_do_ntile.sql
              • cr_do_percent_rank.sql
              • cr_do_cume_dist.sql
              • do_populate_results.sql
              • do_report_results.sql
              • do_compare_dp_results.sql
              • do_demo.sql
              • Reports
                • Histogram report
                • dp-results
                • compare-dp-results
                • int-results
          • yb_hash_code()
        • Keywords
        • Reserved names
      • YCQL
        • ALTER KEYSPACE
        • ALTER ROLE
        • ALTER TABLE
        • CREATE INDEX
        • CREATE KEYSPACE
        • CREATE ROLE
        • CREATE TABLE
        • CREATE TYPE
        • DROP INDEX
        • DROP KEYSPACE
        • DROP ROLE
        • DROP TABLE
        • DROP TYPE
        • GRANT PERMISSION
        • GRANT ROLE
        • REVOKE PERMISSION
        • REVOKE ROLE
        • USE
        • INSERT
        • SELECT
        • EXPLAIN
        • UPDATE
        • DELETE
        • TRANSACTION
        • TRUNCATE
        • Simple expressions
        • Subscripted expressions
        • Function call
        • Operators
        • BLOB
        • BOOLEAN
        • Collection
        • FROZEN
        • INET
        • Integer and counter
        • Non-integer
        • TEXT
        • DATE, TIME, and TIMESTAMP
        • UUID and TIMEUUID
        • JSONB
        • Date and time
        • BATCH
    • CLIs
      • yb-ctl
      • yb-docker-ctl
      • ysqlsh
      • ycqlsh
      • yb-admin
      • yb-ts-cli
      • ysql_dump
      • ysql_dumpall
    • Configuration
      • yb-tserver
      • yb-master
      • yugabyted
      • Default ports
    • Drivers and ORMs
      • JDBC Drivers
      • C# Drivers
      • Go Drivers
      • Python Drivers
      • Client drivers for YSQL
      • Client drivers for YCQL
    • Connectors
      • Kafka Connect YugabyteDB
    • Third party tools
      • pgAdmin
      • Apache Superset
      • Arctype
      • DBeaver
      • TablePlus
      • DbSchema
      • SQL Workbench/J
      • Cassandra Workbench
    • Sample datasets
      • Chinook
      • Northwind
      • PgExercises
      • SportsDB
      • Retail Analytics
  • RELEASES
    • Releases overview
      • v2.13 series (preview)
      • v2.12 series (stable)
      • v2.11 series
      • v2.9 series
      • v2.8 series
      • v2.7 series
      • v2.6 series
      • v2.5 series
      • v2.4 series
      • v2.3 series
      • v2.2 series
      • v2.1 series
      • v2.0 series
      • v1.3 series
      • v1.2 series
    • Release versioning
  • FAQ
    • Comparisons
      • Amazon Aurora
      • Google Cloud Spanner
      • CockroachDB
      • TiDB
      • Vitess
      • MongoDB
      • FoundationDB
      • Amazon DynamoDB
      • Azure Cosmos DB
      • Apache Cassandra
      • PostgreSQL
      • Redis in-memory store
      • Apache HBase
    • General FAQ
    • Operations FAQ
    • API compatibility FAQ
    • YugabyteDB Anywhere FAQ
  • MISC
    • YEDIS
      • Quick start
      • Develop
        • Build an application
        • C#
        • C++
        • Go
        • Java
        • NodeJS
        • Python
      • API reference
        • APPEND
        • AUTH
        • CONFIG
        • CREATEDB
        • DELETEDB
        • LISTDB
        • SELECT
        • DEL
        • ECHO
        • EXISTS
        • EXPIRE
        • EXPIREAT
        • FLUSHALL
        • FLUSHDB
        • GET
        • GETRANGE
        • GETSET
        • HDEL
        • HEXISTS
        • HGET
        • HGETALL
        • HINCRBY
        • HKEYS
        • HLEN
        • HMGET
        • HMSET
        • HSET
        • HSTRLEN
        • HVALS
        • INCR
        • INCRBY
        • KEYS
        • MONITOR
        • PEXPIRE
        • PEXPIREAT
        • PTTL
        • ROLE
        • SADD
        • SCARD
        • RENAME
        • SET
        • SETEX
        • PSETEX
        • SETRANGE
        • SISMEMBER
        • SMEMBERS
        • SREM
        • STRLEN
        • ZRANGE
        • TSADD
        • TSCARD
        • TSGET
        • TSLASTN
        • TSRANGEBYTIME
        • TSREM
        • TSREVRANGEBYTIME
        • TTL
        • ZADD
        • ZCARD
        • ZRANGEBYSCORE
        • ZREM
        • ZREVRANGE
        • ZSCORE
        • PUBSUB
        • PUBLISH
        • SUBSCRIBE
        • UNSUBSCRIBE
        • PSUBSCRIBE
        • PUNSUBSCRIBE
    • Legal
      • Third party software
> APIs > YSQL >

Grammar Diagrams

Report a doc issue Suggest new content
    • abort
    • alter_database
    • alter_database_option
    • alter_default_priv
    • abbr_grant_or_revoke
    • a_grant_table
    • grant_table_priv
    • a_grant_seq
    • grant_seq_priv
    • a_grant_func
    • a_grant_type
    • a_grant_schema
    • a_revoke_table
    • a_revoke_seq
    • a_revoke_func
    • a_revoke_type
    • a_revoke_schema
    • alter_domain_default
    • alter_domain_rename
    • alter_foreign_data_wrapper
    • alter_foreign_table
    • alter_foreign_table_action
    • alter_group
    • alter_group_rename
    • alter_policy
    • alter_policy_rename
    • alter_role
    • alter_role_option
    • role_specification
    • alter_role_rename
    • new_role_name
    • alter_role_config
    • config_setting
    • config_param
    • config_value
    • alter_sequence
    • alter_sequence_options
    • seq_data_type
    • restart
    • alter_server
    • alter_table
    • alter_table_action
    • alter_table_constraint
    • alter_column_constraint
    • alter_user
    • alter_user_rename
    • alter_user_config
    • analyze
    • table_and_columns
    • begin
    • call_procedure
    • procedure_argument
    • argument_name
    • comment_on
    • commit
    • copy_from
    • copy_to
    • copy_option
    • create_aggregate
    • create_aggregate_normal
    • create_aggregate_order_by
    • create_aggregate_old
    • aggregate_arg
    • aggregate_normal_option
    • aggregate_order_by_option
    • aggregate_old_option
    • create_cast
    • create_cast_with_function
    • create_cast_without_function
    • create_cast_with_inout
    • cast_signature
    • create_database
    • create_database_options
    • create_domain
    • domain_constraint
    • create_extension
    • create_function
    • arg_decl
    • function_attribute
    • security_kind
    • lang_name
    • implementation_definition
    • sql_stmt_list
    • create_foreign_data_wrapper
    • create_foreign_table
    • foreign_table_elem
    • create_group
    • create_index
    • index_elem
    • create_matview
    • create_operator
    • operator_option
    • create_operator_class
    • operator_class_as
    • create_policy
    • create_procedure
    • procedure_attribute
    • create_rule
    • rule_event
    • command
    • create_role
    • role_option
    • role_name
    • password
    • timestamp
    • connlimit
    • uid
    • create_schema_name
    • create_schema_role
    • schema_element
    • create_sequence
    • sequence_name
    • sequence_options
    • increment
    • minvalue
    • maxvalue
    • start
    • cache
    • create_server
    • create_table
    • split_row
    • table_elem
    • column_constraint
    • table_constraint
    • key_columns
    • hash_columns
    • range_columns
    • references_clause
    • key_action
    • storage_parameters
    • storage_parameter
    • index_parameters
    • create_table_as
    • create_trigger
    • event
    • create_composite_type
    • create_enum_type
    • create_range_type
    • create_base_type
    • create_shell_type
    • composite_type_elem
    • range_type_option
    • base_type_option
    • create_user
    • create_user_mapping
    • user
    • create_view
    • deallocate
    • delete
    • returning_clause
    • returning_expression
    • do
    • drop_aggregate
    • aggregate_signature
    • drop_cast
    • drop_database
    • drop_domain
    • drop_extension
    • drop_foreign_data_wrapper
    • drop_foreign_table
    • drop_function
    • argtype_decl
    • drop_group
    • drop_matview
    • drop_operator
    • operator_signature
    • drop_operator_class
    • drop_policy
    • drop_procedure
    • drop_role
    • drop_rule
    • drop_sequence
    • drop_owned
    • drop_server
    • drop_table
    • drop_type
    • drop_user
    • drop_trigger
    • end
    • execute_statement
    • explain
    • option
    • grant_table
    • grant_table_col
    • grant_seq
    • grant_db
    • grant_domain
    • grant_schema
    • grant_type
    • grant_role
    • grant_role_spec
    • import_foreign_schema
    • remote_schema
    • local_schema
    • insert
    • column_values
    • conflict_target
    • conflict_action
    • lock_table
    • lockmode
    • prepare_statement
    • reassign_owned
    • refresh_matview
    • reset_stmt
    • reset_role
    • reset_session_authorization
    • revoke_table
    • revoke_table_col
    • revoke_seq
    • revoke_db
    • revoke_domain
    • revoke_schema
    • revoke_type
    • revoke_role
    • rollback
    • select
    • with_clause
    • common_table_expression
    • select_expression
    • order_expr
    • set
    • set_constraints
    • set_role
    • set_session_authorization
    • set_transaction
    • transaction_mode
    • isolation_level
    • read_write_mode
    • deferrable_mode
    • show_stmt
    • show_transaction
    • truncate
    • table_expr
    • update
    • update_item
    • column_value
    • values
    • expression_list
    • select_start
    • fn_over_window
    • ordinary_aggregate_fn_invocation
    • within_group_aggregate_fn_invocation
    • window_clause
    • window_definition
    • frame_clause
    • frame_bounds
    • frame_start
    • frame_end
    • frame_bound
    • frame_exclusion
    • offset
    • group_by_clause
    • grouping_element
    • having_clause
    • qualified_name
    • database_name
    • schema_name
    • table_name
    • column_name
    • object_name
    • access_method_name
    • relation_name
    • aggregate_name
    • constraint_name
    • operator_name
    • policy_name
    • procedure_name
    • routine_name
    • rule_name
    • trigger_name
    • domain_name
    • index_method
    • argmode
    • argname
    • argtype
    • function_arguments
    • text_literal
    • int_literal
    • integer
    • numeric_literal
    • value
    • configuration_parameter
    • large_object_oid
    • left_type
    • right_type
    • lang_name
    • name
    • column_names
    • expression
    • boolean
    • collation
    • type_name
    • attribute_name
    • data_type
    • label
    • subtype
    • operator_class_name
    • subtype_operator_class
    • function_name
    • canonical_function
    • subtype_diff_function
    • input_function
    • output_function
    • receive_function
    • send_function
    • type_modifier_input_function
    • type_modifier_output_function
    • internallength
    • alignment
    • storage
    • like_type
    • category
    • preferred
    • default
    • element
    • delimiter
    • collatable
    • param_name
    • param_value
    • code
    • aggregate_argmode
    • sfunc
    • state_data_type
    • base_type
    • state_data_size
    • ffunc
    • combinefunc
    • serialfunc
    • deserialfunc
    • initial_condition
    • msfunc
    • minvfunc
    • mstate_data_type
    • mstate_data_size
    • mffunc
    • minitial_condition
    • sort_operator
    • function_signature
    • source_type
    • target_type
    • com_op
    • neg_op
    • res_proc
    • join_proc
    • strategy_number
    • support_number
    • op_type
    • storage_type
    • using_expression
    • check_expression
    • new_name
    • version
    • extension_name
    • matview_name
    • new_owner
    • alter_fdw_options
    • fdw_name
    • handler_name
    • validator_name
    • fdw_options
    • option_name
    • option_value
    • savepoint_create
    • savepoint_release
    • savepoint_rollback

abort

abort ::= ABORT [ TRANSACTION | WORK ]

ABORTTRANSACTIONWORK

alter_database

alter_database ::= ALTER DATABASE name 
                   [ [ WITH ] alter_database_option [ ... ]
                     | RENAME TO name
                     | OWNER TO { new_owner
                                  | CURRENT_USER
                                  | SESSION_USER }
                     | SET configuration_parameter { TO | = } 
                       { value | DEFAULT }
                     | SET configuration_parameter FROM CURRENT
                     | RESET configuration_parameter
                     | RESET ALL ]

ALTERDATABASEnameWITHalter_database_optionRENAMETOnameOWNERTOnew_ownerCURRENT_USERSESSION_USERSETconfiguration_parameterTO=valueDEFAULTSETconfiguration_parameterFROMCURRENTRESETconfiguration_parameterRESETALL

alter_database_option

alter_database_option ::= ALLOW_CONNECTIONS allowconn
                          | CONNECTION LIMIT connlimit
                          | IS_TEMPLATE istemplate

ALLOW_CONNECTIONSallowconnCONNECTIONLIMITconnlimitIS_TEMPLATEistemplate

alter_default_priv

alter_default_priv ::= ALTER DEFAULT PRIVILEGES 
                       [ FOR { ROLE | USER } role_name [ , ... ] ] 
                       [ IN SCHEMA schema_name [ , ... ] ] 
                       abbr_grant_or_revoke

ALTERDEFAULTPRIVILEGESFORROLEUSER,role_nameINSCHEMA,schema_nameabbr_grant_or_revoke

abbr_grant_or_revoke

abbr_grant_or_revoke ::= a_grant_table
                         | a_grant_seq
                         | a_grant_func
                         | a_grant_type
                         | a_grant_schema
                         | a_revoke_table
                         | a_revoke_seq
                         | a_revoke_func
                         | a_revoke_type
                         | a_revoke_schema

a_grant_tablea_grant_seqa_grant_funca_grant_typea_grant_schemaa_revoke_tablea_revoke_seqa_revoke_funca_revoke_typea_revoke_schema

a_grant_table

a_grant_table ::= GRANT { grant_table_priv [ , ... ]
                          | ALL [ PRIVILEGES ] } ON TABLES TO 
                  grant_role_spec [ , ... ] [ WITH GRANT OPTION ]

GRANT,grant_table_privALLPRIVILEGESONTABLESTO,grant_role_specWITHGRANTOPTION

grant_table_priv

grant_table_priv ::= SELECT
                     | INSERT
                     | UPDATE
                     | DELETE
                     | TRUNCATE
                     | REFERENCES
                     | TRIGGER

SELECTINSERTUPDATEDELETETRUNCATEREFERENCESTRIGGER

a_grant_seq

a_grant_seq ::= GRANT { grant_seq_priv [ , ... ]
                        | ALL [ PRIVILEGES ] } ON SEQUENCES TO 
                grant_role_spec [ , ... ] [ WITH GRANT OPTION ]

GRANT,grant_seq_privALLPRIVILEGESONSEQUENCESTO,grant_role_specWITHGRANTOPTION

grant_seq_priv

grant_seq_priv ::= USAGE | SELECT | UPDATE

USAGESELECTUPDATE

a_grant_func

a_grant_func ::= GRANT { EXECUTE | ALL [ PRIVILEGES ] } ON 
                 { FUNCTIONS | ROUTINES } TO grant_role_spec [ , ... ] 
                 [ WITH GRANT OPTION ]

GRANTEXECUTEALLPRIVILEGESONFUNCTIONSROUTINESTO,grant_role_specWITHGRANTOPTION

a_grant_type

a_grant_type ::= GRANT { USAGE | ALL [ PRIVILEGES ] } ON TYPES TO 
                 grant_role_spec [ , ... ] [ WITH GRANT OPTION ]

GRANTUSAGEALLPRIVILEGESONTYPESTO,grant_role_specWITHGRANTOPTION

a_grant_schema

a_grant_schema ::= GRANT { USAGE | CREATE | ALL [ PRIVILEGES ] } ON 
                   SCHEMAS TO grant_role_spec [ , ... ] 
                   [ WITH GRANT OPTION ]

GRANTUSAGECREATEALLPRIVILEGESONSCHEMASTO,grant_role_specWITHGRANTOPTION

a_revoke_table

a_revoke_table ::= REVOKE [ GRANT OPTION FOR ] 
                   { grant_table_priv [ , ... ] | ALL [ PRIVILEGES ] } 
                   ON TABLES FROM grant_role_spec [ , ... ] 
                   [ CASCADE | RESTRICT ]

REVOKEGRANTOPTIONFOR,grant_table_privALLPRIVILEGESONTABLESFROM,grant_role_specCASCADERESTRICT

a_revoke_seq

a_revoke_seq ::= REVOKE [ GRANT OPTION FOR ] 
                 { grant_seq_priv [ , ... ] | ALL [ PRIVILEGES ] } ON 
                 SEQUENCES FROM grant_role_spec [ , ... ] 
                 [ CASCADE | RESTRICT ]

REVOKEGRANTOPTIONFOR,grant_seq_privALLPRIVILEGESONSEQUENCESFROM,grant_role_specCASCADERESTRICT

a_revoke_func

a_revoke_func ::= REVOKE [ GRANT OPTION FOR ] 
                  { EXECUTE | ALL [ PRIVILEGES ] } ON 
                  { FUNCTIONS | ROUTINES } FROM grant_role_spec 
                  [ , ... ] [ CASCADE | RESTRICT ]

REVOKEGRANTOPTIONFOREXECUTEALLPRIVILEGESONFUNCTIONSROUTINESFROM,grant_role_specCASCADERESTRICT

a_revoke_type

a_revoke_type ::= REVOKE [ GRANT OPTION FOR ] 
                  { USAGE | ALL [ PRIVILEGES ] } ON TYPES FROM 
                  grant_role_spec [ , ... ] [ CASCADE | RESTRICT ]

REVOKEGRANTOPTIONFORUSAGEALLPRIVILEGESONTYPESFROM,grant_role_specCASCADERESTRICT

a_revoke_schema

a_revoke_schema ::= REVOKE [ GRANT OPTION FOR ] 
                    { USAGE | CREATE | ALL [ PRIVILEGES ] } ON SCHEMAS 
                    FROM grant_role_spec [ , ... ] 
                    [ CASCADE | RESTRICT ]

REVOKEGRANTOPTIONFORUSAGECREATEALLPRIVILEGESONSCHEMASFROM,grant_role_specCASCADERESTRICT

alter_domain_default

alter_domain_default ::= ALTER DOMAIN name 
                         { SET DEFAULT expression | DROP DEFAULT }

ALTERDOMAINnameSETDEFAULTexpressionDROPDEFAULT

alter_domain_rename

alter_domain_rename ::= ALTER DOMAIN name RENAME TO name

ALTERDOMAINnameRENAMETOname

alter_foreign_data_wrapper

alter_foreign_data_wrapper ::= ALTER FOREIGN DATA WRAPPER fdw_name 
                               [ HANDLER handler_name | NO HANDLER ] 
                               [ VALIDATOR validator_name
                                 | NO VALIDATOR ] 
                               [ OPTIONS ( alter_fdw_options ) ] 
                               [ OWNER TO new_owner ] 
                               [ RENAME TO new_name ]

ALTERFOREIGNDATAWRAPPERfdw_nameHANDLERhandler_nameNOHANDLERVALIDATORvalidator_nameNOVALIDATOROPTIONS(alter_fdw_options)OWNERTOnew_ownerRENAMETOnew_name

alter_foreign_table

alter_foreign_table ::= ALTER FOREIGN TABLE [ IF EXISTS ] table_name 
                        alter_foreign_table_action [ , ... ]

ALTERFOREIGNTABLEIFEXISTStable_name,alter_foreign_table_action

alter_foreign_table_action

alter_foreign_table_action ::= ADD [ COLUMN ] column_name data_type 
                               [ COLLATE collation ] 
                               [ alter_column_constraint [ ... ] ]
                               | RENAME TO table_name
                               | DROP [ COLUMN ] column_name 
                                 [ RESTRICT | CASCADE ]
                               | OWNER TO new_owner
                               | OPTIONS ( alter_fdw_options )

ADDCOLUMNcolumn_namedata_typeCOLLATEcollationalter_column_constraintRENAMETOtable_nameDROPCOLUMNcolumn_nameRESTRICTCASCADEOWNERTOnew_ownerOPTIONS(alter_fdw_options)

alter_group

alter_group ::= ALTER GROUP role_specification { ADD | DROP } USER 
                role_name [ , ... ]

ALTERGROUProle_specificationADDDROPUSER,role_name

alter_group_rename

alter_group_rename ::= ALTER GROUP role_name RENAME TO new_role_name

ALTERGROUProle_nameRENAMETOnew_role_name

alter_policy

alter_policy ::= ALTER POLICY name ON table_name 
                 [ TO { role_name
                        | PUBLIC
                        | CURRENT_USER
                        | SESSION_USER } [ , ... ] ] 
                 [ USING ( using_expression ) ] 
                 [ WITH CHECK ( check_expression ) ]

ALTERPOLICYnameONtable_nameTO,role_namePUBLICCURRENT_USERSESSION_USERUSING(using_expression)WITHCHECK(check_expression)

alter_policy_rename

alter_policy_rename ::= ALTER POLICY name ON table_name RENAME TO 
                        new_name

ALTERPOLICYnameONtable_nameRENAMETOnew_name

alter_role

alter_role ::= ALTER ROLE role_specification 
               [ [ WITH ] alter_role_option [ , ... ] ]

ALTERROLErole_specificationWITH,alter_role_option

alter_role_option

alter_role_option ::= SUPERUSER
                      | NOSUPERUSER
                      | CREATEDB
                      | NOCREATEDB
                      | CREATEROLE
                      | NOCREATEROLE
                      | INHERIT
                      | NOINHERIT
                      | LOGIN
                      | NOLOGIN
                      | CONNECTION LIMIT connlimit
                      | [ ENCRYPTED ] PASSWORD  ' password ' 
                      | PASSWORD NULL
                      | VALID UNTIL  ' timestamp ' 

SUPERUSERNOSUPERUSERCREATEDBNOCREATEDBCREATEROLENOCREATEROLEINHERITNOINHERITLOGINNOLOGINCONNECTIONLIMITconnlimitENCRYPTEDPASSWORD password PASSWORDNULLVALIDUNTIL timestamp

role_specification

role_specification ::= role_name | CURRENT_USER | SESSION_USER

role_nameCURRENT_USERSESSION_USER

alter_role_rename

alter_role_rename ::= ALTER ROLE role_name RENAME TO new_role_name

ALTERROLErole_nameRENAMETOnew_role_name

new_role_name

new_role_name ::= name

name

alter_role_config

alter_role_config ::= ALTER ROLE { role_specification | ALL } 
                      [ IN DATABASE database_name ] config_setting

ALTERROLErole_specificationALLINDATABASEdatabase_nameconfig_setting

config_setting

config_setting ::= SET config_param { TO | = } 
                   { config_value | DEFAULT }
                   | SET config_param FROM CURRENT
                   | RESET config_param
                   | RESET ALL

SETconfig_paramTO=config_valueDEFAULTSETconfig_paramFROMCURRENTRESETconfig_paramRESETALL

config_param

config_param ::= '<Text Literal>'

<Text Literal>

config_value

config_value ::= '<Text Literal>'

<Text Literal>

alter_sequence

alter_sequence ::= ALTER SEQUENCE [ IF EXISTS ] sequence_name 
                   alter_sequence_options

ALTERSEQUENCEIFEXISTSsequence_namealter_sequence_options

alter_sequence_options

alter_sequence_options ::= [ AS seq_data_type ] 
                           [ INCREMENT [ BY ] increment ] 
                           [ MINVALUE minvalue | NO MINVALUE ] 
                           [ MAXVALUE maxvalue | NO MAXVALUE ] 
                           [ START [ WITH ] start ] 
                           [ RESTART [ [ WITH ] restart ] ] 
                           [ CACHE cache ] 
                           [ OWNED BY table_name.table_column | NONE ]

ASseq_data_typeINCREMENTBYincrementMINVALUEminvalueNOMINVALUEMAXVALUEmaxvalueNOMAXVALUESTARTWITHstartRESTARTWITHrestartCACHEcacheOWNED BYtable_name.table_columnNONE

seq_data_type

seq_data_type ::= 'smallint' | 'integer' | 'bigint'

smallintintegerbigint

restart

restart ::= '<Integer Literal>'

<Integer Literal>

alter_server

alter_server ::= ALTER SERVER server_name [ VERSION server_version ] 
                 [ OPTIONS ( alter_fdw_options ) ] 
                 [ OWNER TO new_owner ]

ALTERSERVERserver_nameVERSIONserver_versionOPTIONS(alter_fdw_options)OWNERTOnew_owner

alter_table

alter_table ::= ALTER TABLE table_expr alter_table_action [ , ... ]

ALTERTABLEtable_expr,alter_table_action

alter_table_action

alter_table_action ::= ADD [ COLUMN ] column_name data_type 
                       [ alter_column_constraint [ ... ] ]
                       | RENAME TO table_name
                       | DROP [ COLUMN ] column_name 
                         [ RESTRICT | CASCADE ]
                       | ADD alter_table_constraint
                       | DROP CONSTRAINT constraint_name 
                         [ RESTRICT | CASCADE ]
                       | RENAME [ COLUMN ] column_name TO column_name
                       | DISABLE ROW LEVEL SECURITY
                       | ENABLE ROW LEVEL SECURITY
                       | FORCE ROW LEVEL SECURITY
                       | NO FORCE ROW LEVEL SECURITY

ADDCOLUMNcolumn_namedata_typealter_column_constraintRENAMETOtable_nameDROPCOLUMNcolumn_nameRESTRICTCASCADEADDalter_table_constraintDROPCONSTRAINTconstraint_nameRESTRICTCASCADERENAMECOLUMNcolumn_nameTOcolumn_nameDISABLEROWLEVELSECURITYENABLEROWLEVELSECURITYFORCEROWLEVELSECURITYNOFORCEROWLEVELSECURITY

alter_table_constraint

alter_table_constraint ::= [ CONSTRAINT constraint_name ] 
                           { CHECK ( expression )
                             | UNIQUE ( column_names ) 
                               index_parameters
                             | FOREIGN KEY ( column_names ) 
                               references_clause } 
                           [ DEFERRABLE | NOT DEFERRABLE ] 
                           [ INITIALLY DEFERRED
                             | INITIALLY IMMEDIATE ]

CONSTRAINTconstraint_nameCHECK(expression)UNIQUE(column_names)index_parametersFOREIGNKEY(column_names)references_clauseDEFERRABLENOTDEFERRABLEINITIALLYDEFERREDINITIALLYIMMEDIATE

alter_column_constraint

alter_column_constraint ::= [ CONSTRAINT constraint_name ] 
                            { NOT NULL
                              | NULL
                              | CHECK ( expression )
                              | DEFAULT expression
                              | UNIQUE index_parameters
                              | references_clause } 
                            [ DEFERRABLE | NOT DEFERRABLE ] 
                            [ INITIALLY DEFERRED
                              | INITIALLY IMMEDIATE ]

CONSTRAINTconstraint_nameNOTNULLNULLCHECK(expression)DEFAULTexpressionUNIQUEindex_parametersreferences_clauseDEFERRABLENOTDEFERRABLEINITIALLYDEFERREDINITIALLYIMMEDIATE

alter_user

alter_user ::= ALTER USER role_specification 
               [ [ WITH ] alter_role_option [ , ... ] ]

ALTERUSERrole_specificationWITH,alter_role_option

alter_user_rename

alter_user_rename ::= ALTER USER role_name RENAME TO new_role_name

ALTERUSERrole_nameRENAMETOnew_role_name

alter_user_config

alter_user_config ::= ALTER USER { role_specification | ALL } 
                      [ IN DATABASE database_name ] config_setting

ALTERUSERrole_specificationALLINDATABASEdatabase_nameconfig_setting

analyze

analyze ::= ANALYZE [ VERBOSE ] [ table_and_columns [ , ... ] ]

ANALYZEVERBOSE,table_and_columns

table_and_columns

table_and_columns ::= table_name [ ( column_name [ , ... ] ) ]

table_name(,column_name)

begin

begin ::= BEGIN [ TRANSACTION | WORK ] [ transaction_mode [ ... ] ]

BEGINTRANSACTIONWORKtransaction_mode

call_procedure

call_procedure ::= CALL qualified_name ( 
                   [ procedure_argument [ , ... ] ] )

CALLqualified_name(,procedure_argument)

procedure_argument

procedure_argument ::= [ argument_name => ] expression

argument_name=>expression

argument_name

argument_name ::= '<Text Literal>'

<Text Literal>

comment_on

comment_on ::= COMMENT ON 
               { ACCESS METHOD access_method_name
                 | AGGREGATE aggregate_name ( aggregate_signature )
                 | CAST ( source_type AS target_type )
                 | COLLATION object_name
                 | COLUMN relation_name . column_name
                 | CONSTRAINT constraint_name ON table_name
                 | CONSTRAINT constraint_name ON DOMAIN domain_name
                 | CONVERSION object_name
                 | DATABASE object_name
                 | DOMAIN object_name
                 | EXTENSION object_name
                 | EVENT TRIGGER object_name
                 | FOREIGN DATA WRAPPER object_name
                 | FOREIGN TABLE object_name
                 | FUNCTION function_name [ ( function_signature ) ]
                 | INDEX object_name
                 | LARGE OBJECT large_object_oid
                 | MATERIALIZED VIEW object_name
                 | OPERATOR operator_name ( operator_signature )
                 | OPERATOR CLASS object_name USING index_method
                 | OPERATOR FAMILY object_name USING index_method
                 | POLICY policy_name ON table_name
                 | [ PROCEDURAL ] LANGUAGE object_name
                 | PROCEDURE procedure_name 
                   [ ( [ [ argmode ] [ argname ] argtype [ , ... ] ] ) ]
                 | PUBLICATION object_name
                 | ROLE object_name
                 | ROUTINE routine_name 
                   [ ( [ [ argmode ] [ argname ] argtype [ , ... ] ] ) ]
                 | RULE rule_name ON table_name
                 | SCHEMA object_name
                 | SEQUENCE object_name
                 | SERVER object_name
                 | STATISTICS object_name
                 | SUBSCRIPTION object_name
                 | TABLE object_name
                 | TABLESPACE object_name
                 | TEXT SEARCH CONFIGURATION object_name
                 | TEXT SEARCH DICTIONARY object_name
                 | TEXT SEARCH PARSER object_name
                 | TEXT SEARCH TEMPLATE object_name
                 | TRANSFORM FOR type_name LANGUAGE lang_name
                 | TRIGGER trigger_name ON table_name
                 | TYPE object_name
                 | VIEW object_name } IS { '<Text Literal>' | NULL }

COMMENTONACCESSMETHODaccess_method_nameAGGREGATEaggregate_name(aggregate_signature)CAST(source_typeAStarget_type)COLLATIONobject_nameCOLUMNrelation_name.column_nameCONSTRAINTconstraint_nameONtable_nameCONSTRAINTconstraint_nameONDOMAINdomain_nameCONVERSIONobject_nameDATABASEobject_nameDOMAINobject_nameEXTENSIONobject_nameEVENTTRIGGERobject_nameFOREIGNDATAWRAPPERobject_nameFOREIGNTABLEobject_nameFUNCTIONfunction_name(function_signature)INDEXobject_nameLARGEOBJECTlarge_object_oidMATERIALIZEDVIEWobject_nameOPERATORoperator_name(operator_signature)OPERATORCLASSobject_nameUSINGindex_methodOPERATORFAMILYobject_nameUSINGindex_methodPOLICYpolicy_nameONtable_namePROCEDURALLANGUAGEobject_namePROCEDUREprocedure_name(argmodeargname,argtype)PUBLICATIONobject_nameROLEobject_nameROUTINEroutine_name(argmodeargname,argtype)RULErule_nameONtable_nameSCHEMAobject_nameSEQUENCEobject_nameSERVERobject_nameSTATISTICSobject_nameSUBSCRIPTIONobject_nameTABLEobject_nameTABLESPACEobject_nameTEXTSEARCHCONFIGURATIONobject_nameTEXTSEARCHDICTIONARYobject_nameTEXTSEARCHPARSERobject_nameTEXTSEARCHTEMPLATEobject_nameTRANSFORMFORtype_nameLANGUAGElang_nameTRIGGERtrigger_nameONtable_nameTYPEobject_nameVIEWobject_nameIS<Text Literal>NULL

commit

commit ::= COMMIT [ TRANSACTION | WORK ]

COMMITTRANSACTIONWORK

copy_from

copy_from ::= COPY table_name [ ( column_name [ , ... ] ) ]  FROM 
              { 'filename' | PROGRAM 'command' | STDIN } 
              [ [ WITH ] ( option [ , ... ] ) ]

COPYtable_name(,column_name)FROMfilenamePROGRAMcommandSTDINWITH(,option)

copy_to

copy_to ::= COPY { table_name [ ( column_names ) ] | ( query ) }  TO 
            { 'filename' | PROGRAM 'command' | STDOUT } 
            [ [ WITH ] ( option [ , ... ] ) ]

COPYtable_name(column_names)(query)TOfilenamePROGRAMcommandSTDOUTWITH(,option)

copy_option

copy_option ::= FORMAT format_name
                | OIDS [ boolean ]
                | FREEZE [ boolean ]
                | DELIMITER 'delimiter_character'
                | NULL 'null_string'
                | HEADER [ boolean ]
                | QUOTE 'quote_character'
                | ESCAPE 'escape_character'
                | FORCE_QUOTE { ( column_names ) | * }
                | FORCE_NOT_NULL ( column_names )
                | FORCE_NULL ( column_names )
                | ENCODING 'encoding_name'
                | ROWS_PER_TRANSACTION integer

FORMATformat_nameOIDSbooleanFREEZEbooleanDELIMITERdelimiter_characterNULLnull_stringHEADERbooleanQUOTEquote_characterESCAPEescape_characterFORCE_QUOTE(column_names)*FORCE_NOT_NULL(column_names)FORCE_NULL(column_names)ENCODINGencoding_nameROWS_PER_TRANSACTIONinteger

create_aggregate

create_aggregate ::= create_aggregate_normal
                     | create_aggregate_order_by
                     | create_aggregate_old

create_aggregate_normalcreate_aggregate_order_bycreate_aggregate_old

create_aggregate_normal

create_aggregate_normal ::= CREATE AGGREGATE aggregate_name ( 
                            { aggregate_arg [ , ... ] | * } ) ( SFUNC 
                            = sfunc , STYPE = state_data_type 
                            [ , aggregate_normal_option [ ... ] ] )

CREATEAGGREGATEaggregate_name(,aggregate_arg*)(SFUNC=sfunc,STYPE=state_data_type,aggregate_normal_option)

create_aggregate_order_by

create_aggregate_order_by ::= CREATE AGGREGATE aggregate_name ( 
                              [ aggregate_arg [ , ... ] ] ORDER BY 
                              aggregate_arg [ , ... ] ) ( SFUNC = 
                              sfunc , STYPE = state_data_type 
                              [ , aggregate_order_by_option [ ... ] ] 
                              )

CREATEAGGREGATEaggregate_name(,aggregate_argORDERBY,aggregate_arg)(SFUNC=sfunc,STYPE=state_data_type,aggregate_order_by_option)

create_aggregate_old

create_aggregate_old ::= CREATE AGGREGATE aggregate_name ( BASETYPE = 
                         base_type , SFUNC = sfunc , STYPE = 
                         state_data_type 
                         [ , aggregate_old_option [ ... ] ] )

CREATEAGGREGATEaggregate_name(BASETYPE=base_type,SFUNC=sfunc,STYPE=state_data_type,aggregate_old_option)

aggregate_arg

aggregate_arg ::= [ aggregate_argmode ] [ argname ] argtype

aggregate_argmodeargnameargtype

aggregate_normal_option

aggregate_normal_option ::= SSPACE = state_data_size
                            | FINALFUNC = ffunc
                            | FINALFUNC_EXTRA
                            | FINALFUNC_MODIFY = 
                              { READ_ONLY | SHAREABLE | READ_WRITE }
                            | COMBINEFUNC = combinefunc
                            | SERIALFUNC = serialfunc
                            | DESERIALFUNC = deserialfunc
                            | INITCOND = initial_condition
                            | MSFUNC = msfunc
                            | MINVFUNC = minvfunc
                            | MSTYPE = mstate_data_type
                            | MSSPACE = mstate_data_size
                            | MFINALFUNC = mffunc
                            | MFINALFUNC_EXTRA
                            | MFINALFUNC_MODIFY = 
                              { READ_ONLY | SHAREABLE | READ_WRITE }
                            | MINITCOND = minitial_condition
                            | SORTOP = sort_operator
                            | PARALLEL = 
                              { SAFE | RESTRICTED | UNSAFE }

SSPACE=state_data_sizeFINALFUNC=ffuncFINALFUNC_EXTRAFINALFUNC_MODIFY=READ_ONLYSHAREABLEREAD_WRITECOMBINEFUNC=combinefuncSERIALFUNC=serialfuncDESERIALFUNC=deserialfuncINITCOND=initial_conditionMSFUNC=msfuncMINVFUNC=minvfuncMSTYPE=mstate_data_typeMSSPACE=mstate_data_sizeMFINALFUNC=mffuncMFINALFUNC_EXTRAMFINALFUNC_MODIFY=READ_ONLYSHAREABLEREAD_WRITEMINITCOND=minitial_conditionSORTOP=sort_operatorPARALLEL=SAFERESTRICTEDUNSAFE

aggregate_order_by_option

aggregate_order_by_option ::= SSPACE = state_data_size
                              | FINALFUNC = ffunc
                              | FINALFUNC_EXTRA
                              | FINALFUNC_MODIFY = 
                                { READ_ONLY | SHAREABLE | READ_WRITE }
                              | INITCOND = initial_condition
                              | PARALLEL = 
                                { SAFE | RESTRICTED | UNSAFE }
                              | HYPOTHETICAL

SSPACE=state_data_sizeFINALFUNC=ffuncFINALFUNC_EXTRAFINALFUNC_MODIFY=READ_ONLYSHAREABLEREAD_WRITEINITCOND=initial_conditionPARALLEL=SAFERESTRICTEDUNSAFEHYPOTHETICAL

aggregate_old_option

aggregate_old_option ::= SSPACE = state_data_size
                         | FINALFUNC = ffunc
                         | FINALFUNC_EXTRA
                         | FINALFUNC_MODIFY = 
                           { READ_ONLY | SHAREABLE | READ_WRITE }
                         | COMBINEFUNC = combinefunc
                         | SERIALFUNC = serialfunc
                         | DESERIALFUNC = deserialfunc
                         | INITCOND = initial_condition
                         | MSFUNC = msfunc
                         | MINVFUNC = minvfunc
                         | MSTYPE = mstate_data_type
                         | MSSPACE = mstate_data_size
                         | MFINALFUNC = mffunc
                         | MFINALFUNC_EXTRA
                         | MFINALFUNC_MODIFY = 
                           { READ_ONLY | SHAREABLE | READ_WRITE }
                         | MINITCOND = minitial_condition
                         | SORTOP = sort_operator

SSPACE=state_data_sizeFINALFUNC=ffuncFINALFUNC_EXTRAFINALFUNC_MODIFY=READ_ONLYSHAREABLEREAD_WRITECOMBINEFUNC=combinefuncSERIALFUNC=serialfuncDESERIALFUNC=deserialfuncINITCOND=initial_conditionMSFUNC=msfuncMINVFUNC=minvfuncMSTYPE=mstate_data_typeMSSPACE=mstate_data_sizeMFINALFUNC=mffuncMFINALFUNC_EXTRAMFINALFUNC_MODIFY=READ_ONLYSHAREABLEREAD_WRITEMINITCOND=minitial_conditionSORTOP=sort_operator

create_cast

create_cast ::= create_cast_with_function
                | create_cast_without_function
                | create_cast_with_inout

create_cast_with_functioncreate_cast_without_functioncreate_cast_with_inout

create_cast_with_function

create_cast_with_function ::= CREATE CAST ( cast_signature ) WITH 
                              FUNCTION function_name 
                              [ ( function_signature ) ] 
                              [ AS ASSIGNMENT | AS IMPLICIT ]

CREATECAST(cast_signature)WITHFUNCTIONfunction_name(function_signature)ASASSIGNMENTASIMPLICIT

create_cast_without_function

create_cast_without_function ::= CREATE CAST ( cast_signature ) 
                                 WITHOUT FUNCTION 
                                 [ AS ASSIGNMENT | AS IMPLICIT ]

CREATECAST(cast_signature)WITHOUTFUNCTIONASASSIGNMENTASIMPLICIT

create_cast_with_inout

create_cast_with_inout ::= CREATE CAST ( cast_signature ) WITH INOUT 
                           [ AS ASSIGNMENT | AS IMPLICIT ]

CREATECAST(cast_signature)WITHINOUTASASSIGNMENTASIMPLICIT

cast_signature

cast_signature ::= source_type AS target_type

source_typeAStarget_type

create_database

create_database ::= CREATE DATABASE name [ create_database_options ]

CREATEDATABASEnamecreate_database_options

create_database_options

create_database_options ::= [ WITH ] [ OWNER [ = ] user_name ]  
                            [ TEMPLATE [ = ] template ]  
                            [ ENCODING [ = ] encoding ]  
                            [ LC_COLLATE [ = ] lc_collate ]  
                            [ LC_CTYPE [ = ] lc_ctype ]  
                            [ ALLOW_CONNECTIONS [ = ] allowconn ]  
                            [ CONNECTION_LIMIT [ = ] connlimit ]  
                            [ IS_TEMPLATE [ = ] istemplate ]  
                            [ COLOCATED [ = ] { 'true' | 'false' } ]

WITHOWNER=user_nameTEMPLATE=templateENCODING=encodingLC_COLLATE=lc_collateLC_CTYPE=lc_ctypeALLOW_CONNECTIONS=allowconnCONNECTION_LIMIT=connlimitIS_TEMPLATE=istemplateCOLOCATED=truefalse

create_domain

create_domain ::= CREATE DOMAIN name [ AS ] data_type 
                  [ DEFAULT expression ] 
                  [ [ domain_constraint [ ... ] ] ]

CREATEDOMAINnameASdata_typeDEFAULTexpressiondomain_constraint

domain_constraint

domain_constraint ::= [ CONSTRAINT constraint_name ] 
                      { NOT NULL | NULL | CHECK ( expression ) }

CONSTRAINTconstraint_nameNOTNULLNULLCHECK(expression)

create_extension

create_extension ::= CREATE EXTENSION [ IF NOT EXISTS ] extension_name 
                     [ WITH ] [ SCHEMA schema_name ] 
                     [ VERSION version ] [ CASCADE ]

CREATEEXTENSIONIFNOTEXISTSextension_nameWITHSCHEMAschema_nameVERSIONversionCASCADE

create_function

create_function ::= CREATE [ OR REPLACE ] FUNCTION function_name ( 
                    [ arg_decl [ , ... ] ] )  
                    [ RETURNS data_type
                      | RETURNS TABLE ( { column_name data_type } 
                        [ , ... ] ) ]  function_attribute [ ... ]

CREATEORREPLACEFUNCTIONfunction_name(,arg_decl)RETURNSdata_typeRETURNSTABLE(,column_namedata_type)function_attribute

arg_decl

arg_decl ::= [ argmode ] [ argname ] argtype 
             [ { DEFAULT | = } expression ]

argmodeargnameargtypeDEFAULT=expression

function_attribute

function_attribute ::= WINDOW
                       | IMMUTABLE
                       | STABLE
                       | VOLATILE
                       | [ NOT ] LEAKPROOF
                       | CALLED ON NULL INPUT
                       | RETURNS NULL ON NULL INPUT
                       | STRICT
                       | PARALLEL { UNSAFE | RESTRICTED | SAFE }
                       | COST int_literal
                       | ROWS int_literal
                       | TRANSFORM { FOR TYPE type_name } [ , ... ]
                       | SET configuration_parameter 
                         { TO value | = value | FROM CURRENT }
                       | [ EXTERNAL ] SECURITY security_kind
                       | LANGUAGE lang_name
                       | AS implementation_definition

WINDOWIMMUTABLESTABLEVOLATILENOTLEAKPROOFCALLEDONNULLINPUTRETURNSNULLONNULLINPUTSTRICTPARALLELUNSAFERESTRICTEDSAFECOSTint_literalROWSint_literalTRANSFORM,FORTYPEtype_nameSETconfiguration_parameterTOvalue=valueFROMCURRENTEXTERNALSECURITYsecurity_kindLANGUAGElang_nameASimplementation_definition

security_kind

security_kind ::= INVOKER | DEFINER

INVOKERDEFINER

lang_name

lang_name ::= SQL | PLPGSQL | C

SQLPLPGSQLC

implementation_definition

implementation_definition ::= ' sql_stmt_list '
                              | ' plpgsql_block_stmt '
                              | ' obj_file ' [ , ' link_symbol ' ]

'sql_stmt_list''plpgsql_block_stmt''obj_file','link_symbol'

sql_stmt_list

sql_stmt_list ::= sql_stmt ; [ sql_stmt ... ]

sql_stmt;sql_stmt;

create_foreign_data_wrapper

create_foreign_data_wrapper ::= CREATE FOREIGN DATA WRAPPER fdw_name 
                                [ HANDLER handler_name | NO HANDLER ] 
                                [ VALIDATOR validator_name
                                  | NO VALIDATOR ] 
                                [ OPTIONS ( fdw_options ) ]

CREATEFOREIGNDATAWRAPPERfdw_nameHANDLERhandler_nameNOHANDLERVALIDATORvalidator_nameNOVALIDATOROPTIONS(fdw_options)

create_foreign_table

create_foreign_table ::= CREATE FOREIGN TABLE [ IF NOT EXISTS ] 
                         table_name ( [ foreign_table_elem [ , ... ] ] 
                         ) SERVER server_name 
                         [ OPTIONS ( fdw_options ) ]

CREATEFOREIGNTABLEIFNOTEXISTStable_name(,foreign_table_elem)SERVERserver_nameOPTIONS(fdw_options)

foreign_table_elem

foreign_table_elem ::= column_name data_type 
                       [ OPTIONS ( fdw_options ) ] 
                       [ COLLATE collation ] 
                       [ column_constraint [ ... ] ]
                       | table_constraint

column_namedata_typeOPTIONS(fdw_options)COLLATEcollationcolumn_constrainttable_constraint

create_group

create_group ::= CREATE GROUP role_name 
                 [ [ WITH ] role_option [ , ... ] ]

CREATEGROUProle_nameWITH,role_option

create_index

create_index ::= CREATE [ UNIQUE ] INDEX [ NONCONCURRENTLY ]  
                 [ [ IF NOT EXISTS ] name ] ON [ ONLY ] table_name  
                 [ USING access_method_name ] ( index_elem [ , ... ] ) 
                  [ INCLUDE ( column_name [ , ... ] ) ]  
                 [ TABLESPACE tablespace_name ]  
                 [ WHERE boolean_expression ]

CREATEUNIQUEINDEXNONCONCURRENTLYIFNOTEXISTSnameONONLYtable_nameUSINGaccess_method_name(,index_elem)INCLUDE(,column_name)TABLESPACEtablespace_nameWHEREboolean_expression

index_elem

index_elem ::= { column_name | ( expression ) } 
               [ operator_class_name ] [ HASH | ASC | DESC ] 
               [ NULLS { FIRST | LAST } ]

column_name(expression)operator_class_nameHASHASCDESCNULLSFIRSTLAST

create_matview

create_matview ::= CREATE MATERIALIZED VIEW [ IF NOT EXISTS ]  
                   matview_name [ ( column_name [ , ... ] ) ]  
                   [ WITH ( storage_parameters ) ]  
                   [ TABLESPACE tablespace ]  AS query 
                   [ WITH [ NO ] DATA ]

CREATEMATERIALIZEDVIEWIFNOTEXISTSmatview_name(,column_name)WITH(storage_parameters)TABLESPACEtablespaceASqueryWITHNODATA

create_operator

create_operator ::= CREATE OPERATOR operator_name ( 
                    { FUNCTION = function_name
                      | PROCEDURE = procedure_name } 
                    [ , operator_option [ ... ] ] )

CREATEOPERATORoperator_name(FUNCTION=function_namePROCEDURE=procedure_name,operator_option)

operator_option

operator_option ::= LEFTARG = left_type
                    | RIGHTARG = right_type
                    | COMMUTATOR = com_op
                    | NEGATOR = neg_op
                    | RESTRICT = res_proc
                    | JOIN = join_proc
                    | HASHES
                    | MERGES

LEFTARG=left_typeRIGHTARG=right_typeCOMMUTATOR=com_opNEGATOR=neg_opRESTRICT=res_procJOIN=join_procHASHESMERGES

create_operator_class

create_operator_class ::= CREATE OPERATOR CLASS operator_class_name 
                          [ DEFAULT ] FOR TYPE data_type USING 
                          index_method AS operator_class_as [ , ... ]

CREATEOPERATORCLASSoperator_class_nameDEFAULTFORTYPEdata_typeUSINGindex_methodAS,operator_class_as

operator_class_as

operator_class_as ::= OPERATOR strategy_number operator_name 
                      [ ( operator_signature ) ] [ FOR SEARCH ]
                      | FUNCTION support_number 
                        [ ( op_type [ , ... ] ) ] function_name ( 
                        function_signature )
                      | STORAGE storage_type

OPERATORstrategy_numberoperator_name(operator_signature)FORSEARCHFUNCTIONsupport_number(,op_type)function_name(function_signature)STORAGEstorage_type

create_policy

create_policy ::= CREATE POLICY name ON table_name 
                  [ AS { PERMISSIVE | RESTRICTIVE } ] 
                  [ FOR { ALL | SELECT | INSERT | UPDATE | DELETE } ] 
                  [ TO { role_name
                         | PUBLIC
                         | CURRENT_USER
                         | SESSION_USER } [ , ... ] ] 
                  [ USING ( using_expression ) ] 
                  [ WITH CHECK ( check_expression ) ]

CREATEPOLICYnameONtable_nameASPERMISSIVERESTRICTIVEFORALLSELECTINSERTUPDATEDELETETO,role_namePUBLICCURRENT_USERSESSION_USERUSING(using_expression)WITHCHECK(check_expression)

create_procedure

create_procedure ::= CREATE [ OR REPLACE ] PROCEDURE name ( 
                     [ arg_decl [ , ... ] ] ) procedure_attribute 
                     [ ... ]

CREATEORREPLACEPROCEDUREname(,arg_decl)procedure_attribute

procedure_attribute

procedure_attribute ::= TRANSFORM { FOR TYPE type_name } [ , ... ]
                        | SET configuration_parameter 
                          { TO value | = value | FROM CURRENT }
                        | [ EXTERNAL ] SECURITY security_kind
                        | LANGUAGE lang_name
                        | AS implementation_definition

TRANSFORM,FORTYPEtype_nameSETconfiguration_parameterTOvalue=valueFROMCURRENTEXTERNALSECURITYsecurity_kindLANGUAGElang_nameASimplementation_definition

create_rule

create_rule ::= CREATE [ OR REPLACE ] RULE rule_name AS ON rule_event 
                TO table_name [ WHERE boolean_expression ] DO 
                [ ALSO | INSTEAD ] { NOTHING
                                     | command
                                     | ( command [ ; ... ] ) }

CREATEORREPLACERULErule_nameASONrule_eventTOtable_nameWHEREboolean_expressionDOALSOINSTEADNOTHINGcommand(;command)

rule_event

rule_event ::= SELECT | INSERT | UPDATE | DELETE

SELECTINSERTUPDATEDELETE

command

command ::= SELECT | INSERT | UPDATE | DELETE | NOTIFY

SELECTINSERTUPDATEDELETENOTIFY

create_role

create_role ::= CREATE ROLE role_name 
                [ [ WITH ] role_option [ , ... ] ]

CREATEROLErole_nameWITH,role_option

role_option

role_option ::= SUPERUSER
                | NOSUPERUSER
                | CREATEDB
                | NOCREATEDB
                | CREATEROLE
                | NOCREATEROLE
                | INHERIT
                | NOINHERIT
                | LOGIN
                | NOLOGIN
                | CONNECTION LIMIT connlimit
                | [ ENCRYPTED ] PASSWORD  ' password ' 
                | PASSWORD NULL
                | VALID UNTIL  ' timestamp ' 
                | IN ROLE role_name [ , ... ]
                | IN GROUP role_name [ , ... ]
                | ROLE role_name [ , ... ]
                | ADMIN role_name [ , ... ]
                | USER role_name [ , ... ]
                | SYSID uid

SUPERUSERNOSUPERUSERCREATEDBNOCREATEDBCREATEROLENOCREATEROLEINHERITNOINHERITLOGINNOLOGINCONNECTIONLIMITconnlimitENCRYPTEDPASSWORD password PASSWORDNULLVALIDUNTIL timestamp INROLE,role_nameINGROUP,role_nameROLE,role_nameADMIN,role_nameUSER,role_nameSYSIDuid

role_name

role_name ::= name

name

password

password ::= '<Text Literal>'

<Text Literal>

timestamp

timestamp ::= '<DateTime Literal>'

<DateTime Literal>

connlimit

connlimit ::= '<Integer Literal>'

<Integer Literal>

uid

uid ::= '<Text Literal>'

<Text Literal>

create_schema_name

create_schema_name ::= CREATE SCHEMA [ IF NOT EXISTS ] schema_name 
                       [ AUTHORIZATION role_specification ] 
                       [ schema_element [ ... ] ]

CREATESCHEMAIFNOTEXISTSschema_nameAUTHORIZATIONrole_specificationschema_element

create_schema_role

create_schema_role ::= CREATE SCHEMA [ IF NOT EXISTS ] AUTHORIZATION 
                       role_specification [ schema_element [ ... ] ]

CREATESCHEMAIFNOTEXISTSAUTHORIZATIONrole_specificationschema_element

schema_element

schema_element ::= '<YSQL DDL statement>'

<YSQL DDL statement>

create_sequence

create_sequence ::= CREATE SEQUENCE [ IF NOT EXISTS ] sequence_name 
                    sequence_options

CREATESEQUENCEIFNOTEXISTSsequence_namesequence_options

sequence_name

sequence_name ::= qualified_name

qualified_name

sequence_options

sequence_options ::= [ INCREMENT [ BY ] increment ] 
                     [ MINVALUE minvalue | NO MINVALUE ] 
                     [ MAXVALUE maxvalue | NO MAXVALUE ] 
                     [ START [ WITH ] start ] [ CACHE cache ] 
                     [ [ NO ] CYCLE ]

INCREMENTBYincrementMINVALUEminvalueNOMINVALUEMAXVALUEmaxvalueNOMAXVALUESTARTWITHstartCACHEcacheNOCYCLE

increment

increment ::= '<Integer Literal>'

<Integer Literal>

minvalue

minvalue ::= '<Integer Literal>'

<Integer Literal>

maxvalue

maxvalue ::= '<Integer Literal>'

<Integer Literal>

start

start ::= '<Integer Literal>'

<Integer Literal>

cache

cache ::= '<Integer Literal>'

<Integer Literal>

create_server

create_server ::= CREATE SERVER [ IF NOT EXISTS ] server_name 
                  [ TYPE server_type ] [ VERSION server_version ] 
                  FOREIGN DATA WRAPPER fdw_name 
                  [ OPTIONS ( fdw_options ) ]

CREATESERVERIFNOTEXISTSserver_nameTYPEserver_typeVERSIONserver_versionFOREIGNDATAWRAPPERfdw_nameOPTIONS(fdw_options)

create_table

create_table ::= CREATE [ TEMPORARY | TEMP ] TABLE [ IF NOT EXISTS ] 
                 table_name ( [ table_elem [ , ... ] ] ) 
                 [ WITH ( { COLOCATED = { 'true' | 'false' }
                            | storage_parameters } )
                   | WITHOUT OIDS ]  [ TABLESPACE tablespace_name ] 
                 [ SPLIT { INTO integer TABLETS
                           | AT VALUES ( split_row [ , ... ] ) } ]

CREATETEMPORARYTEMPTABLEIFNOTEXISTStable_name(,table_elem)WITH(COLOCATED=truefalsestorage_parameters)WITHOUTOIDSTABLESPACEtablespace_nameSPLITINTOintegerTABLETSATVALUES(,split_row)

split_row

split_row ::= ( column_value [ , ... ] )

(,column_value)

table_elem

table_elem ::= column_name data_type [ column_constraint [ ... ] ]
               | table_constraint

column_namedata_typecolumn_constrainttable_constraint

column_constraint

column_constraint ::= [ CONSTRAINT constraint_name ] 
                      { NOT NULL
                        | NULL
                        | CHECK ( expression )
                        | DEFAULT expression
                        | UNIQUE index_parameters
                        | PRIMARY KEY
                        | references_clause } 
                      [ DEFERRABLE | NOT DEFERRABLE ] 
                      [ INITIALLY DEFERRED | INITIALLY IMMEDIATE ]

CONSTRAINTconstraint_nameNOTNULLNULLCHECK(expression)DEFAULTexpressionUNIQUEindex_parametersPRIMARYKEYreferences_clauseDEFERRABLENOTDEFERRABLEINITIALLYDEFERREDINITIALLYIMMEDIATE

table_constraint

table_constraint ::= [ CONSTRAINT constraint_name ] 
                     { CHECK ( expression )
                       | UNIQUE ( column_names ) index_parameters
                       | PRIMARY KEY ( key_columns )
                       | FOREIGN KEY ( column_names ) 
                         references_clause } 
                     [ DEFERRABLE | NOT DEFERRABLE ] 
                     [ INITIALLY DEFERRED | INITIALLY IMMEDIATE ]

CONSTRAINTconstraint_nameCHECK(expression)UNIQUE(column_names)index_parametersPRIMARYKEY(key_columns)FOREIGNKEY(column_names)references_clauseDEFERRABLENOTDEFERRABLEINITIALLYDEFERREDINITIALLYIMMEDIATE

key_columns

key_columns ::= hash_columns [ , range_columns ] | range_columns

hash_columns,range_columnsrange_columns

hash_columns

hash_columns ::= column_name [ HASH ] | ( column_name [ , ... ] ) HASH

column_nameHASH(,column_name)HASH

range_columns

range_columns ::= { column_name { ASC | DESC } } [ , ... ]

,column_nameASCDESC

references_clause

references_clause ::= REFERENCES table_name [ column_name [ , ... ] ] 
                      [ MATCH FULL | MATCH PARTIAL | MATCH SIMPLE ]  
                      [ ON DELETE key_action ] 
                      [ ON UPDATE key_action ]

REFERENCEStable_name,column_nameMATCHFULLMATCHPARTIALMATCHSIMPLEONDELETEkey_actionONUPDATEkey_action

key_action

key_action ::= NO ACTION | RESTRICT | CASCADE | SET NULL | SET DEFAULT

NOACTIONRESTRICTCASCADESETNULLSETDEFAULT

storage_parameters

storage_parameters ::= storage_parameter [ , ... ]

,storage_parameter

storage_parameter

storage_parameter ::= param_name [ = param_value ]

param_name=param_value

index_parameters

index_parameters ::= [ INCLUDE ( column_names ) ] 
                     [ WITH ( storage_parameters ) ] 
                     [ USING INDEX TABLESPACE tablespace_name ]

INCLUDE(column_names)WITH(storage_parameters)USINGINDEXTABLESPACEtablespace_name

create_table_as

create_table_as ::= CREATE TABLE [ IF NOT EXISTS ]  table_name 
                    [ ( column_name [ , ... ] ) ]  AS query 
                    [ WITH [ NO ] DATA ]

CREATETABLEIFNOTEXISTStable_name(,column_name)ASqueryWITHNODATA

create_trigger

create_trigger ::= CREATE TRIGGER name { BEFORE | AFTER | INSTEAD OF } 
                   { event [ OR ... ] } ON table_name 
                   [ FROM table_name ]  [ NOT DEFERRABLE ] 
                   [ FOR [ EACH ] { ROW | STATEMENT } ] 
                   [ WHEN ( boolean_expression ) ]  EXECUTE 
                   { FUNCTION | PROCEDURE } function_name ( 
                   function_arguments )

CREATETRIGGERnameBEFOREAFTERINSTEADOFOReventONtable_nameFROMtable_nameNOTDEFERRABLEFOREACHROWSTATEMENTWHEN(boolean_expression)EXECUTEFUNCTIONPROCEDUREfunction_name(function_arguments)

event

event ::= INSERT
          | UPDATE [ OF column_name [ , ... ] ]
          | DELETE
          | TRUNCATE

INSERTUPDATEOF,column_nameDELETETRUNCATE

create_composite_type

create_composite_type ::= CREATE TYPE type_name AS ( 
                          [ composite_type_elem [ , ... ] ] )

CREATETYPEtype_nameAS(,composite_type_elem)

create_enum_type

create_enum_type ::= CREATE TYPE type_name AS ENUM ( 
                     [ label [ , ... ] ] )

CREATETYPEtype_nameASENUM(,label)

create_range_type

create_range_type ::= CREATE TYPE type_name AS RANGE ( SUBTYPE = 
                      subtype [ , range_type_option [ ... ] ] )

CREATETYPEtype_nameASRANGE(SUBTYPE=subtype,range_type_option)

create_base_type

create_base_type ::= CREATE TYPE type_name ( INPUT = input_function , 
                     OUTPUT = output_function 
                     [ , base_type_option [ ... ] ] )

CREATETYPEtype_name(INPUT=input_function,OUTPUT=output_function,base_type_option)

create_shell_type

create_shell_type ::= CREATE TYPE type_name

CREATETYPEtype_name

composite_type_elem

composite_type_elem ::= attribute_name data_type [ COLLATE collation ]

attribute_namedata_typeCOLLATEcollation

range_type_option

range_type_option ::= SUBTYPE_OPCLASS = subtype_operator_class
                      | COLLATION = collation
                      | CANONICAL = canonical_function
                      | SUBTYPE_DIFF = subtype_diff_function

SUBTYPE_OPCLASS=subtype_operator_classCOLLATION=collationCANONICAL=canonical_functionSUBTYPE_DIFF=subtype_diff_function

base_type_option

base_type_option ::= RECEIVE = receive_function
                     | SEND = send_function
                     | TYPMOD_IN = type_modifier_input_function
                     | TYPMOD_OUT = type_modifier_output_function
                     | INTERNALLENGTH = { internallength | VARIABLE }
                     | PASSEDBYVALUE
                     | ALIGNMENT = alignment
                     | STORAGE = storage
                     | LIKE = like_type
                     | CATEGORY = category
                     | PREFERRED = preferred
                     | DEFAULT = default
                     | ELEMENT = element
                     | DELIMITER = delimiter
                     | COLLATABLE = collatable

RECEIVE=receive_functionSEND=send_functionTYPMOD_IN=type_modifier_input_functionTYPMOD_OUT=type_modifier_output_functionINTERNALLENGTH=internallengthVARIABLEPASSEDBYVALUEALIGNMENT=alignmentSTORAGE=storageLIKE=like_typeCATEGORY=categoryPREFERRED=preferredDEFAULT=defaultELEMENT=elementDELIMITER=delimiterCOLLATABLE=collatable

create_user

create_user ::= CREATE USER role_name 
                [ [ WITH ] role_option [ , ... ] ]

CREATEUSERrole_nameWITH,role_option

create_user_mapping

create_user_mapping ::= CREATE USER MAPPING [ IF NOT EXISTS ] FOR user 
                        SERVER server_name [ OPTIONS ( fdw_options ) ]

CREATEUSERMAPPINGIFNOTEXISTSFORuserSERVERserver_nameOPTIONS(fdw_options)

user

user ::= user_name | USER | CURRENT_USER | PUBLIC

user_nameUSERCURRENT_USERPUBLIC

create_view

create_view ::= CREATE [ OR REPLACE ] VIEW qualified_name 
                [ ( name [ , ... ] ) ] AS select

CREATEORREPLACEVIEWqualified_name(,name)ASselect

deallocate

deallocate ::= DEALLOCATE [ PREPARE ] { name | ALL }

DEALLOCATEPREPAREnameALL

delete

delete ::= [ WITH [ RECURSIVE ] { common_table_expression [ , ... ] } ] 
            DELETE FROM table_expr [ [ AS ] alias ]  
           [ WHERE boolean_expression | WHERE CURRENT OF cursor_name ] 
            [ returning_clause ]

WITHRECURSIVE,common_table_expressionDELETEFROMtable_exprASaliasWHEREboolean_expressionWHERECURRENTOFcursor_namereturning_clause

returning_clause

returning_clause ::= RETURNING { * | { output_expression 
                                     [ [ AS ] output_name ] } 
                                     [ , ... ] }

RETURNING*,output_expressionASoutput_name

returning_expression

returning_expression ::= output_expression [ [ AS ] output_name ]

output_expressionASoutput_name

do

do ::= DO [ LANGUAGE lang_name ] code

DOLANGUAGElang_namecode

drop_aggregate

drop_aggregate ::= DROP AGGREGATE [ IF EXISTS ] 
                   { aggregate_name ( aggregate_signature ) } 
                   [ , ... ] [ CASCADE | RESTRICT ]

DROPAGGREGATEIFEXISTS,aggregate_name(aggregate_signature)CASCADERESTRICT

aggregate_signature

aggregate_signature ::= * | aggregate_arg [ , ... ]
                        | [ aggregate_arg [ , ... ] ] ORDER BY 
                          aggregate_arg [ , ... ]

*,aggregate_arg,aggregate_argORDERBY,aggregate_arg

drop_cast

drop_cast ::= DROP CAST [ IF EXISTS ] ( cast_signature ) 
              [ CASCADE | RESTRICT ]

DROPCASTIFEXISTS(cast_signature)CASCADERESTRICT

drop_database

drop_database ::= DROP DATABASE [ IF EXISTS ] database_name

DROPDATABASEIFEXISTSdatabase_name

drop_domain

drop_domain ::= DROP DOMAIN [ IF EXISTS ] name [ , ... ] 
                [ CASCADE | RESTRICT ]

DROPDOMAINIFEXISTS,nameCASCADERESTRICT

drop_extension

drop_extension ::= DROP EXTENSION [ IF EXISTS ] extension_name 
                   [ , ... ] [ CASCADE | RESTRICT ]

DROPEXTENSIONIFEXISTS,extension_nameCASCADERESTRICT

drop_foreign_data_wrapper

drop_foreign_data_wrapper ::= DROP FOREIGN DATA WRAPPER [ IF EXISTS ] 
                              fdw_name [ CASCADE | RESTRICT ]

DROPFOREIGNDATAWRAPPERIFEXISTSfdw_nameCASCADERESTRICT

drop_foreign_table

drop_foreign_table ::= DROP FOREIGN TABLE [ IF EXISTS ] table_name 
                       [ CASCADE | RESTRICT ]

DROPFOREIGNTABLEIFEXISTStable_nameCASCADERESTRICT

drop_function

drop_function ::= DROP { FUNCTION | PROCEDURE } [ IF EXISTS ]  
                  { name [ ( [ argtype_decl [ , ... ] ] ) ] } 
                  [ , ... ] [ CASCADE | RESTRICT ]

DROPFUNCTIONPROCEDUREIFEXISTS,name(,argtype_decl)CASCADERESTRICT

argtype_decl

argtype_decl ::= [ argmode ] [ argname ] argtype

argmodeargnameargtype

drop_group

drop_group ::= DROP GROUP [ IF EXISTS ] role_name [ , ... ]

DROPGROUPIFEXISTS,role_name

drop_matview

drop_matview ::= DROP MATERIALIZED VIEW [ IF EXISTS ] matview_name  
                 [ CASCADE | RESTRICT ]

DROPMATERIALIZEDVIEWIFEXISTSmatview_nameCASCADERESTRICT

drop_operator

drop_operator ::= DROP OPERATOR [ IF EXISTS ] 
                  { operator_name ( operator_signature ) } [ , ... ] 
                  [ CASCADE | RESTRICT ]

DROPOPERATORIFEXISTS,operator_name(operator_signature)CASCADERESTRICT

operator_signature

operator_signature ::= { left_type | NONE } , { right_type | NONE }

left_typeNONE,right_typeNONE

drop_operator_class

drop_operator_class ::= DROP OPERATOR CLASS [ IF EXISTS ] 
                        operator_class_name USING index_method 
                        [ CASCADE | RESTRICT ]

DROPOPERATORCLASSIFEXISTSoperator_class_nameUSINGindex_methodCASCADERESTRICT

drop_policy

drop_policy ::= DROP POLICY [ IF EXISTS ] name ON table_name 
                [ CASCADE | RESTRICT ]

DROPPOLICYIFEXISTSnameONtable_nameCASCADERESTRICT

drop_procedure

drop_procedure ::= DROP PROCEDURE [ IF EXISTS ]  
                   { name [ ( [ argtype_decl [ , ... ] ] ) ] } 
                   [ , ... ] [ CASCADE | RESTRICT ]

DROPPROCEDUREIFEXISTS,name(,argtype_decl)CASCADERESTRICT

drop_role

drop_role ::= DROP ROLE [ IF EXISTS ] role_name [ , ... ]

DROPROLEIFEXISTS,role_name

drop_rule

drop_rule ::= DROP RULE [ IF EXISTS ] rule_name ON table_name 
              [ CASCADE | RESTRICT ]

DROPRULEIFEXISTSrule_nameONtable_nameCASCADERESTRICT

drop_sequence

drop_sequence ::= DROP SEQUENCE [ IF EXISTS ] sequence_name 
                  [ CASCADE | RESTRICT ]

DROPSEQUENCEIFEXISTSsequence_nameCASCADERESTRICT

drop_owned

drop_owned ::= DROP OWNED BY role_specification [ , ... ] 
               [ CASCADE | RESTRICT ]

DROPOWNEDBY,role_specificationCASCADERESTRICT

drop_server

drop_server ::= DROP SERVER [ IF EXISTS ] server_name 
                [ CASCADE | RESTRICT ]

DROPSERVERIFEXISTSserver_nameCASCADERESTRICT

drop_table

drop_table ::= DROP TABLE [ IF EXISTS ] table_name [ , ... ] 
               [ CASCADE | RESTRICT ]

DROPTABLEIFEXISTS,table_nameCASCADERESTRICT

drop_type

drop_type ::= DROP TYPE [ IF EXISTS ] type_name [ , ... ] 
              [ CASCADE | RESTRICT ]

DROPTYPEIFEXISTS,type_nameCASCADERESTRICT

drop_user

drop_user ::= DROP USER [ IF EXISTS ] role_name [ , ... ]

DROPUSERIFEXISTS,role_name

drop_trigger

drop_trigger ::= DROP TRIGGER [ IF EXISTS ] name ON table_name 
                 [ CASCADE | RESTRICT ]

DROPTRIGGERIFEXISTSnameONtable_nameCASCADERESTRICT

end

end ::= END [ TRANSACTION | WORK ]

ENDTRANSACTIONWORK

execute_statement

execute_statement ::= EXECUTE name [ ( expression [ , ... ] ) ]

EXECUTEname(,expression)

explain

explain ::= EXPLAIN [ [ ANALYZE ] [ VERBOSE ] | ( option [ , ... ] ) ] 
            sql_stmt

EXPLAINANALYZEVERBOSE(,option)sql_stmt

option

option ::= ANALYZE [ boolean ]
           | VERBOSE [ boolean ]
           | COSTS [ boolean ]
           | BUFFERS [ boolean ]
           | TIMING [ boolean ]
           | SUMMARY [ boolean ]
           | FORMAT { TEXT | XML | JSON | YAML }

ANALYZEbooleanVERBOSEbooleanCOSTSbooleanBUFFERSbooleanTIMINGbooleanSUMMARYbooleanFORMATTEXTXMLJSONYAML

grant_table

grant_table ::= GRANT 
                { { SELECT
                    | INSERT
                    | UPDATE
                    | DELETE
                    | TRUNCATE
                    | REFERENCES
                    | TRIGGER } [ , ... ]
                  | ALL [ PRIVILEGES ] } ON 
                { [ TABLE ] table_name [ , ... ]
                  | ALL TABLES IN SCHEMA schema_name [ , ... ] } TO 
                grant_role_spec [ , ... ] [ WITH GRANT OPTION ]

GRANT,SELECTINSERTUPDATEDELETETRUNCATEREFERENCESTRIGGERALLPRIVILEGESONTABLE,table_nameALLTABLESINSCHEMA,schema_nameTO,grant_role_specWITHGRANTOPTION

grant_table_col

grant_table_col ::= GRANT 
                    { { SELECT | INSERT | UPDATE | REFERENCES } ( 
                      column_names ) [ ,(column_names ... ]
                      | ALL [ PRIVILEGES ] ( column_names ) } ON 
                    { [ TABLE ] table_name [ , ... ] } TO 
                    grant_role_spec [ , ... ] [ WITH GRANT OPTION ]

GRANTSELECTINSERTUPDATEREFERENCES(column_names),(column_names)ALLPRIVILEGES(column_names)ONTABLE,table_nameTO,grant_role_specWITHGRANTOPTION

grant_seq

grant_seq ::= GRANT { { USAGE | SELECT | UPDATE } [ , ... ]
                      | ALL [ PRIVILEGES ] } ON 
              { SEQUENCE sequence_name [ , ... ]
                | ALL SEQUENCES IN SCHEMA schema_name 
                  [ , sequence_name [ ... ] ] } TO grant_role_spec 
              [ , ... ] [ WITH GRANT OPTION ]

GRANT,USAGESELECTUPDATEALLPRIVILEGESONSEQUENCE,sequence_nameALLSEQUENCESINSCHEMAschema_name,sequence_nameTO,grant_role_specWITHGRANTOPTION

grant_db

grant_db ::= GRANT { { CREATE | CONNECT | TEMPORARY | TEMP } [ , ... ]
                     | ALL [ PRIVILEGES ] } ON DATABASE database_name 
             [ , ... ] TO grant_role_spec [ , ... ] 
             [ WITH GRANT OPTION ]

GRANT,CREATECONNECTTEMPORARYTEMPALLPRIVILEGESONDATABASE,database_nameTO,grant_role_specWITHGRANTOPTION

grant_domain

grant_domain ::= GRANT { USAGE | ALL [ PRIVILEGES ] } ON DOMAIN 
                 domain_name [ , ... ] TO grant_role_spec [ , ... ] 
                 [ WITH GRANT OPTION ]

GRANTUSAGEALLPRIVILEGESONDOMAIN,domain_nameTO,grant_role_specWITHGRANTOPTION

grant_schema

grant_schema ::= GRANT { { CREATE | USAGE } [ , ... ]
                         | ALL [ PRIVILEGES ] } ON SCHEMA schema_name 
                 [ , ... ] TO grant_role_spec [ , ... ] 
                 [ WITH GRANT OPTION ]

GRANT,CREATEUSAGEALLPRIVILEGESONSCHEMA,schema_nameTO,grant_role_specWITHGRANTOPTION

grant_type

grant_type ::= GRANT { USAGE | ALL [ PRIVILEGES ] } ON TYPE type_name 
               [ , ... ] TO grant_role_spec [ , ... ] 
               [ WITH GRANT OPTION ]

GRANTUSAGEALLPRIVILEGESONTYPE,type_nameTO,grant_role_specWITHGRANTOPTION

grant_role

grant_role ::= GRANT role_name [ , ... ] TO role_name [ , ... ] 
               [ WITH ADMIN OPTION ]

GRANT,role_nameTO,role_nameWITHADMINOPTION

grant_role_spec

grant_role_spec ::= [ GROUP ] role_name
                    | PUBLIC
                    | CURRENT_USER
                    | SESSION_USER

GROUProle_namePUBLICCURRENT_USERSESSION_USER

import_foreign_schema

import_foreign_schema ::= IMPORT FOREIGN SCHEMA remote_schema 
                          [ { LIMIT TO | EXCEPT } ( table_name [ ... ] 
                            ) ] FROM SERVER server_name INTO 
                          local_schema [ OPTIONS ( fdw_options ) ]

IMPORTFOREIGNSCHEMAremote_schemaLIMITTOEXCEPT(table_name)FROMSERVERserver_nameINTOlocal_schemaOPTIONS(fdw_options)

remote_schema

remote_schema ::= '<Text Literal>'

<Text Literal>

local_schema

local_schema ::= '<Text Literal>'

<Text Literal>

insert

insert ::= [ WITH [ RECURSIVE ] { common_table_expression [ , ... ] } ] 
            INSERT INTO table_name [ AS alias ] [ ( column_names ) ]  
           { DEFAULT VALUES
             | VALUES ( column_values ) [ ,(column_values ... ]
             | subquery }  
           [ ON CONFLICT [ conflict_target ] conflict_action ]  
           [ returning_clause ]

WITHRECURSIVE,common_table_expressionINSERTINTOtable_nameASalias(column_names)DEFAULTVALUESVALUES(column_values),(column_values)subqueryONCONFLICTconflict_targetconflict_actionreturning_clause

column_values

column_values ::= { expression | DEFAULT } [ , ... ]

,expressionDEFAULT

conflict_target

conflict_target ::= ( { column_name | expression } [ , ... ] ) 
                    [ WHERE boolean_expression ]
                    | ON CONSTRAINT constraint_name

(,column_nameexpression)WHEREboolean_expressionONCONSTRAINTconstraint_name

conflict_action

conflict_action ::= DO NOTHING
                    | DO UPDATE SET update_item [ , ... ] 
                      [ WHERE boolean_expression ]

DONOTHINGDOUPDATESET,update_itemWHEREboolean_expression

lock_table

lock_table ::= LOCK [ TABLE ] { table_expr [ , ... ] } 
               [ IN lockmode MODE ] [ NOWAIT ]

LOCKTABLE,table_exprINlockmodeMODENOWAIT

lockmode

lockmode ::= ACCESS SHARE
             | ROW SHARE
             | ROW EXCLUSIVE
             | SHARE UPDATE EXCLUSIVE
             | SHARE
             | SHARE ROW EXCLUSIVE
             | EXCLUSIVE
             | ACCESS EXCLUSIVE

ACCESSSHAREROWSHAREROWEXCLUSIVESHAREUPDATEEXCLUSIVESHARESHAREROWEXCLUSIVEEXCLUSIVEACCESSEXCLUSIVE

prepare_statement

prepare_statement ::= PREPARE name [ ( data_type [ , ... ] ) ] AS 
                      sql_stmt

PREPAREname(,data_type)ASsql_stmt

reassign_owned

reassign_owned ::= REASSIGN OWNED BY role_specification [ , ... ] TO 
                   role_specification

REASSIGNOWNEDBY,role_specificationTOrole_specification

refresh_matview

refresh_matview ::= REFRESH MATERIALIZED VIEW [ CONCURRENTLY ]  
                    matview_name [ WITH [ NO ] DATA ]

REFRESHMATERIALIZEDVIEWCONCURRENTLYmatview_nameWITHNODATA

reset_stmt

reset_stmt ::= RESET { name | ALL }

RESETnameALL

reset_role

reset_role ::= RESET ROLE

RESETROLE

reset_session_authorization

reset_session_authorization ::= RESET SESSION AUTHORIZATION

RESETSESSIONAUTHORIZATION

revoke_table

revoke_table ::= REVOKE [ GRANT OPTION FOR ] 
                 { { SELECT
                     | INSERT
                     | UPDATE
                     | DELETE
                     | TRUNCATE
                     | REFERENCES
                     | TRIGGER } [ , ... ]
                   | ALL [ PRIVILEGES ] } ON 
                 { [ TABLE ] table_name [ , ... ]
                   | ALL TABLES IN SCHEMA schema_name [ , ... ] } FROM 
                 { [ GROUP ] role_name | PUBLIC } [ , ... ] 
                 [ CASCADE | RESTRICT ]

REVOKEGRANTOPTIONFOR,SELECTINSERTUPDATEDELETETRUNCATEREFERENCESTRIGGERALLPRIVILEGESONTABLE,table_nameALLTABLESINSCHEMA,schema_nameFROM,GROUProle_namePUBLICCASCADERESTRICT

revoke_table_col

revoke_table_col ::= REVOKE [ GRANT OPTION FOR ] 
                     { { SELECT | INSERT | UPDATE | REFERENCES } ( 
                       column_names ) [ ,(column_names ... ]
                       | ALL [ PRIVILEGES ] ( column_names ) } ON 
                     [ TABLE ] table_name [ , ... ] FROM 
                     { [ GROUP ] role_name | PUBLIC } [ , ... ] 
                     [ CASCADE | RESTRICT ]

REVOKEGRANTOPTIONFORSELECTINSERTUPDATEREFERENCES(column_names),(column_names)ALLPRIVILEGES(column_names)ONTABLE,table_nameFROM,GROUProle_namePUBLICCASCADERESTRICT

revoke_seq

revoke_seq ::= REVOKE [ GRANT OPTION FOR ] 
               { { USAGE | SELECT | UPDATE } [ , ... ]
                 | ALL [ PRIVILEGES ] } ON 
               { SEQUENCE sequence_name [ , ... ]
                 | ALL SEQUENCES IN SCHEMA schema_name [ , ... ] } 
               FROM { [ GROUP ] role_name | PUBLIC } [ , ... ] 
               [ CASCADE | RESTRICT ]

REVOKEGRANTOPTIONFOR,USAGESELECTUPDATEALLPRIVILEGESONSEQUENCE,sequence_nameALLSEQUENCESINSCHEMA,schema_nameFROM,GROUProle_namePUBLICCASCADERESTRICT

revoke_db

revoke_db ::= REVOKE [ GRANT OPTION FOR ] 
              { { CREATE | CONNECT | TEMPORARY | TEMP } [ , ... ]
                | ALL [ PRIVILEGES ] } ON DATABASE database_name 
              [ , ... ] FROM { [ GROUP ] role_name | PUBLIC } 
              [ , ... ] [ CASCADE | RESTRICT ]

REVOKEGRANTOPTIONFOR,CREATECONNECTTEMPORARYTEMPALLPRIVILEGESONDATABASE,database_nameFROM,GROUProle_namePUBLICCASCADERESTRICT

revoke_domain

revoke_domain ::= REVOKE [ GRANT OPTION FOR ] 
                  { USAGE | ALL [ PRIVILEGES ] } ON DOMAIN domain_name 
                  [ , ... ] FROM { [ GROUP ] role_name | PUBLIC } 
                  [ , ... ] [ CASCADE | RESTRICT ]

REVOKEGRANTOPTIONFORUSAGEALLPRIVILEGESONDOMAIN,domain_nameFROM,GROUProle_namePUBLICCASCADERESTRICT

revoke_schema

revoke_schema ::= REVOKE [ GRANT OPTION FOR ] 
                  { { CREATE | USAGE } [ , ... ]
                    | ALL [ PRIVILEGES ] } ON SCHEMA schema_name 
                  [ , ... ] FROM { [ GROUP ] role_name | PUBLIC } 
                  [ , ... ] [ CASCADE | RESTRICT ]

REVOKEGRANTOPTIONFOR,CREATEUSAGEALLPRIVILEGESONSCHEMA,schema_nameFROM,GROUProle_namePUBLICCASCADERESTRICT

revoke_type

revoke_type ::= REVOKE [ GRANT OPTION FOR ] 
                { USAGE | ALL [ PRIVILEGES ] } ON TYPE type_name 
                [ , ... ] FROM { [ GROUP ] role_name | PUBLIC } 
                [ , ... ] [ CASCADE | RESTRICT ]

REVOKEGRANTOPTIONFORUSAGEALLPRIVILEGESONTYPE,type_nameFROM,GROUProle_namePUBLICCASCADERESTRICT

revoke_role

revoke_role ::= REVOKE [ ADMIN OPTION FOR ] role_name [ , ... ] FROM 
                role_name [ , ... ] [ CASCADE | RESTRICT ]

REVOKEADMINOPTIONFOR,role_nameFROM,role_nameCASCADERESTRICT

rollback

rollback ::= ROLLBACK [ TRANSACTION | WORK ]

ROLLBACKTRANSACTIONWORK

select

select ::= [ WITH [ RECURSIVE ] { common_table_expression [ , ... ] } ] 
            SELECT [ ALL | 
                     DISTINCT [ ON { ( expression [ , ... ] ) } ] ] 
           [ * | { { expression
                     | fn_over_window
                     | ordinary_aggregate_fn_invocation
                     | within_group_aggregate_fn_invocation } 
                 [ [ AS ] name ] } [ , ... ] ]  
           [ FROM { from_item [ , ... ] } ]  
           [ WHERE boolean_expression ]  
           [ GROUP BY { grouping_element [ , ... ] } ]  
           [ HAVING boolean_expression ]  
           [ WINDOW { { name AS window_definition } [ , ... ] } ]  
           [ { UNION | INTERSECT | EXCEPT } [ ALL | DISTINCT ] select ] 
            [ ORDER BY { order_expr [ , ... ] } ]  
           [ LIMIT { integer | ALL } ]  
           [ OFFSET integer [ ROW | ROWS ] ]  
           [ FETCH { FIRST | NEXT } integer { ROW | ROWS } ONLY ]  
           [ FOR { UPDATE | NO KEY UPDATE | SHARE | KEY SHARE } 
             [ OF table_name [ , ... ] ] [ SKIP LOCKED ] [ ... ] ]

WITHRECURSIVE,common_table_expressionSELECTALLDISTINCTON(,expression)*,expressionfn_over_windowordinary_aggregate_fn_invocationwithin_group_aggregate_fn_invocationASnameFROM,from_itemWHEREboolean_expressionGROUPBY,grouping_elementHAVINGboolean_expressionWINDOW,nameASwindow_definitionUNIONINTERSECTEXCEPTALLDISTINCTselectORDERBY,order_exprLIMITintegerALLOFFSETintegerROWROWSFETCHFIRSTNEXTintegerROWROWSONLYFORUPDATENO KEY UPDATESHAREKEY SHAREOF,table_nameSKIP LOCKED

with_clause

with_clause ::= [ WITH [ RECURSIVE ] 
                  { common_table_expression [ , ... ] } ]

WITHRECURSIVE,common_table_expression

common_table_expression

common_table_expression ::= name [ ( name [ , ... ] ) ] AS ( 
                            { select
                              | values
                              | insert
                              | update
                              | delete } )

name(,name)AS(selectvaluesinsertupdatedelete)

select_expression

select_expression ::= expression [ [ AS ] name ]

expressionASname

order_expr

order_expr ::= expression [ ASC | DESC | USING operator_name ] 
               [ NULLS { FIRST | LAST } ]

expressionASCDESCUSINGoperator_nameNULLSFIRSTLAST

set

set ::= SET [ SESSION | LOCAL ] { configuration_parameter { TO | = } 
                                  { value | DEFAULT }
                                  | TIME ZONE 
                                    { timezone | LOCAL | DEFAULT } }

SETSESSIONLOCALconfiguration_parameterTO=valueDEFAULTTIMEZONEtimezoneLOCALDEFAULT

set_constraints

set_constraints ::= SET CONSTRAINTS { ALL | name [ , ... ] } 
                    { DEFERRED | IMMEDIATE }

SETCONSTRAINTSALL,nameDEFERREDIMMEDIATE

set_role

set_role ::= SET [ SESSION | LOCAL ] ROLE { role_name | NONE }

SETSESSIONLOCALROLErole_nameNONE

set_session_authorization

set_session_authorization ::= SET [ SESSION | LOCAL ] SESSION 
                              AUTHORIZATION { role_name | DEFAULT }

SETSESSIONLOCALSESSIONAUTHORIZATIONrole_nameDEFAULT

set_transaction

set_transaction ::= SET TRANSACTION transaction_mode [ ... ]

SETTRANSACTIONtransaction_mode

transaction_mode

transaction_mode ::= isolation_level
                     | read_write_mode
                     | deferrable_mode

isolation_levelread_write_modedeferrable_mode

isolation_level

isolation_level ::= ISOLATION LEVEL { READ UNCOMMITTED
                                      | READ COMMITTED
                                      | REPEATABLE READ
                                      | SERIALIZABLE }

ISOLATIONLEVELREADUNCOMMITTEDREADCOMMITTEDREPEATABLEREADSERIALIZABLE

read_write_mode

read_write_mode ::= READ ONLY | READ WRITE

READONLYREADWRITE

deferrable_mode

deferrable_mode ::= [ NOT ] DEFERRABLE

NOTDEFERRABLE

show_stmt

show_stmt ::= SHOW { name | ALL }

SHOWnameALL

show_transaction

show_transaction ::= SHOW TRANSACTION ISOLATION LEVEL

SHOWTRANSACTIONISOLATIONLEVEL

truncate

truncate ::= TRUNCATE [ TABLE ] { table_expr [ , ... ] } 
             [ CASCADE | RESTRICT ]

TRUNCATETABLE,table_exprCASCADERESTRICT

table_expr

table_expr ::= [ ONLY ] table_name [ * ]

ONLYtable_name*

update

update ::= [ WITH [ RECURSIVE ] { common_table_expression [ , ... ] } ] 
            UPDATE table_expr [ [ AS ] alias ]  SET update_item 
           [ , ... ] [ WHERE boolean_expression
                       | WHERE CURRENT OF cursor_name ]  
           [ returning_clause ]

WITHRECURSIVE,common_table_expressionUPDATEtable_exprASaliasSET,update_itemWHEREboolean_expressionWHERECURRENTOFcursor_namereturning_clause

update_item

update_item ::= column_name = column_value
                | ( column_names ) = [ ROW ] ( column_values )
                | ( column_names ) = ( query )

column_name=column_value(column_names)=ROW(column_values)(column_names)=(query)

column_value

column_value ::= expression | DEFAULT

expressionDEFAULT

values

values ::= VALUES ( expression_list ) [ ,(expression_list ... ]  
           [ ORDER BY { order_expr [ , ... ] } ]  
           [ LIMIT { integer | ALL } ]  
           [ OFFSET integer [ ROW | ROWS ] ]  
           [ FETCH { FIRST | NEXT } integer { ROW | ROWS } ONLY ]

VALUES(expression_list),(expression_list)ORDERBY,order_exprLIMITintegerALLOFFSETintegerROWROWSFETCHFIRSTNEXTintegerROWROWSONLY

expression_list

expression_list ::= expression [ , ... ]

,expression

select_start

select_start ::= SELECT [ ALL | 
                          DISTINCT [ ON { ( expression [ , ... ] ) } ] ] 
                 [ * | { { expression
                           | fn_over_window
                           | ordinary_aggregate_fn_invocation
                           | within_group_aggregate_fn_invocation } 
                       [ [ AS ] name ] } [ , ... ] ]

SELECTALLDISTINCTON(,expression)*,expressionfn_over_windowordinary_aggregate_fn_invocationwithin_group_aggregate_fn_invocationASname

fn_over_window

fn_over_window ::= name  ( [ expression [ , ... ] | * ]  
                   [ FILTER ( WHERE boolean_expression ) ] OVER 
                   { window_definition | name }

name(,expression*FILTER(WHEREboolean_expression)OVERwindow_definitionname

ordinary_aggregate_fn_invocation

ordinary_aggregate_fn_invocation ::= name  ( 
                                     { [ ALL | DISTINCT ] expression 
                                       [ , ... ]
                                       | * } 
                                     [ ORDER BY order_expr [ , ... ] ] 
                                     )  [ FILTER ( WHERE 
                                          boolean_expression ) ]

name(ALLDISTINCT,expression*ORDERBY,order_expr)FILTER(WHEREboolean_expression)

within_group_aggregate_fn_invocation

within_group_aggregate_fn_invocation ::= name  ( 
                                         { expression [ , ... ] } )  
                                         WITHIN GROUP ( ORDER BY 
                                         order_expr [ , ... ] )  
                                         [ FILTER ( WHERE 
                                           boolean_expression ) ]

name(,expression)WITHINGROUP(ORDERBY,order_expr)FILTER(WHEREboolean_expression)

window_clause

window_clause ::= WINDOW { { name AS window_definition } [ , ... ] }

WINDOW,nameASwindow_definition

window_definition

window_definition ::= ( [ name ]  
                      [ PARTITION BY order_expr [ , ... ] ]  
                      [ ORDER BY order_expr [ , ... ] ]  
                      [ frame_clause ] )

(namePARTITIONBY,order_exprORDERBY,order_exprframe_clause)

frame_clause

frame_clause ::= [ { RANGE | ROWS | GROUPS } frame_bounds ] 
                 [ frame_exclusion ]

RANGEROWSGROUPSframe_boundsframe_exclusion

frame_bounds

frame_bounds ::= frame_start | BETWEEN frame_start AND frame_end

frame_startBETWEENframe_startANDframe_end

frame_start

frame_start ::= frame_bound

frame_bound

frame_end

frame_end ::= frame_bound

frame_bound

frame_bound

frame_bound ::= UNBOUNDED PRECEDING
                | offset PRECEDING
                | CURRENT ROW
                | offset FOLLOWING
                | UNBOUNDED FOLLOWING

UNBOUNDEDPRECEDINGoffsetPRECEDINGCURRENTROWoffsetFOLLOWINGUNBOUNDEDFOLLOWING

frame_exclusion

frame_exclusion ::= EXCLUDE CURRENT ROW
                    | EXCLUDE GROUP
                    | EXCLUDE TIES
                    | EXCLUDE NO OTHERS

EXCLUDECURRENTROWEXCLUDEGROUPEXCLUDETIESEXCLUDENOOTHERS

offset

offset ::= integer_expression
           | numeric_expression
           | interval_expression

integer_expressionnumeric_expressioninterval_expression

group_by_clause

group_by_clause ::= GROUP BY { grouping_element [ , ... ] }

GROUPBY,grouping_element

grouping_element

grouping_element ::= ( ) | ( expression [ , ... ] )
                     | ROLLUP ( expression [ , ... ] )
                     | CUBE ( expression [ , ... ] )
                     | GROUPING SETS ( grouping_element [ , ... ] )

()(,expression)ROLLUP(,expression)CUBE(,expression)GROUPINGSETS(,grouping_element)

having_clause

having_clause ::= HAVING boolean_expression

HAVINGboolean_expression

qualified_name

qualified_name ::= [ [ database_name . ] schema_name . ] 
                   '<Text Literal>'

database_name.schema_name.<Text Literal>

database_name

database_name ::= '<Text Literal>'

<Text Literal>

schema_name

schema_name ::= '<Text Literal>'

<Text Literal>

table_name

table_name ::= qualified_name

qualified_name

column_name

column_name ::= '<Text Literal>'

<Text Literal>

object_name

object_name ::= name

name

access_method_name

access_method_name ::= name

name

relation_name

relation_name ::= qualified_name

qualified_name

aggregate_name

aggregate_name ::= qualified_name

qualified_name

constraint_name

constraint_name ::= qualified_name

qualified_name

operator_name

operator_name ::= qualified_name

qualified_name

policy_name

policy_name ::= qualified_name

qualified_name

procedure_name

procedure_name ::= qualified_name

qualified_name

routine_name

routine_name ::= qualified_name

qualified_name

rule_name

rule_name ::= qualified_name

qualified_name

trigger_name

trigger_name ::= qualified_name

qualified_name

domain_name

domain_name ::= qualified_name

qualified_name

index_method

index_method ::= '<Text Literal>'

<Text Literal>

argmode

argmode ::= IN | OUT | INOUT | VARIADIC

INOUTINOUTVARIADIC

argname

argname ::= name

name

argtype

argtype ::= type_name

type_name

function_arguments

function_arguments ::= [ text_literal [ , ... ] ]

,text_literal

text_literal

text_literal ::= '<Text Literal>'

<Text Literal>

int_literal

int_literal ::= '<Integer Literal>'

<Integer Literal>

integer

integer ::= '<Integer Literal>'

<Integer Literal>

numeric_literal

numeric_literal ::= '<Numeric Literal>'

<Numeric Literal>

value

value ::= text_literal | numeric_literal | boolean

text_literalnumeric_literalboolean

configuration_parameter

configuration_parameter ::= text_literal

text_literal

large_object_oid

large_object_oid ::= '<Integer Literal>'

<Integer Literal>

left_type

left_type ::= qualified_name | NONE