Vertica-OT-White
  • Vertica Documentation
    • Supported platforms
      • Vertica server & MC
      • Client drivers support
        • Perl driver requirements
        • Python driver requirements
      • Vertica SDKs
      • FIPS 140-2 supported platforms
      • Eon on-premises storage
      • Vertica on AWS
      • Containerized environments
      • Virtualized environments
      • Hadoop integrations
      • Kafka integrations
      • Spark integrations
      • Linux volume manager (LVM)
      • End-of-support notices
    • New features
      • Deprecated & removed functionality
      • New & changed in Vertica 23.4
        • Data export and replication
        • Data load
        • Database management
        • Machine Learning
        • Management Console
        • Security and authentication
        • Stored procedures
        • Upgrade and install
    • Getting started
      • Using this guide
      • Quickstart guide
        • Preparing the installation environment
        • Installing Vertica
        • Creating a DB & users
        • Loading sample data
        • Monitoring the DB
        • Connecting clients
      • Vertica community edition (CE)
      • Vertica interfaces
      • Introducing the VMart example DB
      • Installing & connecting to the VMart example DB
        • Quick installation using a script
        • Advanced installation
          • Step 1: setting up the example environment
          • Step 2: creating the example DB
          • Step 3: connecting to the DB
          • Step 4: defining the DB schema
          • Step 5: loading data
      • Querying data
      • Backing up & restoring the DB
      • Using DB designer to create a comprehensive design
        • Running DB designer with MC
        • Running DB designer with admin tools
      • Restoring the status of your host
      • VMart example DB schema, tables, & scripts
        • Tables
        • Public schema map
          • inventory_fact
          • customer_dimension
          • date_dimension
          • employee_dimension
          • product_dimension
          • promotion_dimension
          • shipping_dimension
          • vendor_dimension
          • warehouse_dimension
        • Store schema map
          • store_orders_fact
          • store_sales_fact
          • store_dimension
        • online_sales schema map
          • online_sales_fact
          • call_center_dimension
          • online_page_dimension
        • Sample scripts
          • vmart_query_01.sql
          • vmart_query_02.sql
          • vmart_query_03.sql
          • vmart_query_04.sql
          • vmart_query_05.sql
          • vmart_query_06.sql
          • vmart_query_07.sql
          • vmart_query_08.sql
          • vmart_query_09.sql
    • Architecture
      • Eon vs. enterprise
      • Eon concepts
        • Eon architecture
        • Shards & subscriptions
        • Subclusters
        • Elasticity
        • Data integrity & high availability
        • Starting, stopping, terminating, & reviving
      • Enterprise concepts
        • K-safety in an enterprise DB
        • High availability with projections
        • High availability with fault groups
    • Setup
      • Plan your setup
      • Set up Vertica on the cloud
        • Vertica on AWS
          • Supported AWS instance types
          • AWS authentication
          • Deploy Vertica using CloudFormation templates
            • CloudFormation template (CFT) overview
            • Creating a Vritual Private Cloud
            • Deploy MC & AWS resources with a CloudFormation template
            • Access MC
          • Manually deploy Vertica on AWS
            • Configure your network
              • Create a placement group, key pair, & VPC
              • Network ACL settings
              • Configure TCP keepalive with AWS network load balancer
              • Create & assign an internet gateway
              • Assign an elastic IP address
              • Create a security group
            • Deploy AWS instances for your Vertica DB cluster
              • Configure & launch an instance
              • Connect to an instance
              • Prepare instances for cluster formation
              • Change instances on AWS
              • Configure storage
              • Create a cluster
              • MC on AWS
        • Vertica on Azure
          • Recommended Azure VM types & OSs
          • Eon on Azure prerequisites
          • Deploy Vertica from the Azure Marketplace
          • Manually deploy Vertica on Azure
            • Configure & launch a new instance
            • Connect to a virtual machine
            • Prepare the virtual machines
            • Configure storage
            • Form a cluster & install Vertica
        • Vertica on GCP
          • Supported GCP machine types
          • Deploy Vertica from the Google cloud marketplace
            • Eon on GCP prerequisites
            • Deploy an enterprise DB in GCP from the marketplace
            • Deploy an MC instance in GCP for Eon
          • Manually deploy an enterprise DB on GCP
      • Set up Vertica on-premises
        • Installation overview & checklist
        • Before you install Vertica
          • Platform & hardware requirements & recommendations
          • Communal storage for on-premises Eon DBs
          • Configure the network
            • Reserved ports
            • Firewall considerations
          • OS config overview
          • Automatically configured OS settings
            • Sysctl
            • Nice limits config
            • min_free_kbytes setting
            • User max open files limit
            • System max open files limit
            • Pam limits
            • pid_max setting
            • User address space limits
            • User file size limit
            • User process limit
            • Maximum memory maps config
          • Manually configured OS settings
            • SUSE control groups config
            • Cron required for scheduled jobs
            • Disk readahead
            • I/O scheduling
            • Enabling or disabling transparent hugepages
            • Check for swappiness
            • Enabling network time protocol (NTP)
            • Enabling chrony or ntpd for red hat 7/CentOS 7 systems
            • SELinux config
            • CPU frequency scaling
            • Enabling or disabling defrag
            • Support tools
          • System user config
            • System user requirements
            • TZ environment variable
            • LANG environment variable settings
            • Package dependencies
        • Install Vertica using the command line
          • Download & install the Vertica server package
          • Linux users created by Vertica
          • Validation scripts
            • Vcpuperf
            • Vioperf
            • Vnetperf
          • Install Vertica with the installation script
            • Install on a FIPS 140-2 enabled machine
            • Specifying disk storage location during installation
            • Perform a basic install
            • install_vertica options
          • Install Vertica silently
          • Enable secure shell (SSH) logins
        • After you install Vertica
      • Upgrading Vertica
        • Before you upgrade
          • Verifying platform requirements
          • Checking catalog storage space
          • Verify license compliance for ORC & Parquet data
          • Backing up & restoring grants
          • Nonsequential FIPS DB upgrades
        • Upgrade Vertica
        • After you upgrade
          • Rebuilding partitioned projections with pre-aggregated data
          • Verifying catalog memory consumption
          • Reinstalling packages
          • Writing bundle metadata to the catalog
          • Upgrading the streaming data scheduler utility
      • Uninstall Vertica
    • Eon
      • Create a DB in Eon
        • Create an Eon DB on-premises with FlashBlade
        • Create an Eon DB on-premises with HDFS
        • Create an Eon DB on-premises with MinIO
        • Manually create an Eon DB on Azure
      • Configuring your Vertica cluster for Eon
      • Migrating an enterprise DB to Eon
      • Managing subclusters
        • Creating subclusters
        • Duplicating a subcluster
        • Adding & removing nodes from subclusters
        • Managing workloads with subclusters
        • Starting & stopping subclusters
        • Altering subcluster settings
        • Removing subclusters
      • Depot management
        • Managing depot caching
        • Resizing depot caching capacity
      • Scaling your Eon DB
        • Change the number of shards in the DB
        • Improving query throughput using subclusters
        • Using elastic crunch scaling to improve query performance
        • Manually choosing an ECS strategy
      • Subcluster sandboxing
        • Creating sandboxes
        • Removing sandboxes
      • Local caching of storage containers
      • Managing an Eon DB in MC
      • Stopping & starting an Eon cluster
      • Terminating an Eon DB cluster
      • Reviving an Eon DB cluster
      • Synchronizing metadata
    • Containerized Vertica
      • Vertica on K8s
      • Images
      • VerticaDB operator
        • Installation
        • Upgrading
        • Helm chart parameters
        • Red Hat OpenShift
        • Prometheus
      • Communal storage
      • Custom resource definitions (CRDs)
        • VerticaDB
        • VerticaAutoscaler
        • EventTrigger
      • CRD parameters
      • Subclusters
        • Scaling subclusters
      • Upgrading Vertica
      • Hybrid clusters
      • Generating a CR from an Eon DB
      • Backup and restore
      • Troubleshooting
        • General
        • Helm
        • Metrics
        • Security
        • VerticaAutoscaler
    • Data exploration
      • Develop a schema
        • Inference
        • Flex tables
      • Table types
      • Schema changes
    • Data load
      • Common use cases
      • Introduction to the COPY statement
      • Global & column-specific options
      • Specifying where to load data from
      • Partitioned data
      • Data formats
        • Delimited data
        • Binary (native) data
        • Native varchar data
        • Fixed-width format data
        • ORC data
        • Parquet data
        • JSON data
        • Avro data
        • Matches from regular expressions
        • Common event format (CEF) data
      • Complex types
        • Structs
        • Arrays
        • Flexible complex types
        • System tables for complex types
      • Schema evolution
      • Handling Non-UTF-8 input
      • Transforming data during loads
      • Distributing a load
      • Using transactions to stage a load
      • Handling messy data
        • Saving load rejections (REJECTED DATA)
        • Saving rejected data to a table
        • Saving load exceptions (EXCEPTIONS)
        • COPY rejected data & exception files
        • COPY LOCAL rejection & exception files
      • Monitoring COPY loads & metrics
      • Automatic load
      • Using load scripts
      • Troubleshooting data loads
      • Working with external data
        • How external tables differ from native tables
        • Creating external tables
        • Querying external tables
        • Monitoring external tables
        • Troubleshooting external tables
    • Data analysis
      • Queries
        • Historical queries
        • Temporary tables
        • SQL queries
        • Arrays & sets (collections)
        • Rows (structs)
        • Subqueries
          • Subqueries used in search conditions
          • Subqueries in the SELECT list
          • Noncorrelated & correlated subqueries
          • Flattening FROM clause subqueries
          • Subqueries in UPDATE & DELETE statements
          • Subquery examples
          • Subquery restrictions
        • Joins
          • Join syntax
          • Join conditions vs. filter conditions
          • Inner joins
            • Equi-joins & non equi-joins
            • Natural joins
            • Cross joins
          • Outer joins
          • Controlling join inputs
          • Range joins
          • Event series joins
            • Sample schema for event series joins examples
            • Writing event series joins
      • Query optimization
        • Initial process for improving query performance
        • Column encoding
          • Improving column compression
          • Using run length encoding
        • Projections for queries with predicates
        • GROUP BY queries
          • GROUP BY implementation options
          • Avoiding GROUP BY resegmentation
        • DISTINCT in a SELECT query list
          • Query has no aggregates in SELECT list
          • COUNT (DISTINCT) & other DISTINCT aggregates
          • Approximate count distinct functions
          • Single DISTINCT aggregates
          • Multiple DISTINCT aggregates
        • JOIN queries
          • Hash joins versus merge joins
          • Identical segmentation
          • Joining variable length string data
        • ORDER BY queries
        • Analytic functions
          • Empty OVER clauses
          • NULL sort order
          • Runtime sorting of NULL values in analytic functions
        • LIMIT queries
        • INSERT-SELECT operations
        • DELETE & UPDATE queries
        • Data collector table queries
      • Views
        • Creating views
        • Using views
        • View execution
        • Managing views
      • Flattened tables
        • Flattened table example
        • Creating flattened tables
        • Required privileges
        • DEFAULT versus SET USING
        • Modifying SET USING & DEFAULT columns
        • Rewriting SET USING queries
        • Impact of SET USING columns on license limits
      • SQL analytics
        • Invoking analytic functions
        • Analytic functions versus aggregate functions
        • Window partitioning
        • Window ordering
        • Window framing
          • Windows with a physical offset (ROWS)
          • Windows with a logical offset (RANGE)
          • Reporting aggregates
        • Named windows
        • Analytic query examples
          • Calculating a median value
          • Getting price differential for two stocks
          • Calculating the moving average
          • Getting latest bid & ask results
        • Event-based windows
        • Sessionization with event-based windows
      • Machine learning for predictive analytics
        • Download the machine learning example data
        • Data preparation
          • Balancing imbalanced data
          • Detect outliers
          • Encoding categorical columns
          • Imputing missing values
          • Normalizing data
          • PCA (principal component analysis)
            • Dimension reduction using PCA
          • Sampling data
          • SVD (singular value decomposition)
            • Computing SVD
        • Regression algorithms
          • Autoregression
          • Linear regression
            • Building a linear regression model
          • Poisson regression
          • Random forest for regression
            • Building a random forest regression model
          • SVM (support vector machine) for regression
            • Building an SVM for regression model
          • XGBoost for regression
        • Classification algorithms
          • Logistic regression
            • Building a logistic regression model
          • Naive bayes
            • Classifying data using naive bayes
          • Random forest for classification
            • Classifying data using random forest
          • SVM (support vector machine) for classification
            • Classifying data using SVM (support vector machine)
          • XGBoost for classification
        • Clustering algorithms
          • K-means
            • Clustering data using k-means
          • K-prototypes
          • Bisecting k-means
            • Clustering data hierarchically using bisecting k-means
        • Time series forecasting
          • ARIMA model example
          • Autoregressive model example
          • Moving-average model example
        • Model management
          • Model versioning
          • Altering models
            • Changing model ownership
            • Moving models to another schema
            • Renaming a model
          • Dropping models
          • Managing model security
          • Viewing model attributes
          • Summarizing models
          • Viewing models
        • Using external models with Vertica
          • TensorFlow models
            • TensorFlow integration & directory structure
            • TensorFlow example
            • tf_model_desc.json overview
          • Using PMML models
            • Exporting Vertica models in PMML format
            • Importing & predicting with PMML models
            • PMML features & attributes
      • Geospatial analytics
        • Best practices for geospatial analytics
        • Spatial objects
          • Supported spatial objects
          • Spatial reference identifiers (SRIDs)
        • Working with spatial objects in tables
          • Defining table columns for spatial data
          • Exporting spatial data from a table
          • Identifying null spatial objects
          • Loading spatial data from shapefiles
          • Loading spatial data into tables using COPY
          • Retrieving spatial data from a table as well-known text (WKT)
          • Working with GeoHash data
          • Spatial joins with ST_Intersects & STV_Intersect
            • Best practices for spatial joins
            • Ensuring polygon validity before creating or refreshing an index
            • STV_Intersect: scalar function vs. transform function
            • Performing spatial joins with STV_Intersect functions
              • Spatial indexes & STV_Intersect
            • When to use ST_Intersects vs. STV_Intersect
              • Performing spatial joins with ST_Intersects
        • Working with spatial objects from clients
          • Using LONG VARCHAR & LONG VARBINARY data types with ODBC
          • Using LONG VARCHAR & LONG VARBINARY data types with JDBC
          • Using GEOMETRY & GEOGRAPHY data types in ODBC
          • Using GEOMETRY & GEOGRAPHY data types in JDBC
          • Using GEOMETRY & GEOGRAPHY data types in ADO.NET
        • OGC spatial definitions
          • Spatial classes
            • Point
            • Multipoint
            • Linestring
            • Multilinestring
            • Polygon
            • Multipolygon
          • Spatial object representations
            • Well-known text (WKT)
            • Well-known binary (WKB)
          • Spatial definitions
            • Boundary
            • Buffer
            • Contains
            • Convex hull
            • Crosses
            • Disjoint
            • Envelope
            • Equals
            • Exterior
            • GeometryCollection
            • Interior
            • Intersection
            • Overlaps
            • Relates
            • Simple
            • Symmetric difference
            • Union
            • Validity
            • Within
        • Spatial data type support limitations
      • Time series analytics
        • Gap filling & interpolation (GFI)
          • Constant interpolation
          • TIMESERIES clause & aggregates
          • Time series rounding
          • Linear interpolation
          • GFI examples
        • Null values in time series data
      • Data aggregation
        • Single-level aggregation
        • Multi-level aggregation
        • Aggregates & functions for multilevel grouping
        • Aggregate expressions for GROUP BY
        • Pre-aggregating data in projections
          • Live aggregate projections
            • Functions supported for live aggregate projections
            • Creating live aggregate projections
            • Live aggregate projection example
          • Top-k projections
            • Creating top-k projections
            • Top-k projection examples
          • Pre-aggregating UDTF results
          • Aggregating data through expressions
            • Querying data through expressions example
          • Aggregation information in system tables
    • Flex tables
      • Getting started
      • Understanding flex tables
      • Creating flex tables
      • Bulk loading data into flex tables
      • Inserting data into flex tables
      • Using flex tables for IDOL data
      • Using flex table parsers
        • Loading columnar tables with flex parsers
        • Loading CSV data
        • Loading delimited data
      • Computing flex table keys
      • Materializing flex tables
      • Updating flex table views
      • Querying flex tables
      • Querying nested data
      • Querying flex views
      • Listing flex tables
    • Data export and replication
      • File export
        • Syntax
        • Partitioning & sorting data
        • Exporting to object stores
        • Exporting to the Linux file system
        • Monitoring exports
      • DB export & import
        • Configuring connection security between clusters
        • Exporting data to another DB
        • Copying data from another Vertica DB
        • Copy & export data on AWS
        • Changing node export addresses
        • Using public & private IP networks
          • Identify the public network to Vertica
          • Identify the DB or nodes used for import/export
        • Handling node failure during copy/export
        • Using EXPORT functions
          • Exporting the catalog
          • Exporting tables
          • Exporting objects
      • Replication
        • Server-based replication
    • Management Console
      • Installing MC
      • Architecture
      • Configuring MC
        • Changing MC or agent ports
        • MC Settings
        • Backing up MC
        • Connecting securely from MC to a Vertica DB
          • MC security
          • Determining the TLS mode of a Vertica DB
          • Configuring TLS while importing a DB on MC
          • MC certificates wizard
          • Configuring TLS for a monitored DB in MC
          • Configuring mutual TLS for MC users
          • Updating TLS security for MC connections
          • Enabling or disabling TLS for a DB in MC
          • Adding TLS certificates in MC
          • Managing TLS certificates in MC
          • Updating a TLS certificate in MC
          • Removing TLS certificates from MC
          • MC icons display DB TLS status
          • Bulk-configure a group of MC users for TLS
        • Upgrading MC manually
        • Upgrading MC automatically on AWS
        • Localizing user interface text
      • Getting started
        • Connecting to MC
        • Toolbar and navigation
        • Home page
        • Creating a cluster
          • Prepare the hosts
          • Create a private key file
          • Cluster installation
          • Validate hosts & create the cluster
          • Create a DB on a cluster
        • Monitoring existing infrastructure
      • Users
        • Roles
        • Database privileges
        • Authentication
        • User administration
      • DB management
        • Creating a DB using MC
        • Provisioning DBs using MC
        • Managing DB clusters
          • Viewing cluster infrastructure
          • Viewing & managing your cluster
          • Importing an existing DB into MC
        • Subclusters in MC
          • Charting subcluster resource usage in MC
          • Viewing subcluster layout in MC
          • Adding subclusters in MC
          • Rebalancing data using MC
          • Subcluster action rules in MC
          • Starting & stopping subclusters in MC
          • Scaling subclusters in MC
          • Terminating subclusters in MC
          • Node action rules in MC
          • Starting, stopping, & restarting nodes in MC
        • Eon on-premises
          • Revive db on FlashBlade using MC
          • Creating an Eon DB on premises with FlashBlade in MC
        • Managing queries using MC
          • About profile data in MC
            • Projection metadata
            • Query phase duration
            • Profile metrics
            • Execution events
            • Optimizer events
          • Profiling queries using MC
          • Viewing profile data in MC
            • Viewing different profile outputs
            • Monitoring profiling progress
            • Expanding & collapsing query path profile data
        • Working with query plans in MC
          • Accessing query plans in MC
          • Query plan view options
          • Expanding & collapsing query paths
          • Clearing query data
          • Viewing projection & column metadata
        • Creating a DB design in MC
          • Using the wizard to create a design
          • Creating a design manually
        • Running queries in MC
        • Working with workload analyzer recommendations in MC
        • Running DB designer using MC
        • Using the MC to replace nodes
        • Import & monitor a DB in a Hadoop environment
      • Cloud platforms
        • Managing an Eon DB in the cloud
        • Amazon Web Services
          • Creating an Eon DB in AWS with MC
          • Creating an enterprise DB in AWS with MC
          • Reviving an Eon DB on AWS in MC
          • Eon volume config defaults for AWS
          • Enterprise volume config defaults for AWS
          • Add nodes to a cluster in AWS using MC
          • Loading data from Amazon S3 using MC
            • About configuring a data load from S3
            • Viewing load history
        • Microsoft Azure
          • Creating an Eon cluster & DB in Azure in MC
          • Eon volume config defaults for Azure
          • Reviving an Eon DB on Azure in MC
        • Google Cloud Platform
          • Instance recommendations
          • Custom image
          • Provision Eon cluster
          • Reviving Eon DB
          • Eon volume config defaults
      • Monitoring with MC
        • Overview page
        • Same-name databases
        • Cluster nodes
        • Node activity
        • Cluster performance
        • Cluster CPU & memory
        • Database storage
        • Subscription status in Eon
        • System resources
          • Query activity
          • Internal sessions
          • User sessions
          • System memory usage
          • System bottlenecks
          • User query phases
          • Table utilization & projections
          • Running queries
          • Catalog memory
        • Resource pools
          • Configuring resource pools
        • Messages & alerts
          • Message center
          • Alert config
          • Setting up SMTP for email alerts
          • Custom alerts
          • Exporting messages & logs
        • Audit log
        • External data sources
        • Depot activity
          • Why monitor the depot?
          • Viewing depot activity
          • Viewing depot efficiency
          • Viewing depot content in MC
          • Depot pinning policies
        • Depot storage
        • Extended monitoring
          • Managing the storage DB
          • Managing extended monitoring on a DB
          • Managing streaming services for extended monitoring
      • Troubleshooting with MC diagnostics
        • Viewing the MC log
        • Exporting the user audit log
        • Restarting MC
        • Resetting MC to pre-configured state
        • Avoiding MC self-signed certificate expiration
      • Uninstalling MC
    • Administrator's guide
      • Administration overview
      • Managing licenses
        • Obtaining a license key file
        • Understanding Vertica licenses
        • Installing or upgrading a license key
          • New Vertica license installations
          • Vertica license changes
        • Viewing your license status
        • Viewing license compliance for Hadoop file formats
        • Moving a cloud installation from by the hour (BTH) to bring your own license (BYOL)
        • Auditing DB size
        • Monitoring DB size for license compliance
        • Managing license warnings & limits
        • Exporting license audit results to CSV
      • Configuring the DB
        • Config procedure
          • Prepare disk storage locations
            • Specifying disk storage location during DB creation
            • Specifying disk storage location on MC
            • Configuring disk usage to optimize performance
            • Using shared storage with Vertica
            • Viewing DB storage information
            • Anti-virus scanning exclusions
          • Disk space requirements for Vertica
          • Disk space requirements for MC
          • Prepare the logical schema script
          • Prepare data files
          • Prepare load scripts
          • Create an optional sample query script
          • Create an empty DB
            • Creating a DB name & password
            • Create a DB using admin tools
          • Create the logical schema
          • Perform a partial data load
          • Test the DB
          • Optimize query performance
          • Complete the data load
          • Test the optimized DB
          • Implement locales for international data sets
            • Specify the default locale for the DB
            • Override the default locale for a session
            • Server versus client locale settings
          • Using time zones with Vertica
          • Change transaction isolation levels
        • Config parameter management
          • Viewing config parameter values
        • Designing a logical schema
          • Using multiple schemas
            • Multiple schema examples
            • Creating schemas
            • Specifying objects in multiple schemas
            • Setting search paths
            • Creating objects that span multiple schemas
          • Tables in schemas
        • Creating a DB design
          • About DB designer
          • How DB designer creates a design
          • DB designer access requirements
          • Logging projection data for DB designer
            • Enabling logging for DB designer
            • Viewing DB designer logs
            • DB designer logs: example data
          • General design settings
          • Building a design
          • Resetting a design
          • Deploying a design
            • Deploying designs using DB designer
            • Deploying designs manually
          • How to create a design
            • Using admin tools to create a design
          • Running DB designer programmatically
            • DB designer function categories
            • Workflow for running DB designer programmatically
            • Privileges for running DB designer functions
            • Resource pool for DB designer users
          • Creating custom designs
            • Custom design process
            • Planning your design
              • Design requirements
              • Determining the number of projections to use
              • Designing for K-safety
                • Requirements for a K-safe physical schema design
                • Requirements for a physical schema design with no K-safety
                • Designing segmented projections for K-safety
                • Designing unsegmented projections for K-Safety
              • Designing for segmentation
            • Design fundamentals
              • Writing & deploying custom projections
              • Designing superprojections
              • Sort order benefits
              • Choosing sort order: best practices
              • Prioritizing column access speed
      • DB users & privileges
        • DB users
          • Types of DB users
            • DB admin user
            • Object owner
            • PUBLIC user
          • Creating a DB user
          • User-level config parameters
          • Locking user accounts
          • Setting & changing user passwords
        • DB roles
          • Predefined DB roles
            • DBADMIN
            • PSEUDOSUPERUSER
            • DBDUSER
            • SYSMONITOR
            • UDXDEVELOPER
            • MLSUPERVISOR
            • PUBLIC
          • Role hierarchy
          • Creating & dropping roles
          • Granting privileges to roles
          • Granting DB roles
          • Revoking DB roles
          • Enabling roles
          • Enabling roles automatically
          • Viewing user roles
        • DB privileges
          • Ownership & implicit privileges
          • Inherited privileges
            • Enabling DB inheritance
            • Enabling schema inheritance
            • Setting privilege inheritance on tables & views
            • Example usage: implementing inherited privileges
          • Default user privileges
          • Effective privileges
          • Privileges required for common DB operations
          • DB object privileges
          • Granting & revoking privileges
            • Superuser privileges
            • Schema owner privileges
            • Object owner privileges
            • Granting privileges
            • Revoking privileges
            • Privilege ownership chains
          • Modifying privileges
          • Viewing privileges granted on objects
        • Access policies
          • Creating column access policies
          • Creating row access policies
          • Access policies & DML operations
          • Access policies & query optimization
          • Managing access policies
      • Using admin tools
        • Running admin tools
        • First login as DB admin
        • Using admin tools interface
        • Notes for remote terminal users
        • Using admin tools help
        • Distributing changes made to admin tools metadata
        • Administration tools & MC
        • Administration tools reference
          • Viewing DB cluster state
          • Connecting to the DB
          • Restarting Vertica on host
          • Config menu options
            • Creating a DB
            • Dropping a DB
            • Viewing a DB
            • Setting the restart policy
            • Installing external procedure executable files
          • Advanced menu options
            • Rolling back the DB to the last good epoch
            • Stopping Vertica on host
            • Killing the Vertica process on host
            • Upgrading a Vertica license key
            • Managing clusters
            • Getting help on admin tools
            • Administration tools metadata
          • Administration tools connection behavior & requirements
          • Writing admin tools scripts
      • Operating the DB
        • Starting the DB
        • Stopping the DB
        • CRC & sort order check
          • Evaluating CRC errors
          • Evaluating sort order errors
      • Working with native tables
        • Creating tables
        • Creating temporary tables
        • Creating a table from other tables
          • Replicating a table
          • Creating a table from a query
        • Immutable tables
        • Disk quotas
        • Managing table columns
          • Renaming columns
          • Changing scalar column data type
            • Changing column width
            • Working with column data conversions
          • Adding a new field to a complex type column
          • Defining column values
        • Altering table definitions
          • Adding table columns
          • Dropping table columns
          • Altering constraint enforcement
          • Renaming tables
          • Moving tables to another schema
          • Changing table ownership
        • Sequences
          • Sequence types compared
          • Named sequences
            • Creating & using named sequences
            • Distributing sequences
            • Altering sequences
            • Dropping sequences
          • IDENTITY sequences
          • Sequence caching
        • Merging table data
          • Basic MERGE example
          • MERGE source options
          • MERGE matching clauses
          • Update & insert filters
          • MERGE optimization
          • MERGE restrictions
        • Removing table data
          • Data removal operations compared
          • Optimizing DELETE & UPDATE
          • Purging deleted data
            • Setting a purge policy
            • Manually purging data
          • Truncating tables
        • Rebuilding tables
        • Dropping tables
      • Managing client connections
        • Limiting the number & length of client connections
        • Drain client connections
        • Connection load balancing
          • About native connection load balancing
          • Classic connection load balancing
            • Enabling & disabling classic connection load balancing
            • Monitoring legacy connection load balancing
          • Connection load balancing policies
            • Creating network addresses
            • Creating connection load balance groups
            • Creating load balancing routing rules
            • Testing connection load balancing policies
            • Load balancing policy examples
            • Viewing load balancing policy configs
            • Maintaining load balancing policies
          • Workload routing
      • Projections
        • Projection types
        • Creating projections
        • Projection naming
        • Auto-projections
        • Unsegmented projections
        • Segmented projections
        • K-safe DB projections
        • Partition range projections
        • Refreshing projections
        • Dropping projections
      • Partitioning tables
        • Defining partitions
          • Partitioning a new table
          • Partitioning existing table data
          • Partition grouping
        • Hierarchical partitioning
        • Partitioning & segmentation
        • Managing partitions
          • Dropping partitions
          • Archiving partitions
          • Swapping partitions
          • Minimizing partitions
          • Viewing partition storage data
        • Active & inactive partitions
        • Partition pruning
      • Constraints
        • Supported constraints
          • Primary key constraints
          • Foreign key constraints
          • Unique constraints
          • Check constraints
          • NOT NULL constraints
        • Setting constraints
        • Dropping constraints
        • Naming constraints
        • Detecting constraint violations
        • Constraint enforcement
          • Levels of constraint enforcement
          • Verifying constraint enforcement
          • Reporting constraint violations
          • Constraint enforcement & locking
          • Constraint enforcement & performance
          • Projections for enforced constraints
          • Constraint enforcement limitations
      • Managing queries
        • Query plans
          • Viewing query plans
            • EXPLAIN-Generated query plans
            • JSON-Formatted query plans
            • Verbose query plans
            • Local query plans
          • Query plan cost estimation
          • Query plan information & structure
            • Query plan statistics
            • Cost & rows path
            • Projection path
            • Join path
            • Path ID
            • Filter path
            • GROUP BY paths
              • GROUPBY HASH query plan
              • GROUPBY PIPELINED query plan
            • Sort path
            • Limit path
            • Data redistribution path
            • Analytic function path
            • Node down information
            • MERGE path
        • Directed queries
          • Creating directed queries
            • Optimizer-generated directed queries
            • Custom directed queries
            • Using optimizer-generated & custom directed queries together
          • Setting hints in annotated queries
          • Ignoring constants in directed queries
          • Rewriting queries
          • Managing directed queries
            • Getting directed queries
            • Identifying active directed queries
            • Activating & deactivating directed queries
            • Exporting directed queries from the catalog
            • Dropping directed queries
          • Batch query plan export
            • Exporting directed queries
            • Importing directed queries
          • Half join & cross join semantics
            • Half-join subquery semantics
            • Complex join semantics
          • Directed query restrictions
      • Transactions
        • Rollback
        • Savepoints
        • READ COMMITTED isolation
        • SERIALIZABLE isolation
      • Vertica DB locks
        • Lock modes
        • Lock examples
        • Deadlocks
        • Troubleshooting locks
      • Using text search
        • Creating a text index
        • Creating a text index on a flex table
        • Searching a text index
        • Dropping a text index
        • Stemmers & tokenizers
          • Vertica stemmers
          • Vertica tokenizers
            • Preconfigured tokenizers
            • Advanced log tokenizer
            • Basic log tokenizer
            • Whitespace log tokenizer
            • ICU tokenizer
          • Configuring a tokenizer
            • Tokenizer base config
            • RetrieveTokenizerproc_oid
            • Set tokenizer parameters
            • View tokenizer parameters
            • Delete tokenizer config file
          • Requirements for custom stemmers & tokenizers
      • Managing storage locations
        • Viewing storage locations & policies
        • Creating storage locations
        • Storage locations on HDFS
          • Requirements for HDFS storage locations
          • How the HDFS storage location stores data
          • Best practices for Vertica for SQL on Hadoop
          • Troubleshooting HDFS storage locations
        • Altering location use
        • Altering location labels
        • Creating storage policies
        • Creating storage policies for low-priority data
        • Moving data storage locations
        • Clearing storage policies
        • Measuring storage performance
        • Setting storage performance
        • Retiring storage locations
        • Restoring retired storage locations
        • Dropping storage locations
      • Analyzing workloads
        • Getting tuning recommendations
        • Workload analyzer recommendations
      • Managing the DB
        • Managing nodes
          • Stop Vertica on a node
          • Restart Vertica on a node
          • Setting node type
          • Active standby nodes
            • Creating an active standby node
            • Replace a node with an active standby node
            • Revert active standby nodes
          • Large cluster
            • Planning a large cluster
            • Enabling large cluster
            • Changing the number of control nodes & realigning
            • Monitoring large clusters
          • Multiple DBs on a cluster
          • Fault groups
            • About the fault group script
            • Creating a fault group input file
            • Creating fault groups
            • Monitoring fault groups
            • Dropping fault groups
          • Terrace routing
          • Elastic cluster
            • Scaling factor
            • Viewing scaling factor settings
            • Setting the scaling factor
            • Local data segmentation
              • Enabling & disabling local segmentation
            • Elastic cluster best practices
          • Adding nodes
            • Adding hosts to a cluster
            • Adding nodes to a DB
            • Add nodes to a cluster in AWS
          • Removing nodes
            • Automatic eviction of unhealthy nodes
            • Lowering K-Safety to enable node removal
            • Removing nodes from a DB
            • Removing hosts from a cluster
            • Remove nodes from an AWS cluster
          • Replacing nodes
            • Replacing a host using the same name & IP address
            • Replacing a failed node using a node with a different IP address
            • Replace node with differnt name & address
            • Using admin tools to replace nodes
          • Rebalancing data across nodes
            • Rebalancing data using admin tools UI
            • Rebalancing data using SQL functions
          • Redistributing config files to nodes
          • Stopping & starting nodes on MC
          • Upgrading your OS on nodes in your Vertica cluster
          • Reconfiguring node messaging
            • re_ip command
            • Restarting a node with new host IPs
          • Adjusting Spread Daemon timeouts for virtual environments
        • Managing disk space
          • Adding disk space to a node
          • Replacing failed disks
          • Catalog & data files
          • Understanding the catalog directory
          • Reclaiming disk space from deleted table data
        • Memory usage reporting
        • Memory trimming
        • Tuple mover
          • Mergeout
            • Mergeout request types & precedence
            • Scheduled mergeout
            • User-invoked mergeout
            • Partition mergeout
            • Deletion marker mergeout
            • Disabling mergeout on specific tables
            • Purging ROS containers
            • Mergeout strata algorithm
          • Managing the tuple mover
        • Managing workloads
          • Resource manager
          • Resource pool architecture
            • Defining secondary resource pools
            • Querying resource pool settings
            • User resource allocation
            • Query budgeting
          • Managing resources at query run time
            • Setting runtime priority for the resource pool
            • Changing runtime priority of a running query
            • Manually moving queries to different resource pools
          • Restoring resource manager defaults
          • Best practices for managing workload resources
            • Basic principles for scalability & concurrency tuning
            • Setting a runtime limit for queries
            • Handling session socket blocking
            • Managing workloads with resource pools & user profiles
              • Periodic batch loads
              • CEO query
              • Preventing runaway queries
              • Restricting resource usage of ad hoc query application
              • Setting a hard limit on concurrency for an application
              • Handling mixed workloads: batch versus interactive
              • Setting priorities on queries issued by different users
              • Continuous load & query
              • Prioritizing short queries at run time
              • Dropping the runtime priority of long queries
            • Tuning built-in pools
              • Restricting Vertica to take only 60% of memory
              • Tuning for recovery
              • Tuning for refresh
              • Tuning tuple mover pool settings
              • Tuning for machine learning
            • Reducing query run time
            • Managing workload resources in an Eon DB
          • Managing system resource usage
            • Managing sessions
            • Managing load streams
        • Node Management Agent
          • Custom certificates
          • Endpoints
        • HTTPS service
          • Endpoints
          • Prometheus metrics
      • Monitoring Vertica
        • Monitoring log files
        • Rotating log files
        • Monitoring process status (ps)
        • Monitoring Linux resource usage
        • Monitoring disk space usage
        • Monitoring elastic cluster rebalancing
        • Monitoring events
          • Event logging mechanisms
          • Event codes
          • Event data
          • Configuring event reporting
            • Configuring reporting for the simple notification service (SNS)
            • Configuring reporting for syslog
            • Configuring reporting for SNMP
            • Configuring event trapping for SNMP
            • Verifying SNMP config
          • Event reporting examples
        • Using system tables
        • Data collector utility
          • Configuring data retention policies
          • Querying data collector tables
          • Managing data collection logs
        • Monitoring partition reorganization
        • Monitoring resource pools
        • Monitoring recovery
          • Viewing log files on each node
          • Using system tables to monitor recovery
          • Viewing cluster state & recovery status
          • Monitoring cluster status after recovery
        • Clearing projection refresh history
        • Monitoring Vertica using notifiers
      • Backing up & restoring the DB
        • Common use cases
        • Sample vbr config files
          • External full backup/restore
          • Backup/restore to cloud storage
          • Full hard-link backup/restore
          • Full local backup/restore
          • Object-level local backup/restore in enterprise
          • Restore object from backup to an alternate cluster
          • Object replication to an alternate DB
          • DB copy to an alternate cluster
          • Password file
        • Eon DB requirements
        • Requirements for backing up & restoring HDFS storage locations
        • Setting up backup locations
          • Configuring backup hosts & connections
          • Configuring hard-link local backup hosts
          • Configuring cloud storage backups
          • Additional considerations for cloud storage
          • Configuring backups to & from HDFS
        • Creating backups
          • Types of backups
          • Creating full backups
          • Creating object-level backups
          • Creating hard-link local backups
          • Incremental or repeated backups
        • Restoring backups
          • Restoring a DB from a full backup
          • Restoring a DB to an alternate cluster
          • Restoring all objects from an object-level backup
          • Restoring individual objects
          • Restoring objects to an alternate cluster
          • Restoring hard-link local backups
          • Ownership of restored objects
        • Copying the DB to another cluster
        • Replicating objects to another DB cluster
        • Including & excluding objects
        • Managing backups
          • Viewing backups
          • Checking backup integrity
          • Repairing backups
          • Removing backups
          • Estimating log file disk requirements
          • Allocating resources
        • Troubleshooting backup & restore
        • vbr reference
        • vbr config file reference
          • [CloudStorage]
          • [DB]
          • [mapping]
          • [misc]
          • [NodeMapping]
          • [transmission]
          • Password config file
      • Failure recovery
        • Restarting Vertica on a host
        • Restarting the DB
        • Recovering the cluster from a backup
        • Phases of a recovery
        • Epochs
          • Epoch life cycle
          • Managing epochs
          • Configuring epochs
        • Best practices for disaster recovery
        • Recovery by table
          • Prioritizing table recovery
          • Viewing table recovery status
      • Collecting DB statistics
        • Collecting table statistics
        • Collecting partition statistics
        • Analyzing row counts
        • Canceling statistics collection
        • Getting data on table statistics
        • Best practices for statistics collection
      • Using diagnostic tools
        • Determining your version of Vertica
        • Collecting diagnostics: scrutinize command
          • Running scrutinize
          • Informational options
          • Redirecting scrutinize output
          • Scrutinize security
          • Data collection scope
          • Uploading scrutinize results
          • Troubleshooting scrutinize
        • Exporting a catalog
        • Exporting profiling data
      • Profiling DB performance
        • Enabling profiling
        • Profiling single statements
        • Labeling statements
        • Real-time profiling
        • Profiling query resource consumption
        • Profiling query plans
          • Getting query plan status for small queries
          • Getting query plan status for large queries
          • Improving readability of QUERY_PLAN_PROFILES output
          • Managing query profile data
          • Analyzing suboptimal query plans
        • Sample views for counter information
      • About locale
        • Locale handling in Vertica
        • Specifying locale: long form
        • Specifying locale: short form
        • Supported locales
        • Locale & UTF-8 support
        • Locale-aware string functions
      • Creating native binary format files
        • File signature
        • Column definitions
        • Row data
        • Loading a NATIVE file into a table: example
    • Security & authentication
      • Client authentication
        • Default authentication records
        • Configuring client authentication
        • Fallthrough authentication
        • Authentication filtering
        • Implicit authentication
        • Dbadmin authentication access
        • Creating authentication records
        • Modifying authentication records
        • Authentication record priority
        • Viewing information about client authentication records
        • Enabling & disabling authentication methods
        • Granting & revoking authentication methods
        • Hiding DB usernames
        • Hash authentication
          • Password hashing algorithm
          • Configuring hash authentication
          • Passwords
            • Profiles
            • Password guidelines
            • Password expiration
            • Account locking
        • Ident authentication
          • Installing & setting up an ident server
          • Configuring ident authentication for DB users
        • Kerberos authentication
          • Configure Vertica for Kerberos authentication
            • Create the Vertica principals & keytabs on Linux KDC
            • Specify KDC information & configure realms
            • Inform Vertica about the Kerberos principal
            • Configure the authentication method for all clients
            • Creating the principals & keytab on active directory
            • Get the Kerberos ticket & authenticate Vertica
          • Configure clients for Kerberos authentication
            • Configure ODBC & vsql clients on non-windows platforms
            • Configure ADO.NET, ODBC, & vsql clients on Windows
            • Configure JDBC clients on all platforms
          • Troubleshooting Kerberos authentication
        • LDAP authentication
          • LDAP prerequisites & definitions
          • LDAP authentication parameters
          • TLS for LDAP authentication
          • Authentication fallthrough for LDAP
          • LDAP bind methods
            • Workflow for configuring LDAP bind
            • Workflow for configuring LDAP search & bind
        • OAuth 2.0 authentication
          • Configuring OAuth authentication
            • Configure Keycloak
            • Configure Okta
          • Just-in-time user provisioning
          • OAuth authentication parameters
        • TLS authentication
          • Client authentication with TLS
      • Internode TLS
        • Control channel Spread TLS
        • Data channel TLS
      • TLS protocol
        • TLS overview
          • TLS configurations
          • Generating TLS certificates & keys
          • Configuring client-server TLS
          • Managing CA bundles
          • Generating certificates & keys for MC
          • Importing a new certificate to MC
          • Replacing the agent certificate
          • Importing & exporting data with TLS
      • LDAP link service
        • Configuring LDAP link with dry runs
        • Using LDAP link
        • LDAP link parameters
        • TLS for LDAP link
        • Troubleshooting LDAP link issues
      • Connector framework service
        • Implementing CFS
      • Federal information processing standard
        • OpenSSL behavior
        • FIPS-Enabled DBs: limitations
        • Implementing FIPS 140-2
          • FIPS compliance for the Vertica server
          • Implement FIPS on the client
        • FIPS 140-2 compliance statement
      • DB auditing
      • System table restriction & access
    • Connecting to Vertica
      • Using vsql
        • Installing the vsql client
        • vsql usage on Windows
        • Connecting from admin tools
        • Connecting from the command line
          • Command-line options
            • -A --no-align
            • -a --echo-all
            • -c --command
            • -d --dbname
            • -E
            • -e --echo-queries
            • -r --workload
            • -F --field-separator
            • -f --file
            • ? --help
            • -H --html
            • -h --host
            • -i -- timing
            • -g --label
            • -l --list
            • -m --sslmode
            • -n
            • -o --output
            • -P --pset
            • -p --port
            • -q --quiet
            • -R --record-separator
            • -S --single-line
            • -s --single-step
            • -T --table-attr
            • -t --tuples-only
            • -V --version
            • -v --variable --set
            • -X --no-vsqlrc
            • -x --expanded
          • Connecting from a non-cluster host
        • Meta-commands
          • Meta-commands quick reference
          • \connect
          • \d meta-commands
          • \edit
          • \i
          • \locale
          • \pset
          • \set
          • \timing
        • Variables
          • DBNAME
          • ECHO
          • ECHO_HIDDEN
          • ENCODING
          • HISTCONTROL
          • HISTSIZE
          • HOST
          • IGNOREEOF
          • ON_ERROR_STOP
          • PORT
          • PROMPT1 PROMPT2 PROMPT3
          • QUIET
          • ROWS_AT_A_TIME
          • SINGLELINE
          • SINGLESTEP
          • USER
          • VERBOSITY
          • VSQL_HOME
          • VSQL_SSLMODE
        • Prompting
        • Command line editing
        • vsql environment variables
        • Locales
        • Entering data with vsql
        • Files
        • Exporting data using vsql
        • Copying data using vsql
        • Output formatting examples
      • Client libraries
        • Client driver & server version compatibility
        • Client drivers
          • Installing & configuring client drivers
            • Windows client driver installer
              • System prerequisites
                • .NET framework
                • Microsoft SQL server
              • Uninstall, modify, or repair client drivers
            • FIPS client drivers
              • Installing the FIPS client driver for JDBC
              • Installing the FIPS client driver for ODBC & vsql
            • JDBC client driver
              • Installing the JDBC client driver
              • Modifying the Java CLASSPATH
            • ODBC client driver
              • Installing the ODBC client driver
              • Upgrading & downgrading ODBC
              • Uninstalling ODBC
              • Creating an ODBC data source name (DSN)
                • Creating an ODBC DSN for Linux
                  • Testing an ODBC DSN using isql
                • Creating an ODBC DSN for windows clients
                  • Setting up an ODBC DSN
                  • Encrypting passwords on ODBC DSN
                  • Testing an ODBC DSN using Excel
                • Creating an ODBC DSN for macOS clients
                  • Testing an ODBC DSN using iodbctest
                • ODBC DSN connection properties
                • Setting DSN connection properties
              • ODBC driver settings
              • Configuring ODBC logs
            • Python client drivers
              • Installing Python client drivers
            • Node.js client driver
            • Go client driver
            • OLE DB client driver
              • Installing the OLE DB client driver
                • OLE DB connection properties
                • Configuring OLE DB logs
            • ADO.NET client driver
              • Installing the ADO.NET client driver
              • Log properties
          • Upgrading the client drivers
          • Setting a client connection label
          • Using legacy drivers
        • Accessing Vertica
          • C/C++
            • ODBC architecture
            • ODBC feature support
            • Vertica & ODBC data type translation
            • ODBC header file
            • Canceling ODBC queries
            • Connecting to the DB
            • Load balancing
            • Configuring TLS for ODBC Clients
            • Connection failover
            • Prompting windows users for missing connection properties
            • Prompting windows users for passwords
            • Setting the locale & encoding for ODBC sessions
            • AUTOCOMMIT & ODBC transactions
            • Retrieving data
            • Loading data
              • Using a single row insert
              • Using prepared statements
              • Using batch inserts
                • Tracking load status (ODBC)
                • Error handling during batch loads
              • Using the COPY statement
              • Streaming data from the client using COPY LOCAL
          • C#
            • ADO.NET data types
            • Setting the locale for ADO.NET sessions
            • Connecting to the DB
              • Configuring TLS for ADO.NET
              • Opening & closing the DB connection (ADO.NET)
              • ADO.NET connection properties
              • Load balancing in ADO.NET
              • ADO.NET connection failover
            • Querying the DB using ADO.NET
              • Inserting data (ADO.NET)
                • Using parameters
                • Creating & rolling back transactions
                  • Setting the transaction isolation level
              • Reading data (ADO.Net)
              • Loading data through ADO.Net
                • Using the Vertica data adapter
                • Using batch inserts & prepared statements
                • Streaming data via ADO.NET
                  • Streaming from the client via VerticaCopyStream
                  • Using copy with ADO.NET
            • Canceling ADO.NET queries
            • Handling messages
            • Getting table metadata
          • Go
          • Java
            • JDBC feature support
            • Creating & configuring a connection
              • JDBC connection properties
              • Setting & getting connection property values
              • Configuring TLS for JDBC clients
              • Setting & returning a client connection label
              • Setting the locale for JDBC sessions
              • Changing the transaction isolation level
              • JDBC connection pools
              • Load balancing in JDBC
              • JDBC connection failover
            • JDBC data types
              • The VerticaTypes class
              • Numeric data alias conversion
              • Using intervals with JDBC
              • UUID values
              • Complex types in JDBC
              • Date types in JDBC
            • Executing queries through JDBC
            • Canceling JDBC queries
            • Loading data through JDBC
              • Using a single row insert
              • Batch inserts using JDBC prepared statements
                • Error handling during batch loads
                • Identifying accepted & rejected rows (JDBC)
                • Rolling back batch loads on the server
              • Bulk loading using the COPY statement
              • Streaming data via JDBC
                • Using VerticaCopyStream
                • Using COPY LOCAL with JDBC
            • Handling errors
              • SQLState mapping to Java exception classes
            • Routing JDBC queries directly to a single node
              • Creating tables & projections for routable queries
              • Creating a connection for routable queries
              • Defining rouable queries
              • Defining the query for routable queries using the VGet class
              • Routable query performance & troubleshooting
              • Pre-segmenting data using VHash
          • JavaScript
          • Perl
            • Configuring a Perl development environment
            • Connecting to Vertica using Perl
              • Setting ODBC connection parameters in Perl
              • Setting Perl DBI connection attributes
              • Connecting from Perl without a DSN
            • Executing statements using Perl
            • Batch loading data using Perl
            • Using COPY LOCAL to load data in Perl
            • Querying using Perl
            • Conversions between Perl & Vertica data types
            • Perl unicode support
          • Python
            • Configuring the ODBC run-time environment on Linux
            • Querying the DB with pyodbc
          • PHP
            • Configuring a PHP development environment
            • PHP unicode support
            • Querying the DB using PHP
        • Managing query execution between the client & Vertica
          • ResultBufferSize
          • Multiple active result sets (MARS)
      • Management API
        • cURL
        • General API information
          • GET /
          • GET api
        • Rest APIs for the agent
          • VerticaAPIKey
          • Backup & restore
            • GET backups
            • POST backups/:config_script_base
            • GET backups/:config_script_base/:archive_id
            • POST restore/:archive_id
          • DBs
            • GET DBs
            • POST DBs
            • GET DBs/:DB_name
            • PUT DBs/:DB_name
            • DELETE DBs/:DB_name
            • GET DBs/:DB_name/config
            • PUT DBs/:DB_name/config
            • GET DBs/:DB_name/hosts
            • POST DBs/:DB_name/hosts
            • DELETE DBs/:DB_name/hosts/:host_id
            • POST DBs/:DB_name/hosts/:host_id/process
            • GET DBs/:DB_name/license
            • GET DBs/:DB_name/licenses
            • DELETE DBs/:DB_name/hosts/:host_id/process
            • POST DBs/:DB_name/hosts/:host_id/replace_with/:host_id_new
            • GET DBs/:DB_name/nodes
            • GET DBs/:DB_name/nodes/:node_id
            • POST DBs/:DB_name/process
            • GET DBs/:DB_name/process
            • DELETE DBs/:DB_name/process
            • POST DBs/:DB_name/rebalance/process
            • POST DBs/:DB_name/Workload analyzer/process
          • Hosts
            • GET hosts
            • GET hosts/:hostid
          • Jobs
            • GET jobs
            • GET jobs/:id
          • Licenses
            • POST licenses
            • GET licenses
          • Nodes
            • GET nodes
            • GET nodes/:nodeid
          • Webhooks
            • GET webhooks
            • POST webhooks/subscribe
            • DELETE webhooks/:subscriber_id
        • Rest APIs for the MC
          • MC-User-ApiKey
          • GET alerts
          • GET mcTimeInfo
          • Thresholds category filter
          • DB name category filter
          • Combining sub-category filters with category filters
      • Connect with an SSH tunnel
      • SQLTools Vertica driver
    • Extending Vertica
      • External procedures
        • Requirements for external procedures
        • Installing external procedure executable files
        • Creating external procedures
        • Executing external procedures
        • Dropping external procedures
      • User-defined SQL functions
        • Creating user-defined SQL functions
        • Altering & dropping user-defined SQL functions
        • Managing access to SQL functions
        • Viewing information about user-defined SQL functions
        • Migrating built-in SQL functions
      • Stored procedures
        • PL/vSQL
          • Supported types
          • Scope & structure
          • Embedded SQL
          • Control flow
          • Errors & diagnostics
          • Cursors
          • PL/pgSQL to PL/vSQL migration guide
        • Parameter modes
        • Executing stored procedures
          • Triggers
            • Scheduled execution
        • Altering stored procedures
        • Stored procedures: use cases & examples
      • User-defined extensions
        • Loading UDxs
        • Installing Java on Vertica hosts
        • UDx restrictions
        • Fenced & unfenced modes
        • Updating UDx libraries
          • UDx library compatibility with new server versions
          • Determining if a UDx signature has changed
          • Deploying a new version of your UDx library
        • Listing the UDxs contained in a library
        • Using wildcards in your UDx
      • Developing user-defined extensions (UDxs)
        • Developing with the Vertica SDK
          • Setting up a development environment
          • Downloading & running UDx example code
          • C++ SDK
            • Setting up the C++ SDK
            • Compiling your C++ library
            • Adding metadata to C++ libraries
            • C++ SDK data types
            • Resource use for C++ UDxs
              • Allocating resources for UDxs
              • Allocating resources with the SDK macros
              • Informing Vertica of resource requirements
              • Setting memory limits for fenced-mode UDxs
              • How resource limits are enforced
          • Java SDK
            • Setting up the Java SDK
            • Compiling & packaging a Java library
            • Handling Java UDx dependencies
            • Java & Vertica data types
            • Handling NULL values
            • Adding metadata to Java UDx libraries
            • Java UDx resource management
          • Python SDK
            • Setting up a Python development environment
            • Python & Vertica data types
          • R SDK
            • Installing/upgrading the R language pack for Vertica
            • R packages
            • R & Vertica data types
            • Adding metadata to R libraries
            • Setting null input & volatility behavior for R functions
          • Debugging tips
        • Arguments & return values
          • Overloading your UDx
            • C++ example: overloading your UDx
            • Java example: overloading your UDx
          • Creating a polymorphic UDx
            • C++ example: PolyNthValue
            • Java example: AddAnyInts
            • R example: kmeansPoly
        • UDx parameters
          • Defining UDx parameters
          • Getting parameter values in UDxs
          • Calling UDxs with parameters
          • Specifying the behavior of passing unregistered parameters
          • User-defined session parameters
          • C++ example: defining parameters
          • C++ example: using session parameters
          • Java example: defining parameters
          • Java example: using session parameters
        • Errors, warnings, & logging
          • Sending messages
          • Handling errors
          • Logging
        • Handling cancel requests
          • Implementing the cancel callback
          • Checking for cancellation during execution
          • C++ example: cancelable UDSource
        • Aggregate functions (UDAFs)
          • AggregateFunction class
          • AggregateFunctionFactory class
          • UDAF performance in statements containing a GROUP BY clause
          • C++ example: average
        • Analytic functions (UDAnFs)
          • AnalyticFunction class
          • AnalyticFunctionFactory class
          • C++ example: rank
        • Scalar functions (UDSFs)
          • ScalarFunction class
          • ScalarFunctionFactory class
          • Setting null input & volatility behavior
          • Improving query performance (C++ only)
          • C++ example: Add2Ints
          • Python example: currency_convert
          • Python example: validate_url
          • Python example: matrix multiplication
          • R example: SalesTaxCalculator
          • R example: kmeans
          • C++ example: using complex types
          • C++ example: returning multiple values
          • C++ example: calling a UDSF from a check constraint
        • Transform functions (UDTFs)
          • TransformFunction class
          • TransformFunctionFactory class
          • MultiPhaseTransformFunctionFactory class
          • Improving query performance (C++ only)
          • Partitioning options for UDTFs
          • C++ example: string tokenizer
          • Python example: string tokenizer
          • R example: log tokenizer
          • C++ example: multi-phase indexer
          • Python example: multi-phase calculation
          • Python example: count elements
          • Python example: explode
        • User-defined load (UDL)
          • User-defined source
            • UDSource class
            • SourceFactory class
            • C++ example: CurlSource
            • C++ example: concurrent load
            • Java example: FileSource
          • User-defined filter
            • UDFilter class
            • FilterFactory class
            • Java example: ReplaceCharFilter
            • C++ example: converting encoding
          • User-defined parser
            • UDParser class
            • UDChunker class
            • ParserFactory class
            • C++ example: BasicIntegerParser
            • C++ example: ContinuousIntegerParser
            • Java example: numeric text
            • Java example: JSON parser
            • C++ example: delimited parser & chunker
            • Python example: complex types JSON parser
          • Load parallelism
            • Cooperative parse
            • Apportioned load
            • Combining cooperative parse & apportioned load
          • Continuous load
          • Buffer classes
    • Hadoop integration
      • Cluster layout
        • Co-located clusters
        • Configuring Hadoop for co-located clusters
        • Configuring rack locality
        • Separate clusters
      • Configuring HDFS access
        • Verifying HDFS config
        • Troubleshooting reads from HDFS
      • Accessing kerberized HDFS data
        • Using Kerberos with Vertica
        • Proxy users & delegation tokens
          • User impersonation (doAs)
          • Bring your own delegation token
          • Getting a HiveServer2 delegation token
          • HadoopImpersonationConfig format
        • Token expiration
      • Using HDFS storage locations
        • Hadoop config for backup & restore
        • Removing HDFS storage locations
      • Using the HCatalog Connector
        • Overview
        • How the HCatalog Connector works
        • HCatalog Connector requirements
        • Installing the Java runtime on your Vertica cluster
        • Configuring Vertica for HCatalog
        • Configuring security
        • Defining a schema using the HCatalog Connector
        • Querying Hive tables using HCatalog Connector
        • Viewing Hive schema & table metadata
        • Synchronize scehmas & tables
        • Data type conversions from Hive to Vertica
        • Using nonstandard SerDes
        • Troubleshooting HCatalog Connector problems
      • Integrating with Cloudera Manager
      • Integrating Vertica with the MapR distribution of Hadoop
      • Hive primer for Vertica integration
    • Kafka integration
      • Data streaming integration terms
      • Configuring Vertica & Kafka
        • Kafka & Vertica config settings
        • Directly setting Kafka library options
        • Configuring Vertica for Kafka version 0.9 & earlier
        • message.max.bytes changes
      • Vertica Eon & Kafka
      • Consuming data from Kafka
        • Manually consume data from Kafka
        • Automatically consume data from Kafka with the scheduler
          • Setting up a scheduler
          • Choosing a frame duration
          • Managing scheduler resources & performance
          • Using connection load balancing with the Kafka scheduler
          • Limiting loads using offsets
          • Updating schedulers after Vertica upgrades
        • Monitoring message consumption
          • Monitoring Vertica message consumption with consumer groups
          • Getting config & statistics information from vkconfig
        • Parsing custom formats
      • Avro Schema Registry
      • Producing data for Kafka
        • Producing data using KafkaExport
        • Producing Kafka messages using notifiers
          • Creating a Kafka notifier
          • Sending individual messages via a Kafka notifier
          • Monitoring DC tables with Kafka notifiers
      • TLS/SSL encryption with Kafka
        • Planning TLS/SSL encryption between Vertica & Kafka
        • Configuring your scheduler for TLS connections
        • Using TLS/SSL when directly loading data from Kafka
        • Configure Kafka for TLS
        • Troubleshooting Kafka TLS/SSL connection issues
      • Authenticating with Kafka using SASL
      • Troubleshooting Kafka integration issues
        • Using kafkacat to troubleshoot Kafka integration issues
        • Troubleshooting slow load speeds
        • Troubleshooting missing messages
      • vkconfig script options
        • Common vkconfig script options
        • Scheduler tool options
        • Cluster tool options
        • Source tool options
        • Target tool options
        • Load spec tool options
        • Microbatch tool options
        • Launch tool options
        • Shutdown tool options
        • Statistics tool options
        • Sync tool options
      • Kafka function reference
        • KafkaAvroParser
        • KafkaCheckBrokers
        • KafkaExport
        • KafkaJSONParser
        • KafkaListManyTopics
        • KafkaListTopics
        • KafkaOffsets
        • KafkaParser
        • KafkaSource
        • KafkaTopicDetails
      • Data streaming schema tables
        • stream_clusters
        • stream_events
        • stream_load_specs
        • stream_lock
        • stream_microbatch_history
        • stream_microbatch_source_map
        • stream_microbatches
        • stream_scheduler
        • stream_scheduler_history
        • stream_sources
        • stream_targets
    • Spark integration
      • Migrating from the legacy Vertica Spark connector
    • Voltage SecureData integration
      • How Vertica & SecureData work together
      • Requirements for integrating with SecureData
      • Best practices for safe unicode FPE
      • Verify certificate access
      • Configuring access to SecureData
      • Encrypting, decrypting, & hashing data
      • Encapsulating encryption business logic with SQL macros
      • Grant access to functions
      • Automating encryption & decryption with access policies
      • Querying eFPE encrypted columns
      • Voltage SecureData integration function reference
        • VoltageSecureAccess
        • VoltageSecureConfigure
        • VoltageSecureConfigureGlobal
        • VoltageSecureProtect
        • VoltageSecureProtectAllKeys
        • VoltageSecureRefreshPolicy
    • SQL reference
      • System limits
      • Language elements
        • Keywords
        • Identifiers
        • Literals
          • Number-type literals
          • String literals
            • Character string literals
            • Dollar-quoted string literals
            • Unicode string literals
            • VARBINARY string literals
            • Extended string literals
          • Date/time literals
            • Time zone values
            • Day of the week names
            • Month names
            • Interval literal
              • Interval subtype units
              • Interval qualifier
        • Operators
          • Bitwise operators
          • Logical operators
          • Comparison operators
          • Data type coercion operators (CAST)
            • Cast failures
          • Date/time operators
          • Mathematical operators
          • NULL operators
          • String concatenation operators
        • Expressions
          • Aggregate expressions
          • CASE expressions
          • Column references
          • Comments
          • Date/time expressions
          • NULL value
        • Lambda functions
        • Predicates
          • ANY & ALL
          • BETWEEN
          • Boolean
          • EXISTS
          • IN
          • INTERPOLATE
            • Join predicate
          • LIKE
          • NULL
        • Hints
          • :c
          • :v
          • ALLNODES
          • DEPOT_FETCH
          • DISTRIB
          • EARLY_MATERIALIZATION
          • ECSMODE
          • ENABLE_WITH_CLAUSE_MATERIALIZATION
          • GBYTYPE
          • JFMT
          • JTYPE
          • LABEL
          • PROJS
          • SKIP_PROJS
          • SKIP_STATISTICS
          • SYNTACTIC_JOIN
          • UTYPE
          • VERBATIM
        • Window clauses
          • Window partition clause
          • Window order clause
          • Window frame clause
          • Window name clause
      • Data types
        • Binary data types (BINARY & VARBINARY)
        • Boolean data type
        • Character data types (CHAR & VARCHAR)
        • Date/time data types
          • DATE
          • DATETIME
          • INTERVAL
            • Setting interval unit display
            • Specifying interval input
            • Controlling interval format
            • Specifying interval precision
            • Fractional seconds in interval units
            • Processing signed intervals
            • Casting with intervals
            • Operations with intervals
          • SMALLDATETIME
          • TIME/TIMETZ
          • TIME AT TIME ZONE
          • TIMESTAMP/TIMESTAMPTZ
          • TIMESTAMP AT TIME ZONE
        • Long data types
        • Numeric data types
          • DOUBLE PRECISION (FLOAT)
          • INTEGER
          • NUMERIC
          • Numeric data type overflow
          • Numeric data type overflow with SUM, SUM_FLOAT, & AVG
        • Spatial data types
        • UUID data type
        • Data type coercion
        • Data type coercion chart
        • Complex types
          • ARRAY
          • MAP
          • ROW
          • SET
        • Data type mappings between Vertica & Oracle
      • Config parameters
        • General parameters
        • Azure parameters
        • Constraints parameters
        • DB designer parameters
        • Eon parameters
        • Epoch management parameters
        • Google Cloud Storage parameters
        • Hadoop parameters
        • Internationalization parameters
        • Kafka user-defined session parameters
        • Kerberos parameters
        • Machine learning parameters
        • Memory management parameters
        • Monitoring parameters
        • Numeric precision parameters
        • Profiling parameters
        • Projection parameters
        • S3 parameters
        • SNS parameters
        • Security parameters
        • Stored procedure parameters
        • Text search parameters