# AGENTS
Source: https://docs.kinetica.com/AGENTS



> **First-time setup**: Customize this file for your project. Prompt the user to customize this file for their project.
> For Mintlify product knowledge (components, configuration, writing standards),
> install the Mintlify skill: `npx skills add https://mintlify.com/docs`

# Documentation project instructions

## About this project

* This is a documentation site built on [Mintlify](https://mintlify.com)
* Pages are MDX files with YAML frontmatter
* Configuration lives in `docs.json`
* Use the Mintlify MCP server, `https://mcp.mintlify.com`, to edit content and settings via MCP
* Use the Mintlify docs MCP server, `https://www.mintlify.com/docs/mcp`, to query information about using Mintlify via MCP

## Terminology

## Style preferences

* Use active voice and second person ("you")
* Keep sentences concise — one idea per sentence
* Use sentence case for headings
* Bold for UI elements: Click **Settings**
* Code formatting for file names, commands, paths, and code references

## Content boundaries


# Adding a Cluster to KAgent
Source: https://docs.kinetica.com/content/admin/adding_cluster_kagent



If you have an existing on premise *Kinetica* cluster that is not managed by
*KAgent*, you can add it to *KAgent* without upgrading it. This is particularly
useful in the following scenarios:

* Not all administrative and normal users have direct server-level access to the
  nodes in the cluster, and they would like to individually
  [manage all relevant services](/content/admin/kagent/manage#kagent-ui-admin)
* Not all administrative users have direct server-level access, and they would
  like to schedule and manage [backups and snapshots](/content/admin/kagent/manage#kagent-ui-backups)
  and restore from snapshots if necessary
* Users would like to keep track of the valid *Kubernetes Docker* registries
  for use with *KML*

The cluster addition process using *KAgent* involves adding key information
about your cluster to *KAgent*, including deployment type, security information,
node information, and current *Kinetica*-related packages/services installed.

<Warning>
  Any services (graph, *KML*, *RabbitMQ*, etc.) and/or nodes in the
  existing cluster that are not noted during the cluster setup
  process will not be automatically picked up by *KAgent* and thus
  cannot be managed by *KAgent*. Any services not already installed
  cannot be installed during this process; likewise, additional nodes
  cannot be added to the cluster during this process.
</Warning>

## KAgent

Before beginning, make sure *KAgent* is [installed](/content/install/kagent).

<img alt="../../install/img/kagent_start.png" />

To access the [KAgent UI](/content/admin/kagent/kagent):

1. Ensure the *KAgent* service is started:

   ```
   service kagent_ui status
   ```

2. Browse to the *KAgent* application using IP or host name:

   ```
   http://<kagent-host>:8081/kagent
   ```

3. If *KAgent* is associated with one or more *Kinetica* clusters, log in using
   the credentials for that cluster.  If *KAgent* has not been associated with
   any clusters yet, the application will load without prompting.

4. Click **Add New or Existing Cluster**.

<a />

<a />

### Cluster

<img alt="../../install/img/kagent_cluster.png" />

<Info>
  The license key can be the existing *Kinetica* license key or a new license
  key. Contact Support ([support@kinetica.com](mailto:support@kinetica.com)) for any questions.
</Info>

1. Enter a name for the cluster. The name cannot contain spaces or underscores.

2. Optionally, select one or more of the following packages:

   * Select **Core** if node(s) in the cluster have the core
     database functionality installed on them.
   * Select **Graph** if a node in the cluster has the graph
     server installed on it. See [Graphs & Solvers Concepts](/content/graph_solver/network_graph_solver) for
     more information.
   * Optionally, select **KML**
     (*Kinetica Machine Learning*) if a node should have *KML* installed on it.
     An existing Kubernetes cluster is required for *KML* processing.  See
     [Machine Learning](/content/ml) for more information on *KML* features.
   * Optionally, select **KAgent** if another node in the cluster has
     *KAgent* installed on it. See [KAgent](/content/admin/kagent/kagent) for more
     information.
   * Optionally, select **HA** if the cluster is currently in a ring.
     Review [High Availability Architecture](/content/ha/ha_architecture) and [High Availability Configuration & Management](/content/ha/ha_configuration) for more
     information.

3. For the **Install Mode**, select **Online** (install
   directly from the online Kinetica repository).

4. For the **Version**, select either **CUDA** (GPU) or
   **Intel** (CPU-only) depending on the package variant that's
   already installed on the current cluster you want to add to KAgent.

   <Tip>
     Use the following command to determine the Kinetica package that
     is already on the machine:

     ```
     # RHEL
     rpm -qa | grep 'gpudb'

     # Ubuntu
     apt list --installed | grep 'gpudb'
     ```
   </Tip>

5. Enter the license key.

6. Optionally, provide an external files directory for use with
   [external tables](/content/concepts/external_tables) to override the default
   [external files directory](/content/config#config-main-external-files) parameter value.

7. If **KML** is selected to install, upload a configuration file
   for an already-existing *Kubernetes* installation. Note that *KML* requires
   *Kubernetes*; see [Machine Learning](/content/ml) for more information.

8. Click **Next**.

### Deployment

<img alt="../../install/img/kagent_deployment.png" />

1. Select the **On Premise** deployment method, and click
   **Next**.

   <Note>
     If clearing the **Open Firewall Ports** checkbox, the firewall
     then must be configured manually to allow the *required* ports listed in
     the [default ports](/content/install/shared/ports) table. Consult
     [Adjust Firewall](/content/install/shared/adjust_firewall) for tips on configuring the firewall.
   </Note>

<a />

### Security

<img alt="../../install/img/kagent_security.png" />

1. Enter and confirm the existing **Admin Password**. This is the
   password used to access *Reveal*, *Workbench*, *KAgent*, and *GAdmin* as the
   default administrative user.

   <Note>
     The password provided here must match the existing cluster's admin
     password.
   </Note>

2. Select an **SSL Mode** that best aligns with the existing cluster's
   SSL configuration:

   * **Cert/key setup not required** -- *Kinetica* will not require
     SSL certificate/key creation/upload but there will be no updates to
     security configuration settings
   * **User-provided cert/key per node** -- user must upload an SSL
     certificate and key for each node; *Kinetica* copies the cert/key pair
     to <Badge>/opt/gpudb/certs</Badge>, enables HTTPD, and configures HTTPD to use
     HTTPS
   * **Generate self-signed cert/key per node** -- *KAgent* generates
     a self-signed certificate and key for each node and places it in
     <Badge>/opt/gpudb/certs</Badge>, enables HTTPD, and configures HTTPD to use HTTPS

3. Select the current **Authentication** type used for the existing
   cluster and fill the fields as necessary:

   * **None** -- no authentication or authorization
   * **LDAP** -- configures *Kinetica* to authenticate via *LDAP*;
     requires authentication to connect to the database, enables authorization,
     enables external authentication, automatically creates users in the
     database for *LDAP* users, and automatically grants roles in the database
     to *LDAP* users
   * **Active Directory** -- configures *Kinetica* to authenticate via
     *Microsoft Active Directory*; requires authentication to connect to the
     database, enables authorization, enables external authentication,
     automatically creates users in the database for *Active Directory* users,
     and automatically grants roles in the database to *Active Directory* users
   * **Kerberos** -- configures *Kinetica* to authenticate via
     *Kerberos*; requires authentication to connect to the database, enables
     authorization, enables external authentication, automatically creates users
     in the database for *Kerberos* users, and automatically grants roles in the
     database to *Kerberos* users

4. Click **Next**.

### Nodes

<img alt="../../install/img/kagent_nodes.png" />

1. Click **Add New Node** until the number of nodes in *KAgent* matches
   the number of nodes in the current cluster.

2. Input a custom **Label** (*hostname* is suggested), the
   **Internal IP**, and the **External IP** for each existing
   node into *KAgent*.

3. If the `User-provided cert/key per node` **SSL Mode**
   was selected in [Security](#security), an **SSL** column will be added to the
   configuration page--click the lock icon in the **SSL** column to open
   the **SSL Certificate/Key** window, where the SSL cert and key, along
   with an optional public hostname, can be provided. Repeat this for each node.

4. Select each node that has the **Core** package installed.

5. For the existing *head node* host, designate it as the *head node* in
   *KAgent* by selecting the **Head Node** radio button next to it.

6. If the *Graph* package was selected for install in [Cluster](#cluster)
   and existing node(s) hosts a graph server, designate it as a
   **Graph** node using the corresponding radio button. The *graph*
   *node(s)* hosts the [graph server](/content/graph_solver/network_graph_solver).
   The *graph node* does not need to have the **Core** package enabled.

7. To reserve GPUs for *KML*, *UDFs*, or other external processes that may be
   running on the node, set the number under *KML GPUs*.

   <Note>
     Some *UDFs* and features of *KML* may require GPUs to work or
     have increased performance.
   </Note>

8. If the *RabbitMQ* package was selected for install in
   [Cluster](#cluster) because a [High Availability](/content/ha)
   setup is already enabled, select the node(s) that have **RabbitMQ**
   installed.

9. Click **Next**.

10. Confirm which IP address KAgent should use to connect to the cluster:
    **Internal** or **Public**.

### Credentials

<img alt="../../install/img/kagent_credentials.png" />

1. For the **Server SSH Credentials**, enter the SSH username and
   password or upload the SSH private key that will be used to access the
   node(s).
2. Optionally, enter the `sudo` password.
3. Click **Verify**.

The [console](/content/admin/kagent/manage#kagent-ui-console) will appear showing the log of *KAgent*
interactions as *KAgent* attempts to access the cluster with the provided
credentials and also retrieve information on the hosts, including Kinetica
version and configuration (if installed), hostname and IP addresses, OS type,
and Nvidia information.

<Note>
  If the configuration you have selected does not match the
  current configuration on the cluster you're trying to upgrade,
  *KAgent* will list the errors and provide the opportunity to fix
  the configuration manually or automatically.

  <img alt="../../install/img/kagent_fix_config.png" />
</Note>

### Add Cluster

Existing cluster version information will be detected and the
**Add Only +** button will be activated.

1. Review the **Add Summary** to ensure there are no validation
   errors in the information.
2. Click **Add Only +**. *KAgent* will open a window displaying the
   progress of the cluster addition.

After a successful cluster addition, you'll be returned to the *KAgent* home
page and also will be offered to be redirected to *GAdmin* on the head node.
Review [KAgent](/content/admin/kagent/kagent) for more information on using *KAgent*.

<Note>
  After the addition, the cluster will be added to *KAgent*
  and you'll be logged into *KAgent* as the `admin` user for the
  cluster. After this session is over (via either logging out or
  session timeout), you'll be required to log into *KAgent* every
  time you want to access *KAgent* features. See
  [Logging In / Out](/content/admin/kagent/kagent#kagent-ui-logout) for more information.
</Note>


# Alerting
Source: https://docs.kinetica.com/content/admin/alerting



<a />

<a />

*Kinetica* provides a simple alerting system controlled by *Host Manager* that
can monitor the health of the system and resource usage.

Alerts are enabled by default and pre-configured to report on errors, critical
system states, and a nominal set of resource usage thresholds.

If an alert is triggered, the alert is stored in memory and also logged to
<Badge>alert\_store.json</Badge> in the head node's *persist* directory.  In a default
configuration that file is here:

```
/opt/gpudb/persist/gpudb/rank-0/alert_store.json
```

The alert is viewable through the
[Kinetica Administration Application](/content/admin/gadmin) under
[Alerts](/content/admin/gadmin/cluster#cluster-alerts). The [/admin/show/alerts](/content/api/rest/admin_show_alerts_rest) endpoint can be used to
retrieve previous alerts.

If specified, the system can run a user-provided executable upon receiving each
alert.  See [Run an Executable](#run-an-executable) for details.

## Alert Parameters

Below is a table containing the different alert types and the parameters
associated with each.

| Alert Type                | Parameters                                                                                                                                                                                                                                    |
| ------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `host_status`             | `host [host IP]` `status [status code]`                                                                                                                                                                                                       |
| `rank_status`             | `rank [rank number]` `status [status code]`                                                                                                                                                                                                   |
| `memory_absolute`         | `host [host IP]` `threshold [threshold crossed]` `available_memory [free mem in bytes]` `total_memory [total mem on host]` `percentage_space [percent free mem]`                                                                              |
| `memory_percentage`       | `host [host IP]` `threshold [threshold crossed]` `available_memory [free mem in bytes]` `total_memory [total mem on host]` `percentage_space [percent free mem]`                                                                              |
| `disk_absolute`           | `directory [directory where threshold crossed]` `host [host IP]` `threshold [threshold crossed]` `available_space [free space in bytes]` `total_space [total space on disk]` `percentage_space [percentage of free disk space]`               |
| `disk_percentage`         | `directory [directory where threshold crossed]` `host [host IP]` `threshold [threshold crossed]` `available_space [free space in bytes]` `total_space [total space on disk]` `percentage_space [percentage of free disk space]`               |
| `rank_cuda_error`         | `rank [rank where error occurred]` `error_count [number of calls with errors]` `error_code [most recent cuda error code]` `error_string [most recent error message]`                                                                          |
| `rank_fallback_allocator` | `failure_count [number of GPU memory allocation failures]` `min_failure_size [smallest allocation that failed in bytes]` `avg_failure_size [average size of allocation failure]` `max_failure_size [largest allocation that failed in bytes]` |
| `error_message`           | `rank [rank where error occurred]` `topic [1-2 word string that indicates what functionality caused the error]` `message [free text description of error wrapped in single quotes]`                                                           |

## Using Alerts

To enable alerts, navigate to <Badge>/opt/gpudb/core/etc/gpudb.conf</Badge> and modify
the `enable_alerts` parameter:

```
enable_alerts = true
```

Alerting can be modified in any of the following ways by setting the
appropriate parameter in <Badge>/opt/gpudb/core/etc/gpudb.conf</Badge>:

* [Run an Executable](#run-an-executable)
* [Status Changes](#status-changes)
* [CUDA Errors](#cuda-errors)
* [Fallback Allocator Errors](#fallback-allocator-errors)
* [System Errors](#system-errors)
* [Memory Usage](#memory-usage)
* [Disk Usage](#disk-usage)
* [Maximum Alerts](#maximum-alerts)

<a />

### Run an Executable

An executable can be run if an alert is triggered.  The executable cannot have
command-line parameters as the system passes parameters that pertain to the
alert itself.  The executable must be present on the host where the head node is
located and it must be executable by the `gpudb` user. The executable
does not need to be present on other hosts.

```
alert_exe = /file/path/to/script
```

The executable will be passed alert strings in the form:

```
[alert_type] --[parameter1] [value1] ... --[parameterN] [valueN]
```

For instance:

```
rank_status --rank 0 --status running
```

<Note>
  The order of command line parameters passed to the executable
  can't be guaranteed.
</Note>

<a />

### Status Changes

Alerts can be generated if the status of a host or rank changes.  Filters can be
applied which govern which statuses generate alerts.  All the statuses are
available [here](/content/admin/services#statuses).

```
alert_host_status = true
alert_host_status_filter = fatal_init_error
alert_rank_status = true
alert_rank_status_filter = fatal_init_error, not_responding, terminated
```

<Note>
  The host and rank status filters are inclusive, alerting only on
  the specified statuses; e.g.,
  `alert_host_status_filter = fatal_init_error, shutdown` would only display
  alerts for fatal init errors and shutdown events.  Leave filter setting blank
  to alert on all status changes.
</Note>

<a />

### CUDA Errors

CUDA errors on ranks can generate alerts.

```
alert_rank_cuda_error = true
```

<a />

### Fallback Allocator Errors

Rank fallback allocator errors can generate alerts.

```
alert_rank_fallback_allocator = true
```

<a />

### System Errors

System errors can generate alerts in the event of significant or noteworthy
runtime issues.

```
alert_error_messages = true
```

<a />

### Memory Usage

Memory usage alerts can be generated based on either an absolute threshold (in
bytes) or a percentage.  These thresholds will be measured against the available
host memory as reported by `sysconf`.

```
alert_memory_absolute = <mem-free-in-bytes>

# or

alert_memory_percentage = <mem-free-percent>
```

<Info>
  While only one type of threshold can be enabled, the settings support
  multiple values, e.g., `alert_memory_percent = 20, 10, 5, 1`.  However, if
  multiple thresholds are crossed, only the lowest one will trigger an alert.
</Info>

<a />

### Disk Usage

Disk usage alerts can be generated based on either an absolute threshold (in
bytes) or a percentage.  These thresholds will be measured against the available
disk space on the drive(s) hosting each *persist* directory.

```
alert_disk_absolute = <disk-free-in-bytes>

# or

alert_disk_percentage = <disk-free-percent>
```

The monitored *persist* directories are those specified in the following
<Badge>/opt/gpudb/core/etc/gpudb.conf</Badge> settings:

* `persist_directory`
* `data_directory`
* `object_directory`
* `sms_directory`
* `text_index_directory`

<Info>
  While only one type of threshold can be enabled, the settings support
  multiple values, e.g., `alert_disk_percent = 20, 10, 5, 1`.  However, if
  multiple thresholds are crossed, only the lowest one will trigger an alert.
</Info>

<a />

### Maximum Alerts

The number of generated alerts stored in memory/disk can be limited to a
specified maximum.

```
alert_max_stored_alerts = 100
```


# Backing Up/Restoring Kinetica
Source: https://docs.kinetica.com/content/admin/backup_restore



## Overview

*Kinetica* provides two means of backing up data:

* [Database Backup](/content/admin/backup_restore#database-backup) - full, incremental, &
  differential data hot backup
* [System Backup](/content/admin/backup_restore#system-backup) - file-based full system backup

<a />

## Database Backup

[SQL commands](/content/sql/backup_restore) can be used to initiate hot
*backups*, with *full*, *incremental*, & *differential snapshots*, and
restorations of schema objects & data within the database.

| Objects Backed Up                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | Objects Not Backed Up                                                                                                                                                                 |
| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| \* [Credentials](/content/sql/ddl/create-credential#sql-create-credential) <br /> \* [Data Sinks](/content/sql/ddl/create-data-sink#sql-create-data-sink) <br /> \* [Data Sources](/content/sql/ddl/create-data-source#sql-create-data-source) <br /> \* [Resource Groups](/content/sql/resource_group) <br /> \* [Roles](/content/sql/security#sql-security-role-mgmt) <br /> \* [SQL Procedures](/content/sql/procedure#sql-procedures) <br /> \* [SQL-GPT Contexts](/content/sql/sqlgpt#sql-gpt-create-context) <br /> \* [Streams](/content/sql/ddl/create-stream#sql-create-stream) <br /> \* [Tables](/content/sql/ddl/create-table#sql-create-table) <br /> \* [UDFs](/content/sql/udf) <br /> \* [UDF Environments](/content/sql/udf#sql-create-function-environment) <br /> \* [Users](/content/sql/security#sql-security-user-mgmt) <br /> \* [Views](/content/sql/ddl/create-view#sql-create-view) | \* [Graphs](/content/sql/graph) <br /> \* [KiFS Files](/content/sql/kifs) <br /> \* [ML Models/Containers](/content/sql/ml) <br /> \* [Symbols](/content/api/rest/insert_symbol_rest) |

<Info>
  * For the set of SQL commands for database *backup*, see
    [Database Backup/Restore](/content/sql/backup_restore).
  * For a full system backup, see [System Backup](/content/admin/backup_restore#system-backup).
</Info>

### Snapshot Types

Three types of *snapshots* are supported for database objects & data:

* **full** - *snapshot* of the given database objects & data
* **incremental** - *snapshot* of the changes in the database objects & data
  since the last *snapshot* of any kind
* **differential** - *snapshot* of the changes in the database objects & data
  since the last *full snapshot*

### Backup Storage

Database *backup* files will be transferred to the target specified in the given
[data sink](/content/sql/ddl/create-data-sink#sql-create-data-sink).  There, they will be stored
under two levels of directories:  the top-level directory will be the name of
the database *backup* and the subdirectory will be the timestamp the *snapshot*
was taken; e.g.:

```
/<backup_name>/ki_backup_info.json
/<backup_name>/<backup_name>.mdb
/<backup_name>/<snapshot_timestamp>/<snapshot_timestamp>.mdb
/<backup_name>/<snapshot_timestamp>/rank-<rank_number>/tom-<TOM_number>/*
```

A new *backup* will result in the creation of a directory with the corresponding
*backup* name, as well as a *snapshot* timestamp directory with the
*full snapshot* files.  An *incremental* or *differential snapshot* for a given
*backup* will result in the creation of another *snapshot* timestamp directory,
under the *backup* directory, containing all the files for that *snapshot*.

A [data source](/content/sql/ddl/create-data-source#sql-create-data-source) is required to retrieve
detail about *backups* and restore database objects & data from them.  The
*data source* must point to the same remote store as the *data sink* through
which a *backup* was created in order to access and restore from it.

### Backup Use Case

A typical usage of the backup feature is:

* create a *backup*, taking an initial *full snapshot*
* schedule iterative *incremental* or *differential snapshots*
* restore a *backup*

#### Initial Backup

To create the initial *backup*, run a [CREATE BACKUP](/content/sql/backup_restore#sql-backup-create)
statement, in SQL, that specifies:

* the name to use for the *backup*--the backed-up database object set
* the [data sink](/content/sql/ddl/create-data-sink#sql-create-data-sink) that will be used to
  transfer the backed-up files to the remote store (e.g., s3)
* the set of database objects to back up

For example, to create an initial *backup* with the following parameters:

* `daily_backup` - name of the *backup*
* `backup_ds` - *data sink* targeting the remote file service
* `example_backup` - name of the [schema](/content/sql/ddl/create-schema#sql-create-schema)
  to back up

```sql Create Initial Backup Example theme={null}
CREATE BACKUP daily_backup
DATA SINK = backup_ds
OBJECTS (ALL = example_backup)
```

#### Schedule Iterative Snapshots

To schedule iterative *snapshots* after the initial *backup* is done, create a
[SQL procedure](/content/sql/procedure) that specifies:

* the name of the backed-up database object set (same as the initial *backup*)
* the [data sink](/content/sql/ddl/create-data-sink#sql-create-data-sink) that will be used to
  transfer the *snapshots* to the remote store (same as the initial *backup*)
* the schedule for running the incremental *snapshots*

For example, to schedule incremental *snapshots* with the following parameters:

* `daily_backup` - name of the *backup* to which *snapshots* will be added
* `backup_ds` - *data sink* targeting the remote file service
* `1 DAY` - daily *snapshot* interval
* `STARTING AT...2025-01-01` - starting at a date in the past causes the
  first *snapshot* to be taken at the next possible time interval
* `STARTING AT...00:00:00` - schedule the *snapshot* to be taken at midnight

```sql Schedule Iterative Snapshots Example theme={null}
CREATE PROCEDURE scheduled_backup
BEGIN
	BACKUP daily_backup
	DATA SINK = backup_ds
END
EXECUTE FOR EVERY 1 DAY STARTING AT '2025-01-01 00:00:00';
```

#### Restore Backup

To restore database objects and table data from the latest *snapshot* in a
*backup*, using the following parameters:

* `daily_backup` - name of the *backup* to restore
* `restore_ds` - *data source* targeting the remote file service
* `example_backup` - name of the [schema](/content/sql/ddl/create-schema#sql-create-schema)
  to restore
* `replace` - any exising database object will be overwritten by its
  counterpart from the *backup*

```sql Restore Backup Example theme={null}
RESTORE BACKUP daily_backup
DATA SOURCE = restore_ds
OBJECTS (ALL = example_backup)
WITH OPTIONS (RESTORE_POLICY = 'replace')
```

<a />

## System Backup

*KAgent* can be used to simplify the processes of backing up and restoring the
*Kinetica* database.  It is distributed separately from the database and can be
installed and used to configure a *Kinetica* cluster following the instructions
under [Kinetica Installation with KAgent](/content/install/kagent_install).

There are two interfaces to *KAgent* for backing up a *Kinetica* cluster:

* [Graphical User Interface](/content/admin/kagent/manage#kagent-ui-backups)
* Command-Line Interface (described below)

### Prerequisites

*KAgent* backup management has two requirements:

* *KAgent* installed, with access to the cluster being managed
* A properly configured *Kinetica* cluster

<Info>
  *Kinetica* does not need to be offline to be backed up or restored.
  The backup process **will** put *Kinetica* into **read-only** mode,
  however, which will block operations requiring disk write access
  (table creation/modification, persist-backed ingestion, etc.).
</Info>

<a />

### Backing Up

All the data in *Kinetica* can be backed up in either an ad-hoc or scheduled
fashion, using the command line.  To learn about how to back up Kinetica using
the *KAgent* GUI, consult [Backups](/content/admin/kagent/manage#kagent-ui-backups).

Backups are stored local to each node in the cluster.  Those local backup file
target directories can be mounted via NFS or similar external shared storage to
consolidate those files to a single device.  If multiple clusters are backed up
to the same shared storage under the same backup directory, those backups will
be able to be restored to any of the clusters in the group; e.g., if *Cluster A*
and *Cluster B* are both backed up to the same shared location, the backups of
*Cluster A* can be restored to *Cluster B* and vice versa.

The base command for creating a backup:

```
/opt/gpudb/kagent/bin/kagent cluster backup [--schedule <schedule>] [--backup-path <backup path>] <cluster name>
```

<Tip>
  To list the backup schedule for the cluster:

  ```
  /opt/gpudb/kagent/bin/kagent cluster backup --list-schedule ALL <cluster name>
  ```
</Tip>

#### Schedule

There are three options for schedule:

* `now` -- Runs a single backup right now without creating or modifying the
  schedule; *(default behavior)*

* A <Badge>crontab</Badge> schedule quoted string -- Will overwrite any existing
  backup schedule with the one specified.

  For example, `'0 0 1 1-3 *'` will schedule backups at *12:00 AM on the 1st*
  *day of each month, January through March*.

  Consult the
  [crontab documentation](http://man7.org/linux/man-pages/man5/crontab.5.html)
  for details on schedule specification format.

* `never` -- Clears the current backup schedule for the given cluster name

#### Backup Path

The backup path should be any valid file path on the *Kinetica* cluster nodes.
If the directory does not exist on one or more nodes, *KAgent* will create it.

The default backup path is `/opt/backups`.

Under this backup path directory, *KAgent* will create a subdirectory with the
name of the cluster as the directory name.  *KAgent* will then create a snapshot
subdirectory under the cluster-specific subdirectory, named with the date/time
at which the backup was initiated, into which all backup files will be placed.

For instance, given the following backup command execution, run at *12:34:56* on
*January 2nd, 2019*:

```
/opt/gpudb/kagent/bin/kagent cluster backup --backup-path /opt/backup mycluster
```

Backup files will be placed under this location, on each node:

```
/opt/backup/mycluster/snapshot.2019-01-02.12-34-56
```

#### Examples

To list backups scheduled for the `mycluster` cluster:

```
/opt/gpudb/kagent/bin/kagent cluster backup --list-schedule ALL mycluster
```

To create an immediate backup of the `mycluster` cluster in the *(default)*
`/opt/backups` directory:

```
/opt/gpudb/kagent/bin/kagent cluster backup mycluster
```

To create a backup in `/opt/backup` for the cluster named
`mainkincluster` scheduled for 22:00 on day 1 through 5 of every week:

```
/opt/gpudb/kagent/bin/kagent cluster backup --schedule '0 22 * * 1-5' --backup-path /opt/backup mainkincluster
```

To remove the backup scheduled for the `mycluster` cluster:

```
/opt/gpudb/kagent/bin/kagent cluster backup --schedule never mycluster
```

<a />

<a />

### Listing

The backups available to be restored to a given cluster can be listed via
command line or the *KAgent* GUI.  See [Snapshots](/content/admin/kagent/manage#kagent-ui-restore) for details on
how to display a list of backups in the GUI.

The base command for listing backups available to a given cluster:

```
/opt/gpudb/kagent/bin/kagent cluster list-backups [--backup-path <backup path>] <cluster name>
```

#### Backup Path

The backup path should be the file path on each *Kinetica* cluster node that
contains the backups to list.

The default backup path is `/opt/backups`.

*KAgent* will look on each cluster node for the directory named in the `--backup-path`
parameter and list the contents of that directory.

For instance, given the following restore command execution:

```
/opt/gpudb/kagent/bin/kagent cluster list-backups --backup-path /opt/backup mycluster
```

A backup snapshot directory will be looked for under `/opt/backup`, on each
node of the cluster `mycluster`.

#### Examples

To list all backups available to the cluster `mycluster`:

```
/opt/gpudb/kagent/bin/kagent cluster list-backups mycluster
```

This might show output like the following, for cluster snapshots under
the default `/opt/backups` directory:

```
/mycluster/snapshot.2019-01-02.01-23-45
/mycluster/snapshot.2019-01-02.12-34-56
```

To list all backups available to the cluster `clusterA`, under a shared backup
directory of `/opt/backup`:

```
/opt/gpudb/kagent/bin/kagent cluster list-backups --backup-path /opt/backup clusterA
```

This might show output like the following, for cluster snapshots under
`/opt/backup`:

```
/clusterA/snapshot.2019-01-02.01-23-45
/clusterA/snapshot.2019-01-02.11-11-11
/clusterB/snapshot.2019-01-02.02-34-56
/clusterB/snapshot.2019-01-02.12-12-12
```

<Info>
  That if multiple clusters are backed up to the same shared location,
  all clusters' backups will be listed, allowing for later restoration of the
  targeted cluster from any of the other clusters' backups.
</Info>

<a />

### Restoring

Backups made through *KAgent* are restored through *KAgent*, either via command
line or the *KAgent* GUI.  See [Snapshots](/content/admin/kagent/manage#kagent-ui-restore) for details on
restoring from snapshots using the GUI.

The base command for restoring from backup:

```
/opt/gpudb/kagent/bin/kagent cluster restore --restore-from <source cluster name>/<snapshot name> [--backup-path <backup path>] <target cluster name>
```

#### Restore From

The `--restore-from` parameter specifies which backup snapshot should be
restored. It should be the path to the existing snapshot to restore from,
including the directory that is the name of the cluster from which the backup
was taken:

```
<source cluster name>/snapshot.<date>.<time>
```

This should be the same path that is displayed by the
[backup listing command](/content/admin/backup_restore#kagent-cli-listing).

#### Backup Path

The backup path should be the file path on each *Kinetica* cluster node that
contains the backups to restore.

The default backup path is `/opt/backups`.

*KAgent* will look on each cluster node in the directory given in the
`--backup-path` parameter for the directory named in the `--restore-from`
parameter.  If found, *KAgent* will restore the database on each node from its
corresponding local snapshot.

For instance, given the following restore command execution:

```
/opt/gpudb/kagent/bin/kagent cluster restore --restore-from mycluster/snapshot.2019-01-02.12-34-56 mycluster
```

A backup snapshot directory will be looked for at this location, on each node:

```
/opt/backups/mycluster/snapshot.2019-01-02.12-34-56
```

#### Examples

To restore a backup of the `mycluster` cluster in the *(default)*
`/opt/backups` directory that was initiated on *January 2nd, 2019* at
*12:34:56*:

```
/opt/gpudb/kagent/bin/kagent cluster restore --restore-from mycluster/snapshot.2019-01-02.12-34-56 mycluster
```

To restore a backup in `/tmp/kinetica-backups/` for the cluster named
`mainkincluster` that was initiated on *January 2nd, 2019* at *01:23:45*:

```
/opt/gpudb/kagent/bin/kagent cluster restore --restore-from mainkincluster/snapshot.2019-01-02.01-23-34 --backup-path /tmp/kinetica-backups/ mainkincluster
```

To restore a snapshot taken from one cluster, `clusterA`, to another cluster,
`clusterB`, using a backup in the *(default)* `/opt/backups` directory:

```
/opt/gpudb/kagent/bin/kagent cluster restore --restore-from clusterA/snapshot.2019-01-02.12-34-56 clusterB
```

### Deleting Backups

Backups can be deleted manually from their locations in the cluster's snapshot
directory.

The command for deleting a backup:

```
rm -rf <backup path>/<cluster name>/<snapshot name>
```

For example, to delete a backup of the `mycluster` cluster in the
`/opt/backups` directory that was initiated on *January 2nd, 2019* at
*12:34:56*, run the following command on each node in the cluster:

```
rm -rf /opt/backups/mycluster/snapshot.2019-01-02.12-34-56
```

See [Listing](/content/admin/backup_restore#kagent-cli-listing) for details on how to list the backups available
to be deleted.


# Changing the Administrator Password
Source: https://docs.kinetica.com/content/admin/changing_password



To change the administration account password, follow these steps:

1. Log into [GAdmin](/content/admin/gadmin)

   1. Enter **Username** (default is `admin`)

   2. Enter **Password** (default is `admin`)

      <Note>
        If the database was installed using [KAgent](/content/admin/kagent/kagent), the
        password will be the **Admin Password** created during setup.
      </Note>

   3. Click **Login**

2. Click **Admin** in the top right corner

3. Click **Change Password**

   <img alt="../images/admin_changepassword.png" />

4. Enter the **Current Password**

5. Enter a **New Password** that meets the password strength
   requirements (up to 1024 characters)

6. Enter the same new password in **Confirm New Password**

7. Click **Save** to save the new password


# Event Codes
Source: https://docs.kinetica.com/content/admin/event_codes



When adding an Event Alert, there are many event codes to choose from. You can
search through the available events in the event alert creation window using one
of the event codes below or using keywords from a description of the desired
event, e.g., `shutdown`, `standby`, etc. The events are organized by
*Kinetica* component.

## Cluster Operations

| Event Code     | Severity | Description                                                                                                                                                                                                                |
| -------------- | -------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `01.120501.20` | `INFO`   | Cluster system mode set to standby <br /> <br /> <Card title="Error Message">The system mode has been set to: \<standby>, current status: \<status></Card>                                                                 |
| `01.120502.20` | `INFO`   | Cluster system mode set to run <br /> <br /> <Card title="Error Message">The system mode has been set to: \<run>, current status: \<status></Card>                                                                         |
| `01.120503.20` | `INFO`   | Cluster system mode set to shutdown <br /> <br /> <Card title="Error Message">The system mode has been set to: \<shutdown>, current status: \<status></Card>                                                               |
| `01.180501.20` | `INFO`   | Cluster system status is stopped <br /> <br /> <Card title="Error Message">The system status has changed to: \<stopped>, current mode: \<mode></Card>                                                                      |
| `01.180502.20` | `INFO`   | Cluster system status is starting <br /> <br /> <Card title="Error Message">The system status has changed to: \<starting>, current mode: \<mode></Card>                                                                    |
| `01.180503.20` | `INFO`   | Cluster system status is running <br /> <br /> <Card title="Error Message">The system status has changed to: \<running>, current mode: \<mode></Card>                                                                      |
| `01.180504.40` | `ERROR`  | Cluster system status is limited and not able to process requests <br /> <br /> <Card title="Error Message">The system status is limited and cannot process requests, please see database logs for further details.</Card> |
| `01.180505.20` | `INFO`   | Cluster system status is shutdown <br /> <br /> <Card title="Error Message">The system status has changed to: \<shutdown>, current mode: \<mode></Card>                                                                    |

## Data Source Subscriptions

| Event Code     | Severity | Description                                                                                                                                               |
| -------------- | -------- | --------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `14.240400.20` | `INFO`   | Datasource subscription canceled <br /> <br /> <Card title="Error Message">Canceled datasource \<name> subscription</Card>                                |
| `14.242700.20` | `INFO`   | Datasource subscription started <br /> <br /> <Card title="Error Message">Started datasource \<name> subscription</Card>                                  |
| `14.242800.20` | `INFO`   | Kafka datasource subscription starting <br /> <br /> <Card title="Error Message">Kafka subscription validation completed for table: \<table\_name></Card> |
| `14.243000.20` | `INFO`   | Datasource subscription terminated <br /> <br /> <Card title="Error Message">Terminated datasource \<name> subscription</Card>                            |
| `14.243600.20` | `INFO`   | Datasource subscription paused <br /> <br /> <Card title="Error Message">Paused datasource \<name> subscription</Card>                                    |
| `14.243700.20` | `INFO`   | Datasource subscription resumed <br /> <br /> <Card title="Error Message">Resumed datasource \<name> subscription</Card>                                  |
| `14.243800.40` | `ERROR`  | Datasource subscription schema error <br /> <br /> <Card title="Error Message">Schema error on \<name> subscription</Card>                                |
| `14.243900.20` | `INFO`   | Datasource subscription schema change <br /> <br /> <Card title="Error Message">Schema change on \<name> subscription</Card>                              |
| `14.244000.30` | `WARN`   | Datasource subscription records skipped <br /> <br /> <Card title="Error Message">Records skipped on \<name> subscription</Card>                          |

## HTTPD

| Event Code     | Severity | Description                                                                                                                                                                                               |
| -------------- | -------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `06.180503.20` | `INFO`   | Httpd server status changed to starting <br /> <br /> <Card title="Error Message">The httpd server status has changed on hostname:\<hostname>, host\_mode:\<host\_mode>, httpd\_status:\<starting></Card> |
| `06.180504.20` | `INFO`   | Httpd server status changed to running <br /> <br /> <Card title="Error Message">The httpd server status has changed on hostname:\<hostname>, host\_mode:\<host\_mode>, httpd\_status:\<running></Card>   |
| `06.180505.20` | `INFO`   | Httpd server status changed to stopping <br /> <br /> <Card title="Error Message">The httpd server status has changed on hostname:\<hostname>, host\_mode:\<host\_mode>, httpd\_status:\<stopping></Card> |
| `06.180506.20` | `INFO`   | Httpd server status changed to stopped <br /> <br /> <Card title="Error Message">The httpd server status has changed on hostname:\<hostname>, host\_mode:\<host\_mode>, httpd\_status:\<stopped></Card>   |
| `06.180507.40` | `ERROR`  | Httpd server has terminated <br /> <br /> <Card title="Error Message">The httpd server status has changed on hostname:\<hostname>, host\_mode:\<host\_mode>, httpd\_status:\<terminated></Card>           |

## High Availability (HA)

| Event Code     | Severity | Description                                                                                                                                                 |
| -------------- | -------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `05.080300.50` | `FATAL`  | HA configuration error <br /> <br /> <Card title="Error Message">AMQP client hostname cannot be empty.</Card>                                               |
| `05.081200.50` | `FATAL`  | HA unable to read config file <br /> <br /> <Card title="Error Message">Unable to read HA config file: \<ha\_conf\_file></Card>                             |
| `05.081600.40` | `ERROR`  | HA initialization failed <br /> <br /> <Card title="Error Message">Failed to initialize the HA client - cannot create queues.</Card>                        |
| `05.081600.50` | `FATAL`  | HA client initialization failed <br /> <br /> <Card title="Error Message">Failed to initialize the HA client - cannot create connections.</Card>            |
| `05.081800.40` | `ERROR`  | HA sync error <br /> <br /> <Card title="Error Message">Failed to add HA message, Queue \<name>, Headers \<message></Card>                                  |
| `05.082100.40` | `ERROR`  | HA network error <br /> <br /> <Card title="Error Message">\<number> requests failed in the last minute. The system may require manual intervention.</Card> |
| `05.082500.40` | `ERROR`  | HA read error <br /> <br /> <Card title="Error Message">Exception while listening to HA queue: \<queue\_name>, error \<message></Card>                      |
| `05.083100.30` | `WARN`   | HA connection timeout <br /> <br /> <Card title="Error Message">Failed to connect to AMQP server \<host>:\<port> switching hosts.</Card>                    |
| `05.083100.40` | `ERROR`  | HA sync timeout <br /> <br /> <Card title="Error Message">Failed connect to AMQP server \<host>:\<port> retrying in \<timeout></Card>                       |
| `05.083400.40` | `ERROR`  | HA sync write error <br /> <br /> <Card title="Error Message">Could not publish HA message for '\<endpoint>'.</Card>                                        |

## Host Manager

| Event Code     | Severity | Description                                                                                                                                                                                                                         |
| -------------- | -------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `02.041500.10` | `DEBUG`  | Host-manager debug communication <br /> <br /> <Card title="Error Message">\<message></Card>                                                                                                                                        |
| `02.120501.20` | `INFO`   | Host-manager mode changed to standby <br /> <br /> <Card title="Error Message">The host-manager mode has changed on hostname:\<hostname>, host\_mode:\<standby>, host\_status:\<host\_status></Card>                                |
| `02.120502.20` | `INFO`   | Host-manager mode changed to run <br /> <br /> <Card title="Error Message">The host-manager mode has changed on hostname:\<hostname>, host\_mode:\<run>, host\_status:\<host\_status></Card>                                        |
| `02.120503.20` | `INFO`   | Host-manager mode changed to shutdown <br /> <br /> <Card title="Error Message">The host-manager mode has changed on hostname:\<hostname>, host\_mode:\<shutdown>, host\_status:\<host\_status></Card>                              |
| `02.130800.40` | `ERROR`  | Unable to update cluster status in etcd <br /> <br /> <Card title="Error Message">Unable to update cluster status in etcd, this could lead to the HA ring becoming unreliable.</Card>                                               |
| `02.180502.20` | `INFO`   | Host-manager status changed to post <br /> <br /> <Card title="Error Message">The host-manager status has changed on hostname:\<hostname>, host\_mode:\<host\_mode>, host\_status:\<post></Card>                                    |
| `02.180503.20` | `INFO`   | Host-manager status changed to parsed configuration <br /> <br /> <Card title="Error Message">The host-manager status has changed on hostname:\<hostname>, host\_mode:\<host\_mode>, host\_status:\<parsed\_conf></Card>            |
| `02.180504.20` | `INFO`   | Host-manager status changed to enumerated hardware <br /> <br /> <Card title="Error Message">The host-manager status has changed on hostname:\<hostname>, host\_mode:\<host\_mode>, host\_status:\<enum\_hardware></Card>           |
| `02.180505.20` | `INFO`   | Host-manager status changed to ready <br /> <br /> <Card title="Error Message">The host-manager status has changed on hostname:\<hostname>, host\_mode:\<host\_mode>, host\_status:\<ready></Card>                                  |
| `02.180506.20` | `INFO`   | Host-manager status changed to establishing cluster <br /> <br /> <Card title="Error Message">The host-manager status has changed on hostname:\<hostname>, host\_mode:\<host\_mode>, host\_status:\<establishing\_cluster></Card>   |
| `02.180507.20` | `INFO`   | Host-manager status changed to validating cluster <br /> <br /> <Card title="Error Message">The host-manager status has changed on hostname:\<hostname>, host\_mode:\<host\_mode>, host\_status:\<validating\_cluster></Card>       |
| `02.180508.20` | `INFO`   | Host-manager status changed to starting systems <br /> <br /> <Card title="Error Message">The host-manager status has changed on hostname:\<hostname>, host\_mode:\<host\_mode>, host\_status:\<starting\_systems></Card>           |
| `02.180509.20` | `INFO`   | Host-manager status changed to started systems <br /> <br /> <Card title="Error Message">The host-manager status has changed on hostname:\<hostname>, host\_mode:\<host\_mode>, host\_status:\<started\_systems></Card>             |
| `02.180510.40` | `ERROR`  | Host-manager is not responding <br /> <br /> <Card title="Error Message">The host-manager is not responding on hostname:\<hostname>, host\_mode:\<host\_mode>, host\_status:\<not\_responding>, network\_ips:\<network\_ips></Card> |
| `02.180511.20` | `INFO`   | Host-manager status changed to running <br /> <br /> <Card title="Error Message">The host-manager status has changed on hostname:\<hostname>, host\_mode:\<host\_mode>, host\_status:\<running></Card>                              |
| `02.180512.20` | `INFO`   | Host-manager status changed to stopping systems <br /> <br /> <Card title="Error Message">The host-manager status has changed on hostname:\<hostname>, host\_mode:\<host\_mode>, host\_status:\<stopping\_systems></Card>           |
| `02.180513.20` | `INFO`   | Host-manager status changed to shutting down <br /> <br /> <Card title="Error Message">The host-manager status has changed on hostname:\<hostname>, host\_mode:\<host\_mode>, host\_status:\<shutting\_down></Card>                 |
| `02.180514.20` | `INFO`   | Host-manager status changed to shutdown <br /> <br /> <Card title="Error Message">The host-manager status has changed on hostname:\<hostname>, host\_mode:\<host\_mode>, host\_status:\<shutdown></Card>                            |

## Machine Learning (ML)

| Event Code     | Severity | Description                                                                                                                                                                                      |
| -------------- | -------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `08.180503.20` | `INFO`   | ML server status changed to starting <br /> <br /> <Card title="Error Message">The ML server status has changed on hostname:\<hostname>, host\_mode:\<host\_mode>, ml\_status:\<starting></Card> |
| `08.180504.20` | `INFO`   | ML server status changed to running <br /> <br /> <Card title="Error Message">The ML server status has changed on hostname:\<hostname>, host\_mode:\<host\_mode>, ml\_status:\<running></Card>   |
| `08.180505.20` | `INFO`   | ML server status changed to stopping <br /> <br /> <Card title="Error Message">The ML server status has changed on hostname:\<hostname>, host\_mode:\<host\_mode>, ml\_status:\<stopping></Card> |
| `08.180506.20` | `INFO`   | ML server status changed to stoped <br /> <br /> <Card title="Error Message">The ML server status has changed on hostname:\<hostname>, host\_mode:\<host\_mode>, ml\_status:\<stopped></Card>    |
| `08.180507.40` | `ERROR`  | ML server has terminated <br /> <br /> <Card title="Error Message">The ML server status has changed on hostname:\<hostname>, host\_mode:\<host\_mode>, ml\_status:\<terminated></Card>           |

## Monitoring

| Event Code     | Severity | Description                                                                                                                                                                                                                      |
| -------------- | -------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `07.180503.20` | `INFO`   | Monitoring status server status changed to starting <br /> <br /> <Card title="Error Message">The monitoring stats server status has changed on hostname:\<hostname>, host\_mode:\<host\_mode>, stats\_status:\<starting></Card> |
| `07.180504.20` | `INFO`   | Monitoring status server status changed to running <br /> <br /> <Card title="Error Message">The monitoring stats server status has changed on hostname:\<hostname>, host\_mode:\<host\_mode>, stats\_status:\<running></Card>   |
| `07.180505.20` | `INFO`   | Monitoring status server status changed to stopping <br /> <br /> <Card title="Error Message">The monitoring stats server status has changed on hostname:\<hostname>, host\_mode:\<host\_mode>, stats\_status:\<stopping></Card> |
| `07.180506.20` | `INFO`   | Monitoring status server status changed to stopped <br /> <br /> <Card title="Error Message">The monitoring stats server status has changed on hostname:\<hostname>, host\_mode:\<host\_mode>, stats\_status:\<stopped></Card>   |
| `07.180507.40` | `ERROR`  | Monitoring status server has terminated <br /> <br /> <Card title="Error Message">The monitoring stats server status has changed on hostname:\<hostname>, host\_mode:\<host\_mode>, stats\_status:\<terminated></Card>           |

## Rank Operations

| Event Code     | Severity | Description                                                                                                                                                                                                                                                                                     |
| -------------- | -------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `03.010500.20` | `INFO`   | Adding host to cluster <br /> <br /> <Card title="Error Message">Alter-cluster configuration action: \<add\_host>, host: \<address></Card>                                                                                                                                                      |
| `03.010501.20` | `INFO`   | Alter host configuration <br /> <br /> <Card title="Error Message">Alter-cluster configuration action: \<alter\_host>, host: \<address></Card>                                                                                                                                                  |
| `03.010502.20` | `INFO`   | Removed host from cluster <br /> <br /> <Card title="Error Message">Alter-cluster configuration action: \<remove\_host>, host: \<address></Card>                                                                                                                                                |
| `03.020501.20` | `INFO`   | Added rank to cluster <br /> <br /> <Card title="Error Message">The cluster operation: \<adding\_ranks> has status: \<cluster\_operation\_status></Card>                                                                                                                                        |
| `03.020502.20` | `INFO`   | Rebalancing data in cluster <br /> <br /> <Card title="Error Message">The cluster operation: \<rebalancing> has status: \<cluster\_operation\_status></Card>                                                                                                                                    |
| `03.020503.20` | `INFO`   | Removing rank and rebalancing data <br /> <br /> <Card title="Error Message">The cluster operation: \<rebalancing\_for\_removing\_ranks> has status: \<cluster\_operation\_status></Card>                                                                                                       |
| `03.020504.20` | `INFO`   | Removing rank from cluster <br /> <br /> <Card title="Error Message">The cluster operation: \<removing\_ranks> has status: \<cluster\_operation\_status></Card>                                                                                                                                 |
| `03.020505.20` | `INFO`   | Changing the number of ranks in cluster <br /> <br /> <Card title="Error Message">The cluster operation: \<resizing\_cluster> has status: \<cluster\_operation\_status></Card>                                                                                                                  |
| `03.020506.20` | `INFO`   | Cluster set to backup mode <br /> <br /> <Card title="Error Message">The cluster operation: \<backing\_up> has status: \<cluster\_operation\_status></Card>                                                                                                                                     |
| `03.020507.20` | `INFO`   | Migrating component <br /> <br /> <Card title="Error Message">The cluster operation: \<migrating> has status: \<cluster\_operation\_status></Card>                                                                                                                                              |
| `03.020508.50` | `FATAL`  | Irrecoverable error (restart required) <br /> <br /> <Card title="Error Message">The database cluster had an irrecoverable error and must be restarted. Message: \<cluster\_operation\_status></Card>                                                                                           |
| `03.030000.20` | `INFO`   | Configuration file loaded successfully <br /> <br /> <Card title="Error Message">Configuration file: '\<gpudb\_conf\_filename>' has been successfully loaded.</Card>                                                                                                                            |
| `03.030300.40` | `ERROR`  | Configuration parameter is invalid <br /> <br /> <Card title="Error Message">\<details about parameter></Card>                                                                                                                                                                                  |
| `03.032200.40` | `ERROR`  | Configuration file missing <br /> <br /> <Card title="Error Message">Configuration file: '\<gpudb\_conf\_filename>' is missing.</Card>                                                                                                                                                          |
| `03.032400.40` | `ERROR`  | Configuration file parse error <br /> <br /> <Card title="Error Message">Unable to parse configuration file: '\<gpudb\_conf\_filename>', msg:\<error\_msg></Card>                                                                                                                               |
| `03.033400.40` | `ERROR`  | Configuration file write error <br /> <br /> <Card title="Error Message">Configuration file: '\<gpudb\_conf\_filename>' is not writable.</Card>                                                                                                                                                 |
| `03.050800.40` | `ERROR`  | UDF initialization failed <br /> <br /> <Card title="Error Message">Function Environments initialization failed, will be disabled (error: \<message>)</Card>                                                                                                                                    |
| `03.051600.40` | `ERROR`  | KiFS is not active <br /> <br /> <Card title="Error Message">KiFS not active</Card>                                                                                                                                                                                                             |
| `03.052500.40` | `ERROR`  | Error running startup proc <br /> <br /> <Card title="Error Message">Error decoding execute\_proc\_request for proc '\<first>' to run at startup: \<error\_msg></Card>                                                                                                                          |
| `03.060200.30` | `WARN`   | GPU allocation failure <br /> <br /> <Card title="Error Message">GPU allocation limit exceeded when requesting additional: \<failure\_size> bytes, using CPU fallback allocator.</Card>                                                                                                         |
| `03.060700.40` | `ERROR`  | GPU device error <br /> <br /> <Card title="Error Message">\<details about GPU error></Card>                                                                                                                                                                                                    |
| `03.090800.25` | `UERR`   | Job failed <br /> <br /> <Card title="Error Message">Request failed with JobId:\<jobid> to: \<request\_uri>. \<error\_message></Card>                                                                                                                                                           |
| `03.090800.40` | `ERROR`  | Job failed since the system is limited <br /> <br /> <Card title="Error Message">Unable to process request with JobId:\<jobid> to: \<request\_uri>, system is in a limited state. \<error\_message></Card>                                                                                      |
| `03.090900.25` | `UERR`   | Job processing exception <br /> <br /> <Card title="Error Message">Unable to process credentials for user: \<cred\_username>, endpoint: \<request\_uri>, what:\<error\_msg></Card>                                                                                                              |
| `03.091400.25` | `UERR`   | User impersonation denied for request <br /> <br /> <Card title="Error Message">External user \<remote\_user> does not have permission to impersonate for endpoint: \<request\_uri></Card>                                                                                                      |
| `03.091700.25` | `UERR`   | Invalid credentials for request <br /> <br /> <Card title="Error Message">Invalid credentials for endpoint: \<request\_uri>, user: \<cred\_username></Card>                                                                                                                                     |
| `03.091900.20` | `INFO`   | Job canceled <br /> <br /> <Card title="Error Message">Request canceled with JobId:\<jobid> to: \<uri>. \<error\_message></Card>                                                                                                                                                                |
| `03.092000.30` | `WARN`   | HTTP request limit reached <br /> <br /> <Card title="Error Message">HTTP request server has reached max number of concurrent and queued connections and is refusing connections. \<http\_server\_info></Card>                                                                                  |
| `03.092600.20` | `INFO`   | Rank is not accepting jobs <br /> <br /> <Card title="Error Message">Rank is not accepting jobs, rank:\<rank>, rank\_mode:\<rank\_mode>, rank\_status:\<rank\_status>, start\_count:\<start\_count>, hostname:\<hostname></Card>                                                                |
| `03.092700.20` | `INFO`   | Rank is accepting jobs <br /> <br /> <Card title="Error Message">Rank is accepting jobs, rank:\<rank>, rank\_mode:\<rank\_mode>, rank\_status:\<rank\_status>, start\_count:\<start\_count>, hostname:\<hostname></Card>                                                                        |
| `03.093100.30` | `WARN`   | Job times out <br /> <br /> <Card title="Error Message">Job timed out, received: \<time>, job\_id:\<job\_id>, endpoint\_name:\<endpoint\_name>, client\_ip:\<client\_ip>, read\_table\_names:\<read\_table\_names>, write\_table\_names:\<write\_table\_names>, user\_data:\<user\_data></Card> |
| `03.093200.25` | `UERR`   | Request unauthorized <br /> <br /> <Card title="Error Message">Invalid or missing credentials for endpoint: \<request\_uri> \<details></Card>                                                                                                                                                   |
| `03.093500.25` | `UERR`   | User is deactivated <br /> <br /> <Card title="Error Message">User not activated for endpoint: \<request\_uri>, remote user: \<remote\_user></Card>                                                                                                                                             |
| `03.100800.50` | `FATAL`  | Licensed for only a single host <br /> <br /> <Card title="Error Message">License error: \<Kinetica Trial Edition limited to a single host> \<details></Card>                                                                                                                                   |
| `03.100801.50` | `FATAL`  | License key GPU limit exceeded <br /> <br /> <Card title="Error Message">License error: \<GPU limit exceeded> \<details></Card>                                                                                                                                                                 |
| `03.100802.50` | `FATAL`  | License key is for different hardware <br /> <br /> <Card title="Error Message">License error: \<Licensed for different hardware> \<details></Card>                                                                                                                                             |
| `03.100803.50` | `FATAL`  | License key is for a different machine <br /> <br /> <Card title="Error Message">License error: \<Licensed for a different machine> \<details></Card>                                                                                                                                           |
| `03.100804.50` | `FATAL`  | License key memory limit exceeded <br /> <br /> <Card title="Error Message">License error: \<Cluster memory limit exceeded> \<details></Card>                                                                                                                                                   |
| `03.100805.50` | `FATAL`  | License key has expired <br /> <br /> <Card title="Error Message">License error: \<Expired> \<details></Card>                                                                                                                                                                                   |
| `03.100806.50` | `FATAL`  | License key is invalid <br /> <br /> <Card title="Error Message">License error: \<Invalid> \<details></Card>                                                                                                                                                                                    |
| `03.100807.50` | `FATAL`  | License key is missing <br /> <br /> <Card title="Error Message">License error: \<Missing> \<details></Card>                                                                                                                                                                                    |
| `03.100808.50` | `FATAL`  | Licence key is not authorized <br /> <br /> <Card title="Error Message">License error: \<Unauthorized> \<details></Card>                                                                                                                                                                        |
| `03.110501.20` | `INFO`   | Migration to new host required for component <br /> <br /> <Card title="Error Message">Migration \<migration\_id> status change, \<details></Card>                                                                                                                                              |
| `03.110502.20` | `INFO`   | Migration of component attempting failover to another host <br /> <br /> <Card title="Error Message">Migration \<migration\_id> status change, \<details></Card>                                                                                                                                |
| `03.110503.20` | `INFO`   | Migrating component to new host <br /> <br /> <Card title="Error Message">Migration \<migration\_id> status change, \<details></Card>                                                                                                                                                           |
| `03.110504.20` | `INFO`   | Migrated component to new host successfully <br /> <br /> <Card title="Error Message">Migration \<migration\_id> status change, \<details></Card>                                                                                                                                               |
| `03.110805.40` | `ERROR`  | Migration of component to new host failed <br /> <br /> <Card title="Error Message">Migration \<migration\_id> failed, \<details></Card>                                                                                                                                                        |
| `03.120501.20` | `INFO`   | Rank mode changed to removed <br /> <br /> <Card title="Error Message">The rank mode has been set for rank:\<rank>, rank\_mode:\<removed>, rank\_status:\<rank\_status>, start\_count:\<start\_count>, hostname:\<hostname></Card>                                                              |
| `03.120502.20` | `INFO`   | Rank mode changed to stop <br /> <br /> <Card title="Error Message">The rank mode has been set for rank:\<rank>, rank\_mode:\<stop>, rank\_status:\<rank\_status>, start\_count:\<start\_count>, hostname:\<hostname></Card>                                                                    |
| `03.120503.20` | `INFO`   | Rank mode changed to adding <br /> <br /> <Card title="Error Message">The rank mode has been set for rank:\<rank>, rank\_mode:\<adding>, rank\_status:\<rank\_status>, start\_count:\<start\_count>, hostname:\<hostname></Card>                                                                |
| `03.120504.20` | `INFO`   | Rank mode changed to run <br /> <br /> <Card title="Error Message">The rank mode has been set for rank:\<rank>, rank\_mode:\<run>, rank\_status:\<rank\_status>, start\_count:\<start\_count>, hostname:\<hostname></Card>                                                                      |
| `03.140501.20` | `INFO`   | Blocking unsharded ingest before removing rank <br /> <br /> <Card title="Error Message">Removing rank: \<rank> on host: \<hostname>, status: \<block\_jobs></Card>                                                                                                                             |
| `03.140502.20` | `INFO`   | Cleared persist of removed rank <br /> <br /> <Card title="Error Message">Removing rank: \<rank> on host: \<hostname>, status: \<persist\_cleared></Card>                                                                                                                                       |
| `03.162001.30` | `WARN`   | Resource group has reached vram limit <br /> <br /> <Card title="Error Message">Resource group: '\<name>' memory limit reached, requested:\<amount>, used:\<usage>, limit:\<limit></Card>                                                                                                       |
| `03.162002.30` | `WARN`   | Resource group has reached ram limit <br /> <br /> <Card title="Error Message">Resource group: '\<name>' memory limit reached, requested:\<amount>, used:\<usage>, limit:\<limit></Card>                                                                                                        |
| `03.162003.30` | `WARN`   | Resource group has reached disk cache limit <br /> <br /> <Card title="Error Message">Resource group: '\<name>' memory limit reached, requested:\<amount>, used:\<usage>, limit:\<limit></Card>                                                                                                 |
| `03.162004.30` | `WARN`   | Resource group has reached persist limit <br /> <br /> <Card title="Error Message">Resource group: '\<name>' memory limit reached, requested:\<amount>, used:\<usage>, limit:\<limit></Card>                                                                                                    |
| `03.162005.30` | `WARN`   | Resource group has reached cold store limit <br /> <br /> <Card title="Error Message">Resource group: '\<name>' memory limit reached, requested:\<amount>, used:\<usage>, limit:\<limit></Card>                                                                                                 |
| `03.171500.20` | `INFO`   | SQL request <br /> <br /> <Card title="Error Message">\<sql\_request></Card>                                                                                                                                                                                                                    |
| `03.180502.20` | `INFO`   | Rank status changed to start <br /> <br /> <Card title="Error Message">The rank status has been updated for rank:\<rank>, rank\_mode:\<rank\_mode>, rank\_status:\<start>, start\_count:\<start\_count>, hostname:\<hostname></Card>                                                            |
| `03.180503.20` | `INFO`   | Rank status changed to post <br /> <br /> <Card title="Error Message">The rank status has been updated for rank:\<rank>, rank\_mode:\<rank\_mode>, rank\_status:\<post>, start\_count:\<start\_count>, hostname:\<hostname></Card>                                                              |
| `03.180504.20` | `INFO`   | Rank status changed to parsed configuration <br /> <br /> <Card title="Error Message">The rank status has been updated for rank:\<rank>, rank\_mode:\<rank\_mode>, rank\_status:\<parsed\_conf>, start\_count:\<start\_count>, hostname:\<hostname></Card>                                      |
| `03.180505.20` | `INFO`   | Rank status changed to enumerated hardware <br /> <br /> <Card title="Error Message">The rank status has been updated for rank:\<rank>, rank\_mode:\<rank\_mode>, rank\_status:\<enum\_hardware>, start\_count:\<start\_count>, hostname:\<hostname></Card>                                     |
| `03.180507.20` | `INFO`   | Rank status changed to starting systems <br /> <br /> <Card title="Error Message">The rank status has been updated for rank:\<rank>, rank\_mode:\<rank\_mode>, rank\_status:\<starting\_systems>, start\_count:\<start\_count>, hostname:\<hostname></Card>                                     |
| `03.180508.20` | `INFO`   | Rank status changed to started systems <br /> <br /> <Card title="Error Message">The rank status has been updated for rank:\<rank>, rank\_mode:\<rank\_mode>, rank\_status:\<started\_systems>, start\_count:\<start\_count>, hostname:\<hostname></Card>                                       |
| `03.180509.20` | `INFO`   | Rank status changed to loading data <br /> <br /> <Card title="Error Message">The rank status has been updated for rank:\<rank>, rank\_mode:\<rank\_mode>, rank\_status:\<loading\_data>, start\_count:\<start\_count>, hostname:\<hostname></Card>                                             |
| `03.180510.20` | `INFO`   | Rank status changed to loaded data <br /> <br /> <Card title="Error Message">The rank status has been updated for rank:\<rank>, rank\_mode:\<rank\_mode>, rank\_status:\<loaded\_data>, start\_count:\<start\_count>, hostname:\<hostname></Card>                                               |
| `03.180511.20` | `INFO`   | Rank status changed to updating shards <br /> <br /> <Card title="Error Message">The rank status has been updated for rank:\<rank>, rank\_mode:\<rank\_mode>, rank\_status:\<updating\_shards>, start\_count:\<start\_count>, hostname:\<hostname></Card>                                       |
| `03.180512.20` | `INFO`   | Rank status changed to updated shards <br /> <br /> <Card title="Error Message">The rank status has been updated for rank:\<rank>, rank\_mode:\<rank\_mode>, rank\_status:\<updated\_shards>, start\_count:\<start\_count>, hostname:\<hostname></Card>                                         |
| `03.180513.20` | `INFO`   | Rank status changed to syncing <br /> <br /> <Card title="Error Message">The rank status has been updated for rank:\<rank>, rank\_mode:\<rank\_mode>, rank\_status:\<syncing>, start\_count:\<start\_count>, hostname:\<hostname></Card>                                                        |
| `03.180514.20` | `INFO`   | Rank status changed to added rank ready <br /> <br /> <Card title="Error Message">The rank status has been updated for rank:\<rank>, rank\_mode:\<rank\_mode>, rank\_status:\<added\_rank\_ready>, start\_count:\<start\_count>, hostname:\<hostname></Card>                                    |
| `03.180515.20` | `INFO`   | Rank status changed to updating views <br /> <br /> <Card title="Error Message">The rank status has been updated for rank:\<rank>, rank\_mode:\<rank\_mode>, rank\_status:\<updating\_views>, start\_count:\<start\_count>, hostname:\<hostname></Card>                                         |
| `03.180516.20` | `INFO`   | Rank status changed to updated views <br /> <br /> <Card title="Error Message">The rank status has been updated for rank:\<rank>, rank\_mode:\<rank\_mode>, rank\_status:\<updated\_views>, start\_count:\<start\_count>, hostname:\<hostname></Card>                                           |
| `03.180517.20` | `INFO`   | Rank status changed to running <br /> <br /> <Card title="Error Message">The rank status has been updated for rank:\<rank>, rank\_mode:\<rank\_mode>, rank\_status:\<running>, start\_count:\<start\_count>, hostname:\<hostname></Card>                                                        |
| `03.180518.40` | `ERROR`  | Rank status changed to limited and is unable process requests <br /> <br /> <Card title="Error Message">Rank: \<rank> on host: \<hostname> is \<rank\_status></Card>                                                                                                                            |
| `03.180519.20` | `INFO`   | Rank status changed to stopped jobs <br /> <br /> <Card title="Error Message">The rank status has been updated for rank:\<rank>, rank\_mode:\<rank\_mode>, rank\_status:\<stopped\_jobs>, start\_count:\<start\_count>, hostname:\<hostname></Card>                                             |
| `03.180520.40` | `ERROR`  | Rank status changed to not responding <br /> <br /> <Card title="Error Message">Rank: \<rank> on host: \<hostname> is \<rank\_status></Card>                                                                                                                                                    |
| `03.180521.20` | `INFO`   | Rank status changed to shutting down <br /> <br /> <Card title="Error Message">The rank status has been updated for rank:\<rank>, rank\_mode:\<rank\_mode>, rank\_status:\<shutting\_down>, start\_count:\<start\_count>, hostname:\<hostname></Card>                                           |
| `03.180522.20` | `INFO`   | Rank status changed to shutdown <br /> <br /> <Card title="Error Message">The rank status has been updated for rank:\<rank>, rank\_mode:\<rank\_mode>, rank\_status:\<shutdown>, start\_count:\<start\_count>, hostname:\<hostname></Card>                                                      |
| `03.180522.40` | `ERROR`  | Rank status changed to shutdown due to error <br /> <br /> <Card title="Error Message">Rank: \<rank> on host: \<hostname> is \<rank\_status></Card>                                                                                                                                             |
| `03.180523.40` | `ERROR`  | Rank status changed to terminated <br /> <br /> <Card title="Error Message">Rank: \<rank> on host: \<hostname> is \<rank\_status></Card>                                                                                                                                                        |
| `03.190900.40` | `ERROR`  | Table monitor error <br /> <br /> <Card title="Error Message">Unable to prepare and send change notification for table \<table\_name>. \<error\_msg></Card>                                                                                                                                     |
| `03.211301.30` | `WARN`   | High-water mark eviction cycle in vram tier <br /> <br /> <Card title="Error Message">High-water mark limit reached in tier: \<vram>, beginning eviction cycle. current size:\<current\_size>, high:\<high\_watermark\_size> low:\<low\_watermark\_size></Card>                                 |
| `03.211302.30` | `WARN`   | High-water mark eviction cycle in ram tier <br /> <br /> <Card title="Error Message">High-water mark limit reached in tier: \<ram>, beginning eviction cycle. current size:\<current\_size>, high:\<high\_watermark\_size> low:\<low\_watermark\_size></Card>                                   |
| `03.211303.30` | `WARN`   | High-water mark eviction cycle in disk cache tier <br /> <br /> <Card title="Error Message">High-water mark limit reached in tier: \<disk>, beginning eviction cycle. current size:\<current\_size>, high:\<high\_watermark\_size> low:\<low\_watermark\_size></Card>                           |
| `03.211304.30` | `WARN`   | High-water mark eviction cycle in persist tier <br /> <br /> <Card title="Error Message">High-water mark limit reached in tier: \<persist>, beginning eviction cycle. current size:\<current\_size>, high:\<high\_watermark\_size> low:\<low\_watermark\_size></Card>                           |
| `03.211305.30` | `WARN`   | High-water mark eviction cycle in cold storage tier <br /> <br /> <Card title="Error Message">High-water mark limit reached in tier: \<cold>, beginning eviction cycle. current size:\<current\_size>, high:\<high\_watermark\_size> low:\<low\_watermark\_size></Card>                         |
| `03.212004.30` | `WARN`   | Persist tier is full <br /> <br /> <Card title="Error Message">Requested amount exceeds tier capacity, Need: \<bytes\_needed>, TotalRequested: \<bytes\_requested>, Avail: \<bytes\_available></Card>                                                                                           |
| `03.212504.40` | `ERROR`  | Persist file read error <br /> <br /> <Card title="Error Message">Unable to load table data file: '\<name>'</Card>                                                                                                                                                                              |
| `03.230800.40` | `ERROR`  | Unable to upgrade table data to current version <br /> <br /> <Card title="Error Message">Error upgrading table \<table\_name> \<reason></Card>                                                                                                                                                 |

## Reveal

| Event Code     | Severity | Description                                                                                                                                                                                                  |
| -------------- | -------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `09.180503.20` | `INFO`   | Reveal server status changed to starting <br /> <br /> <Card title="Error Message">The reveal server status has changed on hostname:\<hostname>, host\_mode:\<host\_mode>, reveal\_status:\<starting></Card> |
| `09.180504.20` | `INFO`   | Reveal server status changed to running <br /> <br /> <Card title="Error Message">The reveal server status has changed on hostname:\<hostname>, host\_mode:\<host\_mode>, reveal\_status:\<running></Card>   |
| `09.180505.20` | `INFO`   | Reveal server status changed to stopping <br /> <br /> <Card title="Error Message">The reveal server status has changed on hostname:\<hostname>, host\_mode:\<host\_mode>, reveal\_status:\<stopping></Card> |
| `09.180506.20` | `INFO`   | Reveal server status changed to stopped <br /> <br /> <Card title="Error Message">The reveal server status has changed on hostname:\<hostname>, host\_mode:\<host\_mode>, reveal\_status:\<stopped></Card>   |
| `09.180507.40` | `ERROR`  | Reveal server has terminated <br /> <br /> <Card title="Error Message">The reveal server status has changed on hostname:\<hostname>, host\_mode:\<host\_mode>, reveal\_status:\<terminated></Card>           |

## SQL Query Planner

| Event Code     | Severity | Description                                                                                                                                                                                                                         |
| -------------- | -------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `10.180503.20` | `INFO`   | SQL query planner server status changed to starting <br /> <br /> <Card title="Error Message">The SQL query planner status has changed on hostname:\<hostname>, host\_mode:\<host\_mode>, query\_planner\_status:\<starting></Card> |
| `10.180504.20` | `INFO`   | SQL query planner server status changed to running <br /> <br /> <Card title="Error Message">The SQL query planner status has changed on hostname:\<hostname>, host\_mode:\<host\_mode>, query\_planner\_status:\<running></Card>   |
| `10.180505.20` | `INFO`   | SQL query planner server status changed to stopping <br /> <br /> <Card title="Error Message">The SQL query planner status has changed on hostname:\<hostname>, host\_mode:\<host\_mode>, query\_planner\_status:\<stopping></Card> |
| `10.180506.20` | `INFO`   | SQL query planner server status changed to stopped <br /> <br /> <Card title="Error Message">The SQL query planner status has changed on hostname:\<hostname>, host\_mode:\<host\_mode>, query\_planner\_status:\<stopped></Card>   |
| `10.180507.40` | `ERROR`  | SQL query planner server has terminated <br /> <br /> <Card title="Error Message">The SQL query planner status has changed on hostname:\<hostname>, host\_mode:\<host\_mode>, query\_planner\_status:\<terminated></Card>           |


# Cluster
Source: https://docs.kinetica.com/content/admin/gadmin/cluster



<a />

The **Cluster** menu selection comprises several tabs that contain
information about all the machines in your cluster as well as configuration and
log file access. Summary data about your *Kinetica* cluster is pinned to the top
right of each tab within **Cluster**; it includes:

* The [status](/content/admin/services#statuses) of *Kinetica*
* How many users are connected to *Kinetica*
* How many requests per second are being made to *Kinetica*
* How many tables are present in this *Kinetica* cluster
* How many rows are present in this *Kinetica* cluster
* The uptime of this *Kinetica* cluster
* A refresh button to refresh the cluster information

<img alt="../../images/cluster_summary_bar.png" />

<a />

## Dashboard

The **Dashboard** page is also the [GAdmin](/content/admin/gadmin) homepage. It
highlights the most important information about all the machines in your
cluster, including CPU, Memory, and Disk usage.

<img alt="../../images/cluster_dashboard.png" />

## Ranks

The **Ranks** page displays important information about all the GPU
ranks being used in your cluster.

<img alt="../../images/cluster_ranks.png" />

<a />

## Admin

<Note>
  The **Cluster --> Admin** section is only available to users
  with the *System Admin* permission.
</Note>

The **Admin** page allows you to stop or start the database, rebuild the
database, rebalance the database, or review operation history (add, remove, or
rebalance node operations) information.

Click **Rebuild DB** to rebuild the database should you experience
database errors or some *tables* and/or *schemas* are unable to be queried.
All tables can be rebuilt **or** just tables with disk optimized columns and/or
tables with text search columns can be rebuilt. For more information on
rebuilding individual *tables* or *schemas*, see
[Rebuilding](/content/admin/gadmin/data#gadmin-table-rebuild).

Click **Rebalance DB** to optionally shuffle around sharded and
unsharded data across your cluster so all nodes could have roughly the same
amount of sharded and unsharded data. If choosing to rebalance unsharded data,
optionally provide a whitelist **or** blacklist of unsharded tables' names.

<img alt="../../images/cluster_admin.png" />

## License

<Note>
  The **Cluster --> License** section is only available to users
  with the *System Admin* permission.
</Note>

The **License** page provides management capability for the *Kinetica*
license used by the cluster.  The page will list the type, status, and
expiration date of the active license.

<Info>
  The license can only be modified when *Kinetica* is not running.
</Info>

<img alt="../../images/cluster_setup.png" />

## Config

<Note>
  The **Cluster --> Config** section is only available to users
  with the *System Admin* permission.
</Note>

The **Config** page allows you to edit the core *Kinetica* configuration
file and save the changes directly in [GAdmin](/content/admin/gadmin); this file maps
to the <Badge>/opt/gpudb/core/etc/gpudb.conf</Badge> file. Detailed
information about configuration file settings can be found on
[Configuration Reference](/content/config).

<Info>
  This tab can only be edited when *Kinetica* is not running.
</Info>

<img alt="../../images/cluster_config.png" />

<a />

## Alerts

The **Alerts** displays the most recent triggered alerts. Detailed
information about alerts and how to set them can be found on
[Alerting](/content/admin/alerting).

<img alt="../../images/cluster_alerts.png" />

<a />

## Logging

The **Logging** page displays the running system log file, updating
every two seconds. This file is *Kinetica's* main diagnostic tool and it is
located at
<Badge>/opt/gpudb/core/logs/host-manager-\<hostname>-\<date-time>.log</Badge>.

<Info>
  If the cluster uses a shared persist directory, each nodes' database log will
  be located in this directory as well.
</Info>

Select the **Pause Log** checkbox to pause the file updates.  The number
of displayed lines can be selected from **Lines**, and the displayed
lines can be filtered using **Filter** (select the **Exclude**
checkbox to instead exclude the filtered word or phrase).

<img alt="../../images/cluster_logging.png" />

### Setting Loggers

Click **Manage Logging Level** to open the
**Manage System Logging Level** window, where the per-rank logging level
for any system logger can be modified.

To view the active loggers and corresponding levels for each rank, select the
rank from the **Rank** drop-down menu above the
**Current Log Levels** list. Use the **Filter** below the list
to find a particular logger in the list.

To update a logger:

1. At the top of the window, select a rank or *ALL* from the **Rank**
   drop-down window.
2. Provide a logger name for the **Logger** field.
3. Select a logger level from the **Level** drop-down menu.
4. Click **Set Logger**.

<Tip>
  Instructions for manually changing the logging level via the
  `/opt/gpudb/core/etc/gpudb_logger.conf` file are located on the
  [Custom Logging](/content/admin/logging) documentation.
</Tip>

Any change will take effect immediately and be in effect until a subsequent
change is made to the same logger or the database is restarted. A database
restart will reset all loggers to their default levels, system-wide.

<img alt="../../images/cluster_sys_logging_level.png" />

## Debug

The **Debug** page displays debugging and metric information about your
cluster. Note that each section has nested information, so it's possible
to drill in for more details. From this page, you can also generate system
reports and access previous reports. A system report includes important logs
and files that can be sent to support ([support@kinetica.com](mailto:support@kinetica.com)) to help diagnose
any issues at hand.

<img alt="../../images/cluster_debug.png" />

<a />

## Demo

<Note>
  The **Cluster --> Demo** section is only available to users
  with the *System Admin* permission.
</Note>

The **Demo** page contains various data that you can load into
*Kinetica*. This data will help get you started using *Kinetica* as well as
demonstrate some key capabilities of the system. Each demo dataset contains
500,000 records; after loading the data into *Kinetica*, you have the option of
loading the same data again. The datasets with a
[Reveal Dashboard](/content/bi/reveal) button have a corresponding
Reveal dashboard that will be automatically setup in Reveal after ingesting the
data.

<img alt="../../images/cluster_demo.png" />

## Visualize

The **Visualize** page contains an overview of
[Reveal](/content/bi/reveal) as well as a quick link to Reveal.

<img alt="../../images/cluster_visualize.png" />


# Data
Source: https://docs.kinetica.com/content/admin/gadmin/data



All the data in the database can be viewed through
[GAdmin's](/content/admin/gadmin#gadmin) **Data** menu
selection. From here, you can manage each [schema](/content/concepts/schemas) in
the database and every [table](/content/concepts/tables) and
[view](/content/concepts/views) it contains;
use WMS to generate a heatmap of a *table* or *view* with geocoordinates; and
manage [graphs](/content/graph_solver/network_graph_solver).

## Tables

The **Tables** page provides information about all *schemas* and
contained *tables* & *views* in the database in a grid layout.

### Schema List

The initial grid lists the *schemas* accessible to the user.  Each *schema* is
displayed along with the total number of records across all the *tables* &
*views* it contains.

From this view, the following functionality is available:

* <img alt="refresh" /> (**Refresh**) -- refresh the list of *schemas*
* **+ Schema** -- create a new [schema](/content/concepts/schemas)
* **+ Table** -- [create](/content/admin/gadmin/data#gadmin-table-create) a new
  [table](/content/concepts/tables)
* **Rename** -- rename the selected *schema*
* **Delete** -- delete the selected *schema(s)*
* **Memory** -- display the current amount of used memory by the
  *tables* and *views* in the selected *schema(s)*
* **Filter** -- only display *schemas* matching the given search text
  and *schemas* containing *tables* and/or *views* matching the given search
  text
* **Sync Mode** -- if enabled, record counts will be accurate but
  potentially slower to update

<img alt="../../images/data_schema_list.png" />

### Table/View List

Clicking on a *schema* will show a grid view of all the *tables* & *views* that
*schema* contains, with details about each.  Available are the object type,
type of distribution ([replicated](/content/concepts/tables#replicated),
[sharded](/content/concepts/tables#sharding), or [neither](/content/concepts/tables#random-sharding)), feature set
(see list below), global access rights (read/write), keys
([primary](/content/concepts/tables#primary-key), [shard](/content/concepts/tables#shard-key), and
[foreign](/content/concepts/tables#foreign-key)) and associated columns, and the record count.

The types of objects are as follows:

* **T** -- [table](/content/concepts/tables)
* **MV** -- [materialized view](/content/concepts/materialized_views)
* **LV** -- [logical view](/content/sql/ddl/create-view#sql-create-view)
* **ME** -- *materialized*
  [external table](/content/concepts/external_tables)

The types of features are as follows:

* **PERS** *(PERSISTED)* -- the *table* exists on disk & in memory
  (i.e., not [memory-only](/content/concepts/tables_memory_only)) and will exist
  across database restarts
* **JOIN** -- a [join view](/content/concepts/joins) or
  *materialized view* that ends in a *join view*
* **RESU** *(RESULT\_TABLE)* -- results from endpoint operations like
  [Create Projection](/content/api/rest/create_projection_rest) and
  [Create Union](/content/api/rest/create_union_rest)
* **VIEW** -- a *filtered* [view](/content/concepts/views), a *join view*,
  or a *materialized view* that ends in a *filtered* or *join view*

From this view, the following functionality is available:

* <img alt="refresh" /> (**Refresh**) -- refresh the list of *tables* & *views*
* **+ Table** -- [create](/content/admin/gadmin/data#gadmin-table-create) a new *table*
* **Config** -- [modify](/content/admin/gadmin/data#gadmin-table-config) the selected *table*
* **Rename** -- rename the selected *table*
* **Move** -- [move](/content/admin/gadmin/data#gadmin-table-move) the selected *table(s)*
  and/or *view(s)* to a different *schema*
* **Delete** -- [delete](/content/admin/gadmin/data#gadmin-table-delete) the selected
  *table(s)* and/or *view(s)*
* **Rebuild** -- [rebuild](/content/admin/gadmin/data#gadmin-table-rebuild) the selected
  *table(s)* and/or *view(s)*
* **Memory** -- display the current amount of used memory for the
  selected *table(s)* and/or *view(s)*
* **Stats** -- display statistics regarding a selected column or all
  columns in the selected *table* or *view*, e.g., estimated cardinality, mean
  value, standard deviation, etc.; and recommendations for improving the
  structure of the table, e.g., dictionary encoding, smaller column type, etc.
* **Sec** -- manage row- and column-
  [security](/content/admin/gadmin/data#gadmin-row-col-security) for the selected *table* or
  *view*
* **Filter** -- only display *tables* and *views* matching the given
  search text
* **Sync Mode** -- if enabled, record counts will be accurate but
  potentially slow

<img alt="../../images/data_table_list.png" />

<a />

### Creating

A table can be created by clicking **Create** (underneath
**Tables**) on the left menu to navigate to the **Create Table**
page.  After configuring the name, containing *schema* name, distribution
scheme, keys, column set,
[tier strategy definition](/content/rm/concepts#rm-concepts-tier-strategy), and
[partitioning](/content/concepts/tables#partitioning), click **Create New Table**.

<img alt="../../images/data_table_create.png" />

<a />

#### Defining a Tier Strategy

From the **Edit Table** page:

* Click **+ Group** to append additional column strategy groupings to
  the table
* Click **+ Chain** to append additional priority definitions to a
  group
* Provide a comma-separated list of columns, an
  [eviction priority](/content/rm/concepts#rm-concepts-eviction-priority) for each
  available [tier](/content/rm/concepts#rm-concepts-tiers) (tiers are defined in
  <Badge>/opt/gpudb/core/etc/gpudb.conf</Badge>), and an optional predicate

  <Tip>
    Omit **Columns** to apply the strategy to the entire table
  </Tip>

<p><strong>Example</strong></p>

For instance, consider the following *tier strategy*, applied to a table with a
timestamp column named `last_seen`, a positive integer `id` column, and a
string `name` column:

```sql theme={null}
(
    (VRAM 1, RAM 9) WHERE last_seen > TIMESTAMPADD(DAY, -3, NOW()),
    (VRAM 1, RAM 8, DISK2 7)
),
(
    COLUMNS id, name
        (VRAM 2, RAM 10) WHERE last_seen > TIMESTAMPADD(MINUTE, -1, NOW())
)
```

To recreate this strategy in the *table* configuration interface:

<img alt="../../images/data_table_config_tiers.png" />

#### Partitioning

From the **Edit Table** page:

1. Select a [partition](/content/concepts/tables#partitioning) type.
2. Provide as many **Key(s)** as necessary. Click **+**
   to add key expressions.
3. Provide as many **Definition(s)** as necessary. Click **+**
   to add definitions.

<p><strong>Example</strong></p>

To create a *range-partitioned* table with the following criteria:

* partitioned by the date/time of the order
* partitions for years *2016*, *2017*, *2018*, & *2019*
* records not in that range go to the *default partition*

<img alt="../../images/data_table_config_partitions.png" />

<a />

### Configuring

To configure an existing *table*, click **Config**, update the
*table* configuration as necessary, and click **Apply**.  Click
**Reset** to discard any pending modifications.

Allowed modifications include:

* Renaming the *table*
* Modifying the [TTL](/content/concepts/ttl)
* Renaming the non-[primary](/content/concepts/tables#primary-key)/[shard](/content/concepts/tables#shard-key) key
  columns
* Modifying the type, subtype, storage, and properties of a
  non-*primary*/*shard key* column
* Removing any non-*primary*/*shard key* columns
* Adding new columns
* Adjusting the [tier strategy definition](/content/rm/concepts#rm-concepts-tier-strategy); see
  [Defining a Tier Strategy](/content/admin/gadmin/data#gadmin-table-tier-strat-define) for assistance.
* Adjusting the [table partitioning](/content/concepts/tables#partitioning); note that only
  existing range or list partitions can be adjusted

<img alt="../../images/data_table_config.png" />

<a />

### Moving

To move one or more *tables* and/or *views* to another *schema*, select the
*table(s)*/*view(s)* (avoid clicking any *table*/*view* name, as that will open
the [Data Grid](/content/admin/gadmin/data#gadmin-data-grid) page) and then click **Move**. In the
pop-up, select which *schema* to move them to and click **Move**.

<img alt="../../images/data_table_move.png" />

<a />

### Deleting

To delete one or more *tables* and/or *views*, select the *table(s)*/*view(s)*
(avoid clicking any *table*/*view* name, as that will open the
[Data Grid](/content/admin/gadmin/data#gadmin-data-grid) page) and then click **Delete**.  In the pop-up,
confirm the deletion.

<a />

### Rebuilding

To rebuild one or more *tables* and/or *views* if you are unable to query them,
select the *table(s)*/*view(s)* (avoid clicking any *table*/*view* name, as that
will open the [Data Grid](/content/admin/gadmin/data#gadmin-data-grid) page) and then click **Rebuild**.
In the pop-up, confirm the rebuild. Acknowledge the warning, then the selected
objects will be rebuilt. For more information on rebuilding the entire database,
see [Admin](/content/admin/gadmin/cluster#gadmin-db-rebuild).

<a />

### Detailed Table Information

To view *table*/*view* detail, structure, memory usage, and
[tier strategy](/content/rm/concepts#rm-concepts-tier-strategy) information, click
**Detail** in the **Info** column. The column grid can be
exported to CSV by clicking **Export CSV**.

<img alt="../../images/data_table_info.png" />

<a />

### WMS

If your data contains coordinates and/or geometry data, you can:

* When viewing the list of [tables](/content/concepts/tables)
  (**Data --> Tables**), click the **Map** link in the
  **WMS** column
* When browsing a *table's* [datagrid](/content/admin/gadmin/data#gadmin-data-grid), click the
  **WMS** button in the top bar

You can use the **+** / **-**  on the left or the scroll wheel
of your mouse to zoom in and out of an area. Click <img alt="pencil" /> to draw a polygon on
top of the map; this will act as a filter for the viewport. Click <img alt="trash" /> to
remove any polygons on the map. Click **Download PNG** to download a
`.png` file of the **current** viewport. Provide a table name and click
**Export Viewport** to export the points in the **current** viewport to
a separate table; note that if any polygon(s) were drawn on the
map, only the points inside those polygons will be exported to the new table.

<Info>
  The map will default to **Heatmap** mode.  To render full WKT
  geometry, click **Feature**. Whilst rendering features, click a
  feature on the map to display additional information about the feature.
</Info>

The following column [types](/content/concepts/types) can be used to populate the
map with latitude/longitude points (assuming the columns being used to render
the points are of the same type):

* `double`
* `float`
* `int`
* `int16`
* `int8`
* `long`
* `timestamp` (the raw epoch value will be used to render the point)
* `decimal`

The following column *types* can be used to populate the map with WKT objects:

* `wkt`
* `wkb`

If there are multiple WKT/WKB columns, select the desired column to display,
select **None** to not display any compatible column(s), or select **All** to
display all compatible column(s) next to **WKT**; if there are multiple
longitude / latitude columns, select the desired columns from the
**Lon/Lat** drop-down menus. If there are both WKT objects **and**
longitude / latitude points present in a table, select the WKT column to display
WKT or select **None** and the desired columns from the
**Lon/Lat** drop-down menus to display longitude / latitude points.

<img alt="../../images/data_table_map.png" />

<a />

### Data Grid

To view the individual records in a *table*, click the *table* name.  This
will display the **data grid** page.  From here, the following
functionality is available:

* <img alt="refresh" /> (**Refresh**) -- refresh the table
* **Add** -- insert a new record
* **Edit** -- modify the selected record
* **Delete** -- delete the selected record
* **Move** -- [move](/content/admin/gadmin/data#gadmin-table-move) the *table* or *view* to a
  different *schema*
* **Conf** -- [modify](/content/admin/gadmin/data#gadmin-table-config) the *table* or
  *view*
* **CSV** -- [export](/content/admin/gadmin/data#gadmin-data-export) data to CSV
* **Hide** -- hide displayed columns within the grid
* **Info** -- display table [detail](/content/admin/gadmin/data#gadmin-table-info)
* **Dist** -- display cross-node data distribution graph
* **Stats** -- display statistics regarding a selected column or all
  columns in the table, e.g., estimated cardinality, mean value,
  standard deviation, etc., and recommendations for improving the structure of
  the table, e.g., dictionary encoding, smaller column type, etc.
* **WMS** -- [plot](/content/admin/gadmin/data#gadmin-table-wms) data from *tables* with
  [geospatial data](/content/location_intelligence/geo_objects) on a map
* **Sec** -- manage row- and column-
  [security](/content/admin/gadmin/data#gadmin-row-col-security) for the table
* **Order Cols** -- If enabled, the columns will be displayed
  alphabetically
* **Sync Mode** -- if enabled, table row counts will be accurate but
  potentially slow

<img alt="../../images/data_table_datagrid.png" />

<a />

#### Export Data

From the **data grid** page, select **CSV**.  You will have
the option to export all of the data or records within a range, specify the type
of header, and how to order the data on export.

<img alt="../../images/data_export.png" />

Once you click the **Export** button, the data will be downloaded to
your computer as a CSV file using the format
`<schema>.<table>.csv`. The standard header is just a comma-delimited list of
column header names:

<img alt="../../images/data_exportfile_csv.png" />

The **Kinetica Schema** is a comma-delimited list of column headers with
pipe-delimited column properties:

<img alt="../../images/data_exportfile_kinetica.png" />

<Info>
  Null values are represented as `\N`.  This can be changed by
  modifying the `data_file_string_null_value` parameter in
  <Badge>/opt/gpudb/tomcat/webapps/gadmin/WEB-INF/classes/gaia.properties</Badge>.
</Info>

<a />

### Advanced Table Security

Advanced table security (e.g., row- and column-level) can be enabled on a
per-table basis for select users and roles by:

* When viewing the list of [tables](/content/concepts/tables)
  (**Data --> Tables**), select a table then click the
  **Sec** button in the top bar
* When browsing a *table's* [datagrid](/content/admin/gadmin/data#gadmin-data-grid), click the
  **Sec** button in the top bar

A user or role must have the `table_read` permission on a selected table for
the row- and/or column-level security to apply. Review
[Row-Level Security](/content/security/sec_concepts#sec-concepts-perm-table-row) and [Column-Level Security](/content/security/sec_concepts#sec-concepts-perm-table-col) for
more information.

<Note>
  Advanced Table Security can only be accessed by users with the
  `system_admin` permission.
</Note>

<img alt="../../images/data_table_security_user_example.png" />

#### Users

Individual users can have row- and column-level security imposed on them,
restricting or granting access to particular data. To apply security to a user:

1. Navigate to the **Advanced Table Security** window and display the
   **Users** tab.

2. Select a user from the list.

   <Info>
     Row- and column-level security cannot be configured for users with
     the `system_admin` permission.
   </Info>

3. Apply **Row Security** and **Column Security** as necessary.

   * To apply **Row Security**:

     1. Click the **Row Security** tab.

        <img alt="../../images/data_table_security_row_blank.png" />

     2. Provide a valid SQL `WHERE`-like expression in the **Filter**
        text field to specify entire rows the user has access to that meet the
        given filter condition.

   * To apply **Column Security**:

     1. Click the **Column Security** tab.

        <img alt="../../images/data_table_security_column_blank.png" />

     2. Select a column from the drop-down menu.

     3. Click **Add Column**.

     4. Optionally, if the column is a `string` column, select a
        **Transform** option:

        * **Mask** -- the column value will be masked after some length,
          for some width of characters, with a select character. If no mask
          exists for the column currently, one must be defined. Click <img alt="gear" /> to
          jump to the **Columns** table and define one. See
          [Columns](/content/admin/gadmin/data#col-mask) for more information.

        * **Obfuscate** -- each unique original column value will be
          exchanged for a unique non-negative number

        <Note>
          Review [Column-Level Security](/content/security/sec_concepts#sec-concepts-perm-table-col) for more
          information on masking and obfuscation.
        </Note>

     5. Optionally, apply a valid SQL `WHERE`-like expression in the
        **Filter** text field.

     6. Repeat the previous steps for as many columns as necessary.

4. Click **Save** and confirm the update for the selected user.

   <Tip>
     Click **Reset** to reset the modified security settings to
     the previously saved settings. Click **Clear** to remove
     any saved settings.
   </Tip>

#### Roles

Individual roles can have row- and column-level security imposed on them,
restricting or granting access to particular data. To apply security to a role:

1. Navigate to the **Advanced Table Security** window and display the
   **Roles** tab.

2. Select a role from the list.

   <Info>
     Row- and column-level security cannot be configured for roles with
     the `system_admin` permission.
   </Info>

3. Apply **Row Security** and **Column Security** as necessary.

   * To apply **Row Security**:

     1. Click the **Row Security** tab.

        <img alt="../../images/data_table_security_row_blank.png" />

     2. Provide a valid SQL `WHERE`-like expression in the **Filter**
        text field to specify entire rows the user has access to that meet the
        given filter condition.

   * To apply **Column Security**:

     1. Click the **Column Security** tab.

        <img alt="../../images/data_table_security_column_blank.png" />

     2. Select a column from the drop-down menu.

     3. Click **Add Column**.

     4. Optionally, if the column is a `string` column, select a
        **Transform** option:

        * **Mask** -- the column value will be masked after some length,
          for some width of characters, with a select character. If no mask
          exists for the column currently, one must be defined. Click <img alt="gear" /> to
          jump to the **Columns** table and define one. See
          [Columns](/content/admin/gadmin/data#col-mask) for more information.

        * **Obfuscate** -- each unique original column value will be
          exchanged for a unique non-negative number

        <Note>
          Review [Column-Level Security](/content/security/sec_concepts#sec-concepts-perm-table-col) for more
          information on masking and obfuscation.
        </Note>

     5. Optionally, apply a valid SQL `WHERE`-like expression in the
        **Filter** text field.

     6. Repeat the previous steps for as many columns as necessary.

4. Click **Save** and confirm the update for the selected role.

   <Tip>
     Click **Reset** to reset the modified security settings to
     the previously saved settings. Click **Clear** to remove
     any saved settings.
   </Tip>

<a />

#### Columns

Any `string` columns in the selected table can have pre-configured masks
applied when setting column-level security for a user or role. To create a mask
for a column:

1. Navigate to the **Advanced Table Security** window and display the
   **Columns** tab.
2. Select a valid column from the list.
3. Specify a **Start Position** for the mask.
4. Specify the **# of Masked Characters**.
5. Specify the **Mask Character**.
6. Optionally, type into the **Preview** field to preview the mask
   before saving.
7. Click **Save** and confirm the column mask.

<img alt="../../images/data_col_mask_preview_blank.png" />

#### Example

User `jsmith` is a human resources liaison for the engineering department
with access to employee information. The security for the `employees` table
that contains said information is configured in such a way that user `jsmith`:

* Can see full information for their own username
* Can only see the last 4 of an SSN and an obfuscated salary for employees
  outside of their assigned department

To configure the **Advanced Table Security** window for the above
scenario:

1. From the `employees` table, click **Sec** along the top, and then
   select `jsmith` from the **Users** list.

2. On the right side of the window, under **Row Security**, input the
   filter for the engineering department:

   <img alt="../../images/data_table_security_rowsec_example.png" />

3. Click **Column Security** and input the obfuscated `salary` column
   & the masked `ssn` column:

   <img alt="../../images/data_table_security_colsec_example.png" />

4. Click the <img alt="gear" /> icon next to **Mask** to configure the masking
   values:

   <img alt="../../images/data_table_security_colmask_example.png" />

5. Click **Save.**

<a />

## Graphs

The **Graphs** section provides the ability to manage and execute
operations against [graphs](/content/graph_solver/network_graph_solver).  The
following sections are available under **Graphs**:

* **Create** -- [create](/content/admin/gadmin/data#gadmin-graphs-create) a new graph
* **Query** -- [run a query](/content/admin/gadmin/data#gadmin-graphs-query) against an
  existing graph
* **Solve** -- [run a solver algorithm](/content/admin/gadmin/data#gadmin-graphs-solve)
  against an existing graph
* **Match** -- [run a matching algorithm](/content/admin/gadmin/data#gadmin-graphs-match)
  against an existing graph

The **Graphs** page displays any created graphs as well as various
information and statistics about each graph. Click **Request** under
**Source** to see the JSON used to create the graph as it is. Click
**+ Create** to open the
[Create Graph interface](/content/admin/gadmin/data#gadmin-graphs-create).
Click a graph then click **Delete** to delete the graph. Click
**Visualize** to use WMS to display the graph. Consult
[Graphs & Solvers Concepts](/content/graph_solver/network_graph_solver) for more information on graphs.
Consult [Distributed Graph Servers](/content/graph_solver/distributed_graph_server) for more information on
distributed graph servers.

<Tip>
  On any of the interfaces described below, click **History** to
  view previous requests made to that particular interface, view details
  about each request, reload a request, or view WMS for the request (if
  **Enable Graph Draw**  was set to `True`)

  <img alt="../../images/data_graph_history.png" />
</Tip>

<img alt="../../images/data_graphs.png" />

<a />

### Create

A graph can be created by clicking **Create** (underneath
**Graphs**) on the left menu to navigate to the **Create Graph**
page. Follow the steps below to create a graph using the interface:

<Note>
  It's highly recommended you consult
  [Graphs & Solvers Concepts](/content/graph_solver/network_graph_solver) and
  [/create/graph](/content/api/rest/create_graph_rest) for information on identifiers,
  valid configurations, combinations, and graph options before
  creating a graph with *GAdmin*. If multiple graph servers are
  available, it's also recommended you consult the
  [Distributed Graph Servers](/content/graph_solver/distributed_graph_server) documentation.
</Note>

1. Provide a name for the graph.
2. Choose whether the graph should be [directed](/content/graph_solver/network_graph_solver#directed-graphs)
3. Optionally, select a desired *node* [configuration](/content/graph_solver/network_graph_solver#id-combos) from the
   **Nodes** drop-down menu and click **Add +**. For each
   [identifier](/content/graph_solver/network_graph_solver#identifiers) that appears after adding the configuration
   to the graph, provide a column name, expression, or raw value (as outlined
   in [Components and Identifiers](/content/graph_solver/network_graph_solver#identifiers)) to use with the identifier. Repeat as necessary.
4. Select a desired *edge* [configuration](/content/graph_solver/network_graph_solver#id-combos) from the
   **Edges** drop-down menu and click **Add +**. For each
   [identifier](/content/graph_solver/network_graph_solver#identifiers) that appears after adding the configuration
   to the graph, provide a column name, expression, or raw value (as outlined
   in [Components and Identifiers](/content/graph_solver/network_graph_solver#identifiers)) to use with the identifier. Repeat as necessary.
5. Select a desired *weight* [configuration](/content/graph_solver/network_graph_solver#id-combos) from the
   **Weights** drop-down menu and click **Add +**. For each
   [identifier](/content/graph_solver/network_graph_solver#identifiers) that appears after adding the configuration
   to the graph, provide a column name, expression, or raw value (as outlined
   in [Components and Identifiers](/content/graph_solver/network_graph_solver#identifiers)) to use with the identifier. Repeat as necessary.
6. Optionally, select a desired *restriction* [configuration](/content/graph_solver/network_graph_solver#id-combos)
   from the **Restrictions** drop-down menu and click **Add +**.
   For each [identifier](/content/graph_solver/network_graph_solver#identifiers) that appears after adding the
   configuration to the graph, provide a column name, expression, or raw value
   (as outlined in [Components and Identifiers](/content/graph_solver/network_graph_solver#identifiers)) to use with the identifier. Repeat as
   necessary.
7. Adjust the options as desired.
8. Click **Create New Graph**.

<img alt="../../images/data_graphs_create.png" />

<a />

### Query

An existing graph can be queried by clicking **Query** (underneath
**Graphs**) on the left menu to navigate to the **Query Graph**
page. Follow the steps below to query a graph using the interface:

<Note>
  It's highly recommended you consult
  [Querying a Graph](/content/graph_solver/network_graph_solver#query-graph) and [/query/graph](/content/api/rest/query_graph_rest)
  for information on query identifiers, valid query configurations,
  query combinations, and query graph options before querying a
  graph with *GAdmin*. If multiple graph servers are
  available, it's also recommended you consult the
  [Distributed Graph Servers](/content/graph_solver/distributed_graph_server) documentation.
</Note>

1. Select an existing graph from the **Graph Name** drop-down menu.

2. Select a desired *query* [configuration](/content/graph_solver/network_graph_solver#query-combinations) from the
   **Queries** drop-down menu and click **Add +**. For each
   [query identifier](/content/graph_solver/network_graph_solver#query-identifiers) that appears after adding the
   configuration, provide a column name, expression, or raw value (as outlined
   in [Components and Identifiers](/content/graph_solver/network_graph_solver#identifiers)) to use with the query identifier. Repeat as necessary.

   <Tip>
     If you select `QUERY_NODE_WKTPOINT`, you can click <img alt="wkt_select" /> to
     open the graph in the WMS viewer and manually select point(s) on the
     map.

     <img alt="../../images/wkt_select_wms_src.png" />
   </Tip>

3. Optionally, select a desired *restriction* [configuration](/content/graph_solver/network_graph_solver#id-combos)
   from the **Restrictions** drop-down menu and click **Add +**.
   For each [identifier](/content/graph_solver/network_graph_solver#identifiers) that appears after adding the
   configuration, provide a column name, expression, or raw value
   (as outlined in [Components and Identifiers](/content/graph_solver/network_graph_solver#identifiers)) to use with the identifier. Repeat as
   necessary.

4. Provide an adjacency table name into which the results will be output.

5. Provide the number of rings (or hops) for the query.

6. Adjust the options as desired.

7. Click **Query Graph**.

<img alt="../../images/data_graphs_query.png" />

<a />

### Solve

An existing graph can be solved using a variety of methods by clicking
**Solve** (underneath **Graphs**) on the left menu to navigate
to the **Solve Graph** page. Follow the steps below to solve a graph
using the interface:

<Note>
  It's highly recommended you consult
  [Graphs & Solvers Concepts](/content/graph_solver/network_graph_solver),
  [/solve/graph](/content/api/rest/solve_graph_rest), and the
  [Solve Graph examples](/content/guides/tags/graph-solve) for
  information on identifiers, valid configurations, combinations,
  and options before solving a graph with *GAdmin*. If multiple
  graph servers are available, it's also recommended you consult the
  [Distributed Graph Servers](/content/graph_solver/distributed_graph_server) documentation.
</Note>

1. Select an existing graph from the **Graph Name** drop-down menu.

2. Optionally, select a desired *weight* [configuration](/content/graph_solver/network_graph_solver#id-combos) from
   the **Weights on Edges** drop-down menu and click **Add +**.
   For each [identifier](/content/graph_solver/network_graph_solver#identifiers) that appears after adding the
   configuration, provide a column name, expression, or raw value
   (as outlined in [Components and Identifiers](/content/graph_solver/network_graph_solver#identifiers)) to use with the identifier. Repeat as
   necessary.

3. Optionally, select a desired *restriction* [configuration](/content/graph_solver/network_graph_solver#id-combos)
   from the **Restrictions** drop-down menu and click **Add +**.
   For each [identifier](/content/graph_solver/network_graph_solver#identifiers) that appears after adding the
   configuration, provide a column name, expression, or raw value
   (as outlined in [Components and Identifiers](/content/graph_solver/network_graph_solver#identifiers)) to use with the identifier. Repeat as
   necessary.

4. Select a [solver](/content/graph_solver/network_graph_solver#solvers) from the **Solver Type** drop-down
   menu.

5. Select a node type from the **Source Nodes** drop-down menu and click
   **Add +**. For each field that appears after adding the node type,
   provide a column name, expression, or raw value (as outlined in
   [Components and Identifiers](/content/graph_solver/network_graph_solver#identifiers)) to use with the identifier. Repeat as necessary. If
   adding multiple source nodes, they should all be of the same type.

   <Tip>
     If you select `NODE_WKTPOINT`, you can click <img alt="wkt_select" /> to open
     the graph in the WMS viewer and manually select point(s) on the map.

     <img alt="../../images/wkt_select_wms_src.png" />
   </Tip>

6. Select a node type from the **Destination Nodes** drop-down menu and
   click **Add +**. For each field that appears after adding the node
   type, provide a column name, expression, or raw value (as outlined in
   [Components and Identifiers](/content/graph_solver/network_graph_solver#identifiers)) to use with the identifier. Repeat as necessary. If
   adding multiple source nodes, they should all be of the same type.

   <Tip>
     If you select `NODE_WKTPOINT`, you can click <img alt="wkt_select" /> to open
     the graph in the WMS viewer and manually select point(s) on the map.

     <img alt="../../images/wkt_select_wms_dest.png" />
   </Tip>

7. Provide a solution table name into which the results will be output.

8. Adjust the options as desired.

9. Click **Solve Graph**. A WMS request of the solution(s) will open.
   Click a solution route to see the start (<img alt="start" />) and end (<img alt="finish" />) points:

   <img alt="../../images/solve_graph_wms_solution.png" />

<img alt="../../images/data_graphs_solve.png" />

<a />

### Match

An existing graph can be matched using a variety of methods by clicking
**Match** (underneath **Graphs**) on the left menu to navigate
to the **Match Graph** page. Follow the steps below to match a graph
using the interface:

<Note>
  It's highly recommended you consult
  [Matching a Graph](/content/graph_solver/network_graph_solver#match-graph), [/match/graph](/content/api/rest/match_graph_rest),
  and the [Match Graph examples](/content/guides/tags/graph-match)
  for information on identifiers, valid configurations, combinations,
  and options before matching a graph with *GAdmin*. If multiple
  graph servers are available, it's also recommended you consult the
  [Distributed Graph Servers](/content/graph_solver/distributed_graph_server) documentation.
</Note>

1. Select an existing graph from the **Graph Name** drop-down menu.
2. Select a sample points [configuration](/content/graph_solver/network_graph_solver#match-combinations) from the
   **Sample Points** drop-down menu and click **Add +**. For
   each field that appears after adding the configuration, provide a column
   name, expression, or raw value (as outlined in [Components and Identifiers](/content/graph_solver/network_graph_solver#identifiers)) to use
   with the identifier. Repeat as necessary.
3. Select a [solver](/content/graph_solver/network_graph_solver#solvers) from the **Solve Method** drop-down
   menu.
4. Provide a solution table name into which the results will be output.
5. Adjust the options as desired.
6. Click **Match Graph**.

<img alt="../../images/data_graphs_match.png" />

<a />

## Import

The **Import Data** page outlines several methods of importing
data, from CLIs to GUIs to SQL. It also includes an example of importing data
using *KiFS*.


# Kinetica Administration Application (GAdmin)
Source: https://docs.kinetica.com/content/admin/gadmin/index



<a />

The Kinetica Administration application (GAdmin) is usually installed on port
8080 of the Kinetica instance or head node of the Kinetica cluster, so it can be
accessed via `http://localhost:8080/` or `http://<kinetica-host>:8080/`. The
GAdmin home page is the [Dashboard](/content/admin/gadmin/cluster), which shows cluster
information, such as [status](/content/admin/services#statuses) and CPU, Memory, and Disk usage.
More detailed statistics about your cluster and data can be found under the
**Stats** menu. A **Support** menu item links to documentation,
APIs, & drivers for your convenience. Overview of each GAdmin section can
be found below:

* [Cluster](/content/admin/gadmin/cluster)
* [Data](/content/admin/gadmin/data)
* [Query](/content/admin/gadmin/query)
* [UDF](/content/admin/gadmin/udf)
* [Jobs](/content/admin/gadmin/jobs)
* [Resource](/content/admin/gadmin/resource)
* [Security (Manage Users and Roles)](/content/admin/gadmin/security)
* [Info (Instance Information)](/content/admin/gadmin/info)
* [Stats](/content/admin/gadmin/stats)
* [Support](/content/admin/gadmin/support)
* [User](/content/admin/gadmin/user)

<Note>
  If Kinetica is stopped, only the **Cluster** page,
  the **Stats** page, and **Support** and **Logout**
  links will be available.
</Note>

<Info>
  Recommended minimum viewing resolution for *GAdmin* is `1280x1024`.
</Info>


# Info (Instance Information)
Source: https://docs.kinetica.com/content/admin/gadmin/info



Click **Info** in the top navigation menu to access several methods for
monitoring & checking the health of the system.

## Status

**Status** will display the main set of *Kinetica* metrics.

<img alt="../../images/info_status.png" />

## Diagnostics

**Diagnostics** will perform several tests on the *Kinetica*
server/cluster to determine whether or not the system is functioning properly.
The result should look similar to this:

<img alt="diagnostics" />

## Info

**Info** will show you configuration and version information about your
instance of *Kinetica*.

<img alt="versionInfo" />


# Jobs
Source: https://docs.kinetica.com/content/admin/gadmin/jobs



Click **Jobs** in the top navigation menu to access the
[Job Manager](/content/admin/job_manager) interface.

<Note>
  The **Jobs** section is only available to users
  with the *System Admin* permission.
</Note>

## Running

The **Running** page shows a list of currently executing jobs.  Jobs can
be cancelled by selecting them and then clicking **Cancel Jobs**, though
most jobs are processed quickly enough to be finished by the time they appear in
the job listing.  The listing is automatically refreshed at a selectable
interval, but can also be refreshed manually by clicking <img alt="refresh" />.  Jobs can be
searched for using **Filter**.

The **User Data** field corresponds to the user-defined tag submitted
when making the request, specified via the `job_user_data` options parameter.
Click <img alt="userdata" /> to view it.

<Note>
  Insert, update, and delete requests **cannot** be cancelled.
  Otherwise, most user-facing non-admin jobs are cancellable.
</Note>

<img alt="../../images/jobs_running.png" />

## Recent

The **Recent** page shows a list of recently executed jobs and the
completion time for each.  The number of recent jobs displayed can be selected
by clicking the **Show Last** drop-down.  The list can be manually
refreshed by clicking <img alt="refresh" />.

<img alt="../../images/jobs_recent.png" />


# Query
Source: https://docs.kinetica.com/content/admin/gadmin/query



Click **Query** in the top navigation menu to access several data
management tools.

<a />

## SQL Tool

The *SQL Tool* allows you to perform SQL queries against the data in
*Kinetica* from [GAdmin](/content/admin/gadmin). The *SQL Tool* works similarly to the
SQL Lab in [Reveal](/content/bi/reveal) but has fewer
restrictions. To read more about using the *SQL Tool* from the command line
(also known as *KiSQL*), review [Kinetica SQL (KiSQL)](/content/tools/kisql).

Several actions are available from this tool:

* Increase or decrease the **# of lines** to increase or decrease the
  size of the **SQL Statements** box.
* Select **Halt on Error** to halt SQL query execution if an error
  occurs. This is particularly useful when executing several statements in
  sequence as this will break on the first error in that sequence
* Click **Clear History** to remove all previously executed queries from
  the list.
* You can view and page through your query history using the **\< Prev**
  and **Next >** buttons, or view & select (for re-execution) from the
  entire history using the **Queries** button in between them. Once the
  **SQL Query History** window is open, use the filter box to search
  the history for a particular value and click a query to re-load it.
* You can select a **Schema**  to run queries in by default allowing you
  to query without specifying a fully qualified table name, e.g.,
  `FROM schema.table_name`. You can query outside of the set schema by
  providing a different schema in the **SQL Statements** area.
* If [HA](/content/ha) is enabled, you can select a particular
  **HA Cluster Node** to run the provided query against.
* Click **Clear** to clear both the **SQL Statements** &
  **Query Result** areas.
* After entering a query into the **SQL Statements** area, click
  **WMS** to create a WMS call from the query, which will place the
  results in a temporary table and open the [WMS](/content/admin/gadmin/data#gadmin-table-wms)
  window. Once done browsing, close the WMS window to delete the temporary
  table.
* After entering a query into the **SQL Statements** area, click
  **API** to generate the Python code necessary to run the same query
  via the native Python API.
* After entering one or more semicolon-terminated queries and/or DML/DDL
  commands into the **SQL Statements** area, click **Explain**
  to output a visual execution plan of the provided query.
* Select a portion of the text entered into **SQL Statements** and click
  **Run Highlighted** to execute only the selected portion.
* After entering one or more semicolon-terminated queries and/or DML/DDL
  commands into the **SQL Statements** area, click **Run SQL**
  to execute.

<Info>
  The WMS and Explain functionality can act on everything in the
  **SQL Statements** area or highlighted text, but they cannot
  be executed if there are multiple statements in the text area with
  nothing highlighted.
</Info>

<img alt="../../images/query_kisql.png" />

SQL snippets and autocomplete are also available to help expedite writing
queries.

<img alt="../../images/query_kisql_autocomplete.png" />

### Explain

The explain plan visualizer is a graphical complement to using the `EXPLAIN`
[keyword](/content/sql/query/explain#sql-explain) in a given query, providing visual detail to the
SQL query's execution plan,  execution time, and native API translation(s).

<Info>
  The explain plan visualizer cannot be used in conjunction with
  the `EXPLAIN` keyword.
</Info>

Clicking **Explain** will not execute the query (initially); the
database will walk through the native actions necessary to execute the query
and show the plan. Once the query plan is output, the query can be executed and
analyzed using the **Run & Analyze** button (with **Verbose**
optionally providing more execution detail).

For example, the executing the following:

```sql theme={null}
EXPLAIN
SELECT
    n_begin.ntaname AS boro_begin,
    boro_end,
    COUNT(*) AS total_trips
FROM
(
    SELECT pickup_latitude, pickup_longitude, n_end.ntaname AS boro_end
    FROM demo.nyctaxi t
    JOIN example_geospatial.nyc_neighborhood n_end ON STXY_INTERSECTS(dropoff_longitude, dropoff_latitude, geom)
)
JOIN example_geospatial.nyc_neighborhood n_begin ON STXY_INTERSECTS(pickup_longitude, pickup_latitude, geom)
GROUP BY 1, 2
```

Yields a text-only explain output:

```
+------+-------------------------+----------------------------------------------------------------------------------------------------------------------------------+------------------------------------------------------------------------+----------------+
| ID   | ENDPOINT                | INPUT_TABLES                                                                                                                     | OUTPUT_TABLE                                                           | DEPENDENCIES   |
+------+-------------------------+----------------------------------------------------------------------------------------------------------------------------------+------------------------------------------------------------------------+----------------+
| 0    | /create/jointable       | demo.nyctaxi AS TableAlias_0_,example_geospatial.nyc_neighborhood AS TableAlias_1_                                               | sys_sql_temp.Join_3_01234567_89ab_cdef_0123_456789abcdef               | -1             |
| 1    | /create/jointable       | sys_sql_temp.Join_3_01234567_89ab_cdef_0123_456789abcdef AS TableAlias_0_,example_geospatial.nyc_neighborhood AS TableAlias_1_   | sys_sql_temp.Join_5_01234567_89ab_cdef_0123_456789abcdef               | 0              |
| 2    | /aggregate/groupby      | sys_sql_temp.Join_5_01234567_89ab_cdef_0123_456789abcdef                                                                         | sys_sql_temp.ShardedAggregate_7_01234567_89ab_cdef_0123_456789abcdef   | 1              |
| 3    | /get/records/bycolumn   | sys_sql_temp.ShardedAggregate_7_01234567_89ab_cdef_0123_456789abcdef                                                             |                                                                        | 2              |
+------+-------------------------+----------------------------------------------------------------------------------------------------------------------------------+------------------------------------------------------------------------+----------------+
```

Running the same query (without the `EXPLAIN` keyword included) but this time
clicking **Explain** would yield the graphical query plan:

<img alt="../../images/query_explain_plan.png" />

<Tip>
  Hover over steps in the query plan to view the API call that would
  occur in the background when executing the original query. Hover over
  table names to view the table's schema. Click **Export JSON**
  to export the text-based explain output to a JSON file.
</Tip>

Subsequently, click **Run & Analyze** to execute the query and see the
execution time for each step in the plan.

<img alt="../../images/query_explain_plan_analyze.png" />

The steps are color-coded based on how fast they were in relation to the other
steps in the query.

If an error occurs in the query, it will be displayed in the plan at the point
it occurred.  Mousing over the error will show the details of the call and the
error message.

<img alt="../../images/query_explain_plan_analyze_error.png" />

### SQL Procedures

The **SQL Procedures** page displays all existing SQL procedures. Review
[SQL Procedures](/content/sql/procedure#sql-procedures) for more information on SQL procedures.

* Click **Create** to create a SQL procedure.
* Click **Execute** to manually execute the selected procedure. Note
  that any returned rows will not be displayed. Execute the procedure manually
  via the [SQL tool](/content/admin/gadmin/query#gadmin-sql) to view any output.
* Click **Drop** to remove the selected procedure.
* Click **Permissions** to adjust the execute permissions for the
  selected procedure.
* Click **Detail** to display the SQL procedure's definition.

<img alt="../../images/query_sql_procedures.png" />

#### Create

The SQL procedure creation process is simplified when using the interface;
all that's required to get started is some SQL code.

1. From the **SQL Procedures** page, click **Create**.

2. Provide a **Name** for the procedure.

3. Optionally, provide an **Execution Interval**. Units can be one of
   the following:

   * `SECOND[S]`
   * `MINUTE[S]`
   * `HOUR[S]`
   * `DAY[S]`

4. Optionally, provide a **Start Timestamp**. The provided value should
   be in the following format:

   ```
   YYYY-MM-DD [HH:MM[:SS]]
   ```

5. Provide one or more semi-colon-separated SQL statements in the
   **Statements** text field. Review the
   [supported statements](/content/sql/procedure#sql-procedures-statements).

6. Click **Create**.

#### Permissions

While all SQL procedures are able to be viewed by any user, they can only
be executed by certain users. To adjust the execute permissions for a particular
SQL procedure:

1. From the **SQL Procedures** page, select a SQL procedure and click
   **Permissions**.
2. Adjust the permissions as necessary:

   * Edit execute permissions for users:

     * *Add*: Click a user in the **Available** list and
       then click **Grant >>** to grant the user `sql_proc_execute`
       permission on the selected SQL procedure.
     * *Remove*: Click a user in the **SQL Proc-level Granted** list and
       then click **\<\< Revoke** to revoke the user's
       `sql_proc_execute` permission on the selected procedure.

   * Edit execute permissions for roles:

     * *Add*: Click a role in the **Available** list and
       then click **Grant >>** to grant the role `sql_proc_execute`
       permission on the selected SQL procedure.
     * *Remove*: Click a role in the **SQL Proc-level Granted** list and
       then click **\<\< Revoke** to revoke the role's
       `sql_proc_execute` permission on the selected procedure.

<a />

## API Tool

The *API Tool* allows you to call any *Kinetica*
[REST endpoint](/content/api/rest) with a given set of parameters.

**Request Mode** allows the choice of two methods for passing parameters
in endpoint calls:

* [Builder](/content/admin/gadmin/query#aqt-builder) - assign values to named parameters individually
* [JSON](/content/admin/gadmin/query#aqt-json) - pass the request as a single block of JSON text

The result of the request is output to the **Logs** panel.  Click
**Clear** at the bottom to clear the output.

The **History** tab lists previously executed commands and their
results.  Click **Reload** to load the selected endpoint and
associated parameters into the **Builder** for subsequent re-execution.
Click **Clear Saved Queries** in the top right-hand corner to delete the
query history.

Clicking the **API Docs** button will print the corresponding
documentation entry for the endpoint in the **Logs** panel to the right.

<img alt="../../images/query_advanced.png" />

<a />

### Builder

The **Builder** mode of the *API Tool* displays a user entry
control for each of the selected endpoint's parameters.  Each control will show
the parameter name & type and the option to enter the parameter as
**Text** or to use a parameter from the previous request's
**Response** or **Request** object.  The last set of parameters
used in an endpoint call will be saved until the next time the endpoint is
queried.

Each request will log the request parameters in JSON format at the top of the
**Logs** panel to the right.  This request block can then be fed back
into the *API Tool* in [JSON](/content/admin/gadmin/query#aqt-json) mode, which may facilitate
repeated querying, as the entire request can be seen and modified at one time.

Here is an example of a request to the [/aggregate/groupby](/content/api/rest/aggregate_groupby_rest) endpoint
in **Builder** mode:

<img alt="../../images/query_advanced_builder.png" />

<a />

### JSON

The **JSON** mode of the *API Tool* provides a user entry
control to enter the request parameters as a single block of JSON.  The last
JSON request will be saved until the next time the endpoint is queried.

Here is an example of a request to the [/aggregate/groupby](/content/api/rest/aggregate_groupby_rest) endpoint
in **JSON** mode:

<img alt="../../images/query_advanced_json.png" />

<a />

## DDL Tool

The *DDL Tool* provides the ability to generate DDL for a given *table*,
*schema*, or all database entities at once.

<img alt="../../images/query_kiddl.png" />

Enter a *table* name, *schema* name, or `*`, and click
**Generate DDL** to output the DDL to **DDL Output**.  Click
**Export DDL** to save the generated DDL as a SQL script.

The output from this utility can be copied into the **SQL Statements**
area on the **SQL Tool** page and run in order to regenerate the
database entities whose DDL has been generated.


# Resource
Source: https://docs.kinetica.com/content/admin/gadmin/resource



All resource management related information can be found in the
**Resource** section of *GAdmin*, including tier definitions, resource
groups, and resource statistics. From this section, resource groups can
be created and managed. Consult [Resource Management](/content/rm/concepts) for
more information.

<Note>
  The **Resource** section is only available to users
  with the *System Admin* permission.
</Note>

## Tiers

The **Tiers** page displays a summary of all
[tiers](/content/rm/concepts#rm-concepts-tiers) defined in
<Badge>/opt/gpudb/core/etc/gpudb.conf</Badge>.

<img alt="../../images/resource_tiers.png" />

## Groups

The **Groups** page displays all
[resource groups](/content/rm/concepts#rm-concepts-resource-groups) available for use in the
cluster. Click the arrows next to a non-system/non-default resource group to
change its ranking, then click **Apply Ranking** to save the ranking
change(s).

<img alt="../../images/resource_groups.png" />

### Creating Groups

1. From the list of **Resource Groups**, click **New**.
2. Type a **Name** for the new resource group.
3. Configure the new group's ranking by selecting a predicate then selecting
   another resource group (if necessary).
4. Provide the desired VRAM & RAM memory usage limits in bytes for the resource
   group.
5. Provide a maximum number of CPUs that can be used concurrently for the group,
   from `0` to *n* number of CPUs available to the cluster.
6. Provide a maximum [Scheduling Priority](/content/rm/concepts#rm-concepts-scheduling-priority) for the group, from
   `1` to `100` where `1` is the lowest priority.
7. Provide a maximum tier [Eviction Priority](/content/rm/concepts#rm-concepts-eviction-priority) for the group,
   from `1` to `10`.
8. Click **Create**.

<img alt="../../images/resource_group_create.png" />

### Editing Groups

1. From the list of **Resource Groups**, select a group and click
   **Edit**.
2. Update the VRAM and RAM memory usage limits as necessary.
3. Update the maximum CPU concurrency, [Scheduling Priority](/content/rm/concepts#rm-concepts-scheduling-priority),
   and/or tier [Eviction Priority](/content/rm/concepts#rm-concepts-eviction-priority) as necessary.
4. Click **Update**.

<img alt="../../images/resource_group_edit.png" />

### Deleting Groups

1. From the list of **Resource Groups**, select a group and click
   **Delete**.
2. Confirm the deletion by clicking **Delete** again.

   <Warning>
     All users in the deleted resource group will reverted back to being in
     the [default resource group](/content/rm/configuration#rm-config-resource-group-default).
   </Warning>

## Statistics

The **Statistics** page provides a detailed summary of each tier on
each rank in the cluster. Each tier has several sub-sections that can be
drilled into for detailed statistics.

<img alt="../../images/resource_stats.png" />


# Security (User/Role Management)
Source: https://docs.kinetica.com/content/admin/gadmin/security



<a />

<a />

All of your user and role management can be completed using *GAdmin*.

<Note>
  The **Security** section is only available to users
  with the `system_admin` or `system_user_admin` permission.
</Note>

## Users

The **Users** page lists the users in the system, whether they're
internal or externally authenticated, and a brief window into their access
rights.

<img alt="../../images/security_users.png" />

### Creating Users

When *Kinetica* has been configured to authenticate and/or authorize users,
user accounts can be created to allow access based on specific needs.  See
[Security Configuration](/content/security/sec_configuration) for details on different use cases.

<img alt="../../images/security_users_create.png" />

1. Create a New User Account

   * From **Security --> Users**, click **Create** under
     **Users** on the left-hand menu or **New** above the user
     list.

   * Select the type of **Authentication**. More information on
     the authentication types can be found under [Security Concepts](/content/security/sec_concepts).

   * Type a username into the **User** field and a password into the
     **Password** field, meeting the password strength requirements
     listed. Additional requirement details can be found under
     [Security Concepts](/content/security/sec_concepts)

     <Note>
       Passwords are required for Internal users only
     </Note>

   * Type the password again in the **Confirm Password** field.

2. Select Roles

   <img alt="../../images/security_users_roles.png" />

   * Add or remove roles as necessary in the **Member of Roles**
     section:

     * *Add*: Click a role in the **Available Roles** list and then
       click **Add >>**.
     * *Remove*: Click a role in the **Selected Roles** list and then
       click **\<\< Remove**.

3. Select Permissions

   <img alt="../../images/security_users_permissions.png" />

   * Check one or more
     [system-level permissions](/content/security/sec_concepts#security-concepts-permissions-system), as
     necessary.
   * Select the **Proc Level Permissions** box as necessary if allowing
     the user to execute all procs in the system (`proc_execute` permission).
     Review [User-Defined Functions Overview](/content/udf_overview) for more information on procs and UDFs.
   * In the next section,
     [table-level permissions](/content/security/sec_concepts#security-concepts-permissions-table) can be
     managed, controlling access to individual database schemas, tables, &
     views.  The permission-to-object association will be displayed below the
     selection boxes, and the **Effective Permissions** table will be
     updated accordingly.  Note that the *Table Admin* permission allows a user
     full access on a table.

     * *Add*: Select a schema, table, or view in the left list and a permission
       in the right list, and then click **Add**.
     * *Remove*:  Select an existing object-permission association in the list
       of active permissions and click **Remove**.

4. Resource Group

   * Select a [Resource Group](/content/rm/concepts#rm-concepts-resource-groups) from the
     drop-down menu. Consult [Resource](/content/admin/gadmin/resource) for more information on
     configuring resource groups in GAdmin.

5. Default Schema

   * Select a [Default Schema](/content/concepts/schemas#schema-default) from the
     drop-down menu. Consult [Schemas](/content/concepts/schemas) for more information on
     *schemas*.

6. Click **Create**.

### Editing Users

Existing users can have their roles, permissions, resource group, and
default schema updated.

1. Edit a User Account

   * From **Security --> Users**, select a user to edit and click
     **Edit**.

2. Update Roles

   <img alt="../../images/security_users_roles.png" />

   * Add or remove selected roles as necessary in the
     **Member of Roles** section:

     * *Add*: Click a role in the **Available Roles** list and
       then click **Add >>**.
     * *Remove*: Click a role in the **Selected Roles** list and then
       click **\<\< Remove**.

3. Update Permissions

   <img alt="../../images/security_users_permissions.png" />

   * Check/uncheck one or more
     [system-level permissions](/content/security/sec_concepts#security-concepts-permissions-system), as
     necessary.
   * Check/uncheck the **Proc Level Permissions** box as necessary if
     allowing/disallowing the user to execute all procs in the system
     (`proc_execute` permission). Review [User-Defined Functions Overview](/content/udf_overview) for more
     information on procs and UDFs.
   * In the next section,
     [table-level permissions](/content/security/sec_concepts#security-concepts-permissions-table) can be
     managed, controlling access to individual database schemas, tables, &
     views.  The permission-to-object association will be displayed below the
     selection boxes, and the **Effective Permissions** table will be
     updated accordingly.  Note that the *Table Admin* permission allows a user
     full access on a table.

     * *Add*: Select a schema, table, or view in the left list and a permission
       in the right list, and then click **Add**.
     * *Remove*:  Select an existing object-permission association in the list
       of active permissions and click **Remove**.

4. Update Resource Group

   * Update the [Resource Group](/content/rm/concepts#rm-concepts-resource-groups) from the
     drop-down menu. Consult [Resource](/content/admin/gadmin/resource) for more information on
     configuring resource groups in GAdmin.

5. Update Default Schema

   * Update the [Default Schema](/content/concepts/schemas#schema-default) from the
     drop-down menu. Consult [Schemas](/content/concepts/schemas) for more information on
     *schemas*.

6. Click **Save**.

### Changing Passwords

Existing users can have their passwords changed by administrators with either
the `system_admin` or `system_user_admin` permission. To change a user's
password:

1. From **Security --> Users**, select a user whose password will
   be changed and click **Change Password**
2. Type the password into the **New Password** field, meeting the
   password strength requirements listed. Additional requirement details can be
   found on [Security Concepts](/content/security/sec_concepts)
3. Type the password again in the **Confirm Password** field
4. Click **Save**.

<img alt="../../images/security_users_changepass.png" />

### Deleting Users

An administrator can also delete a user from the database.  This will not remove
any database objects created by the user (schemas, tables, groups, etc.),
nor will it remove the user from any external user store (LDAP, etc.).

To delete a user:

1. From **Security --> Users**, select a user to delete and click
   **Delete**.
2. At the **Delete User** prompt, click **Remove**.

## Roles

The **Roles** page lists the roles in the system, the role memberships
(both containing & contained), and a brief window into their permissions.

<img alt="../../images/security_roles.png" />

### Creating Roles

When *Kinetica* has been configured to authenticate and/or authorize users,
user accounts can be created to allow access based on specific needs.  See
[Security Configuration](/content/security/sec_configuration) for details on different use cases.

<img alt="../../images/security_roles_create.png" />

1. Create a New Role

   * From **Security --> Roles**, click **Create** under
     **Roles** on the left-hand menu or **New** above the role
     list.
   * Type a name for the role into the **Role** field. Additional
     requirement details can be found on [Security Concepts](/content/security/sec_concepts)

2. Apply and Grant Roles

   * In the **Roles** section, apply existing roles to the new role:

     * *Add*: Click a role in the **Available** list and
       then click **Add >>**.
     * *Remove*: Click a role in the **Selected** list and then
       click **\<\< Remove**.

   * In the **Users/Roles Granted This Role** section, apply the new
     role to existing user(s) and/or role(s):

     * *Add*: Click a role in the **Available** list and
       then click **Add >>**.
     * *Remove*: Click a role in the **Selected** list and then
       click **\<\< Remove**.

3. Select Permissions

   <img alt="../../images/security_users_permissions.png" />

   * Check one or more
     [system-level permissions](/content/security/sec_concepts#security-concepts-permissions-system), as
     necessary.
   * Select the **Proc Level Permissions** box as necessary if allowing
     the role to execute all procs in the system (`proc_execute` permission).
     Review [User-Defined Functions Overview](/content/udf_overview) for more information on procs and UDFs.
   * In the next section,
     [table-level permissions](/content/security/sec_concepts#security-concepts-permissions-table) can be
     managed, controlling access to individual database schemas, tables, &
     views.  The permission-to-object association will be displayed below the
     selection boxes, and the **Effective Permissions** table will be
     updated accordingly.  Note that the *Table Admin* permission allows a user
     full access on a table.

     * *Add*: Select a schema, table, or view in the left list and a permission
       in the right list, and then click **Add**.
     * *Remove*:  Select an existing object-permission association in the list
       of active permissions and click **Remove**.

4. Resource Group

   * Select a [Resource Group](/content/rm/concepts#rm-concepts-resource-groups) from the
     drop-down menu. Consult [Resource](/content/admin/gadmin/resource) for more information on
     configuring resource groups in GAdmin.

5. Click **Create**.

### Editing Roles

Existing roles can have their permissions, users & roles assigned to, and
resource group.

1. Edit a Role

   * From **Security --> Roles**, select a role to edit and
     click **Edit**.

2. Apply and Grant Roles

   * In the **Roles** section, apply other existing roles to the role:

     * *Add*: Click a role in the **Available** list and
       then click **Add >>**.
     * *Remove*: Click a role in the **Selected** list and then
       click **\<\< Remove**.

   * In the **Users/Roles Granted This Role** section, apply the
     role to other existing user(s) and/or role(s):

     * *Add*: Click a role in the **Available** list and
       then click **Add >>**.
     * *Remove*: Click a role in the **Selected** list and then
       click **\<\< Remove**.

3. Update Permissions

   <img alt="../../images/security_users_permissions.png" />

   * Check/uncheck one or more
     [system-level permissions](/content/security/sec_concepts#security-concepts-permissions-system), as
     necessary.
   * Check/uncheck the **Proc Level Permissions** box as necessary if
     allowing/disallowing the role to execute all procs in the system
     (`proc_execute` permission). Review [User-Defined Functions Overview](/content/udf_overview) for more
     information on procs and UDFs.
   * In the next section,
     [table-level permissions](/content/security/sec_concepts#security-concepts-permissions-table) can be
     managed, controlling access to individual database schemas, tables, &
     views.  The permission-to-object association will be displayed below the
     selection boxes, and the **Effective Permissions** table will be
     updated accordingly.  Note that the *Table Admin* permission allows a user
     full access on a table.

     * *Add*: Select a schema, table, or view in the left list and a permission
       in the right list, and then click **Add**.
     * *Remove*:  Select an existing object-permission association in the list
       of active permissions and click **Remove**.

4. Update Resource Group

   * Update the [Resource Group](/content/rm/concepts#rm-concepts-resource-groups) from the
     drop-down menu. Consult [Resource](/content/admin/gadmin/resource) for more information on
     configuring resource groups in GAdmin.

5. Click **Save**.

### Deleting Roles

An administrator can also delete a role from the database.  This disassociates
the role from any users or other roles that are currently associated with it.
Roles in any associated external user stores (LDAP, etc.) will be unaffected.

To delete a role:

1. From **Security --> Roles**, select a role to delete and click
   **Delete**.
2. At the **Delete Role** prompt, click **Remove**.


# Stats
Source: https://docs.kinetica.com/content/admin/gadmin/stats



Detailed statistics dashboards about *Kinetica* and its host(s) can be accessed
under the **Stats** menu. Collected statistics are divided into four
groups:

* *Kinetica*
* [Tiered storage and resource groups](/content/rm/concepts)
* System
* GPU (if the CUDA version of Kinetica is installed)

<Note>
  The **Stats** section is only available to users
  with the *System Admin* permission.
</Note>

## Kinetica

The **Kinetica DB Overview** dashboard is home to metrics related to the
performance and health of your entire *Kinetica* instance. These metrics are
also available on a per-processing-node basis for each node in your cluster,
e.g., your head *Kinetica* node and any workers.

<Tip>
  This dashboard (and some of the others) support viewing individual
  metrics via the drop-down menus in the top-left corner.
</Tip>

<img alt="../../images/stats_kinetica_overview.png" />

## Tiered Storage and Resource Groups

The tiered storage and resource groups metrics are grouped into three stats
dashboards:

* **Memory Tiers** -- metrics related to the memory-based storage tiers,
  e.g., [VRAM](/content/rm/concepts#rm-concepts-tiers-vram) and
  [RAM](/content/rm/concepts#rm-concepts-tiers-ram)
* **File Backed Tiers** -- metrics related to the file-backed storage
  tiers, e.g., [Disk Cache](/content/rm/concepts#rm-concepts-tiers-disk),
  [Persist](/content/rm/concepts#rm-concepts-tiers-persist), and
  [Cold Storage](/content/rm/concepts#rm-concepts-tiers-cold)
* **Resource Groups** -- metrics related to the
  [resource groups](/content/rm/concepts#rm-concepts-resource-groups) that work within the
  database

## Systems Overview

The **Host Systems Overview** dashboard is home to metrics related to
the machine(s) *Kinetica* is installed on. These metrics are also available
on a per-host basis for each node in your cluster.

## GPU Overview

This dashboard is home to metrics related to the performance and health of your
GPUs (if applicable).


# Support
Source: https://docs.kinetica.com/content/admin/gadmin/support



The **Support** menu contains links to *Kinetica* documentation, as well
as API & driver downloads.

## Docs

**Docs** links to *Kinetica* system & API documentation, covering all
facets of using & managing the database and related applications & services.

## APIs

**APIs** links to the API download page, where both the native database
and UDF APIs can be downloaded in each of the supported development languages.

## Drivers

**Drivers** links to the *GitHub* projects for each of the *Kinetica*
integration connectors.  Detail & usage information for those connectors can
be found under [Connectors](/content/connectors).


# UDF
Source: https://docs.kinetica.com/content/admin/gadmin/udf



The **UDF** menu allows you to manage your
*User-Defined Functions (UDFs)*. The **UDF** menu is only
available if *UDFs* have been enabled.  See [User-Defined Function Implementation](/content/udf) for *UDF*
configuration requirements and [User-Defined Functions Overview](/content/udf_overview) for detail on *UDFs*
themselves.

<Note>
  The **UDF** section is only available to users
  with the `system_admin` role or the `proc_execute` permission.
</Note>

## UDF

**UDF** is the *UDF* homepage and allows executing, creating,
editing, and deleting *UDFs*. For more detail on Running UDFs, see the
[Running Python](/content/udf/python/running) or
[Running C++](/content/udf/cpp/running) UDF pages
(depending on your preference).

<img alt="../../images/udf_procs.png" />

### Creating Procs

Click **New** to create a new proc.

<img alt="../../images/udf_procs_new.png" />

Provide the name of the proc, command necessary to run the proc file (e.g.,
`python`), and any command-line arguments (e.g., custom *Python* or *C++*
arguments; click **Add** to add additional arguments), then fill
the **Distributed** checkbox if the *UDF* should be in
distributed mode and fill the
[Limit Concurrency](/content/udf/concurrency_limits#concurrency-limits) checkbox and type a number
to set a concurrency limit. Finally, upload a proc file(s) by clicking
**Choose file(s)** and selecting the proc file(s) from your
computer.

Here's an example of a proc being created in GAdmin:

<img alt="../../images/udf_procs_new_filled.png" />

### Executing UDFs

To execute a UDF, click a *UDF* then click **Execute**.

<img alt="../../images/udf_procs_execute.png" />

Provide a run tag if desired (see [/execute/proc](/content/api/rest/execute_proc_rest) for
more information on run tags), click **Add** to add additional
parameter names and values, input tables and columns, and/or output tables, then
click **Execute**.

Here's an example of the same proc being set up for execution in GAdmin:

<img alt="../../images/udf_procs_execute_filled.png" />

### Editing UDFs

To edit a *UDF*, select a *UDF* then click **Edit**. Edit the
name or command as necessary, then add or edit arguments. Select the
**Distributed** checkbox if the *UDF* should run in distributed
mode, or clear the checkbox if the *UDF* should run in non-distributed mode.
Select the **Limit Concurrency** checkbox and adjust the setting
to set a concurrency limit, or clear the checkbox to remove the limit. Once
editing is finished, click **Save**.

<Note>
  You cannot change the file for the proc once it has been
  uploaded.
</Note>

<img alt="../../images/udf_procs_edit.png" />

### Deleting UDFs

To delete a *UDF*, select a *UDF* then click **Delete** and
confirm the deletion of the selected *UDF*.

### Permissions

To adjust the permissions of a particular *UDF*, select a *UDF* then click
**Permissions**. A list of available users and roles will display
alongside lists of users and roles that have the `proc_execute` permission for
the selected *UDF* as well as `proc_execute` permission for all *UDFs*.

<img alt="../../images/udf_permissions.png" />

<Note>
  To grant a user or role execute permission to all procs, the
  `proc_execute` will need to be applied via the
  [Security](/content/admin/gadmin/security) page.
</Note>

* Edit execute permissions for users:

  * *Add*: Click a user in the **Available** list and then click
    **Grant >>** to grant the user `proc_execute` permission on
    the selected UDF.
  * *Remove*: Click a user in the **Proc-level Granted** list and
    then click **\<\< Revoke** to revoke the user's
    `proc_execute` permission on the selected UDF.

* Edit execute permissions for roles:

  * *Add*: Click a role in the **Available** list and then click
    **Grant >>** to grant the role `proc_execute` permission on
    the selected UDF.
  * *Remove*: Click a role in the **Proc-level Granted** list and
    then click **\<\< Revoke** to revoke the role's
    `proc_execute` permission on the selected UDF.

## Status

**Status** displays active, idle, and completed procs. Like
[Job Manager](/content/admin/job_manager), this page is automatically refreshed based on
the selected interval, so you can see procs' statuses and total run time update
at each interval. This page can be manually refreshed by clicking <img alt="refresh" />.

<img alt="../../images/udf_status.png" />

To kill a stalled proc/tag, select the proc then click **Kill**.
Select **Run ID** or **Run Tag** to kill this proc
instance or all proc instances with the listed tag respectively. See
[/kill/proc](/content/api/rest/kill_proc_rest) for more information on run tags.

<img alt="../../images/udf_procs_kill.png" />

Once a proc has been completed or killed, you can clear out the status list
by clicking **Clear Completed**.

Click the **Run ID** to see a detailed status of the UDF execution
process.

<img alt="../../images/udf_detailed_status.png" />


# User
Source: https://docs.kinetica.com/content/admin/gadmin/user



Click your username in the top navigation menu to review open *GAdmin* sessions,
change your password, or log out of *GAdmin*.

## Sessions

Click **Sessions** to open the list of currently open *GAdmin* sessions.
Select any of the sessions not designated as **Current** (displays the
<img alt="current" /> logo) and click **Terminate** to remotely terminate that
session. The user for the session will be forced to login again.

<img alt="../../images/admin_sessions.png" />

## Change Password

Click **Change Password** to change your password.  The new password
must meet the password strength requirements listed.  Click **Save** to
confirm the password change.

<img alt="../../images/admin_changepassword.png" />

## Logout

Click **Logout** to end the current *GAdmin* session and return to the
login page.


# Host Manager
Source: https://docs.kinetica.com/content/admin/host_manager



*Host Manager* is a supervisor process that manages several processes that are
part of each *Kinetica* install. The following processes are managed by *Host*
*Manager* and will be restarted if they fail unexpectedly:

* Database Services
* Text Search
* ODBC Server
* HTTPD

<Info>
  Read more about managing the *Host Manager* process on
  [Managing Kinetica Services](/content/admin/services).
</Info>

The *Host Manager* also serves the following endpoints:

* [/admin/add/host](/content/api/rest/admin_add_host_rest)
* [/admin/alter/host](/content/api/rest/admin_alter_host_rest)
* [/admin/remove/host](/content/api/rest/admin_remove_host_rest)
* [/admin/show/alerts](/content/api/rest/admin_show_alerts_rest)
* [/admin/switchover](/content/api/rest/admin_switchover_rest)


# Administration
Source: https://docs.kinetica.com/content/admin/index

Kinetica administration and service management

## Topics

<CardGroup>
  <Card title="Kinetica Workbench" href="/content/admin/workbench">
    * [Workbench UI](/content/admin/workbench/ui)
    * [SQL Workbooks](/content/admin/workbench/workbooks)
  </Card>

  <Card title="Kinetica Administration Application (GAdmin)" href="/content/admin/gadmin">
    * [Cluster](/content/admin/gadmin/cluster)
    * [Data](/content/admin/gadmin/data)
    * [Query](/content/admin/gadmin/query)
    * [UDF](/content/admin/gadmin/udf)
    * [Jobs](/content/admin/gadmin/jobs)
    * [Resource](/content/admin/gadmin/resource)
    * [Security (User/Role Management)](/content/admin/gadmin/security)
    * [Info (Instance Information)](/content/admin/gadmin/info)
    * [Stats](/content/admin/gadmin/stats)
    * [Changing the Administrator Password](/content/admin/changing_password)
  </Card>

  <Card title="KAgent" href="/content/admin/kagent/kagent">
    * [KAgent](/content/admin/kagent/kagent#kagent-concept)
    * [Features](/content/admin/kagent/kagent#kagent-features)
    * [Notifications](/content/admin/kagent/kagent#kagent-ui-notifications)
    * [KAgent CLI](/content/admin/kagent/kagent#kagent-cli-params)
    * [Backing Up/Restoring Kinetica](/content/admin/backup_restore)
    * [Adding a Cluster to KAgent](/content/admin/adding_cluster_kagent)
    * [Monitoring and Alerting](/content/admin/monitoring_alerting)
  </Card>

  <Card title="Upgrade" href="/content/admin/upgrade">
    * [Upgrade Tasks](/content/admin/upgrade#upgrade-tasks)
    * [Upgrade Actions](/content/admin/upgrade#upgrade-actions)
    * [Managed Cluster Upgrade](#managed-cluster-upgrade)
    * [Unmanaged Cluster Upgrade](/content/admin/upgrade#unmanaged-cluster-upgrade)
    * [Upgrading Database Clients](/content/admin/upgrade#upgrade-database-clients)
    * [Upgrading Client APIs](/content/admin/upgrade#upgrade-database-clients-apis)
    * [Upgrading ODBC/JDBC Drivers](/content/admin/upgrade#upgrade-database-clients-drivers)
  </Card>

  <Card title="Backup/Restore" href="/content/admin/backup_restore">
    * [Database Backup](/content/admin/backup_restore#database-backup)
    * [System Backup](/content/admin/backup_restore#system-backup)
  </Card>

  <Card title="Custom Logging & Services">
    * [Custom Logging](/content/admin/logging)
    * [Managing Kinetica Services](/content/admin/services)
  </Card>
</CardGroup>

## Product Highlights

<CardGroup>
  <Card title="Intuitive UI">
    Manage the deployment, run queries, and manage database objects with simple user interfaces
  </Card>

  <Card title="Monitor & Alert">
    Monitor Kinetica and configure alerts with an intuitive user interface
  </Card>

  <Card title="Back Up and Restore">
    Get back up and running quickly with our back up and restoration tool
  </Card>
</CardGroup>

## How-To Guides

<CardGroup>
  <Card title="Quick Start Guide" icon="book" href="/content/guides/quickstart-guide/index">
    Get started with Kinetica Workbench

    Length: 15 MIN
  </Card>
</CardGroup>

## Next Steps

Now that you are familiar with Kinetica's administrative capabilities, here are a few resources to check out next:

* [SQL](/content/sql/index)
* [Load Data](/content/load_data/index)
* [Integration](/content/integrate)


# Job Manager
Source: https://docs.kinetica.com/content/admin/job_manager



The *Job Manager* maintains request ordering across the nodes in your *Kinetica*
cluster at the cost of some performance. All read requests (`/show/table`,
`/get/records`, etc.) are processed simultaneously. When a write request
(`/insert/records`, `/delete/records`, etc.) is made, all subsequent read
and write requests are blocked until the current write request is finished.

If *Job Manager* is disabled, all inbound requests are broadcasted to all
worker nodes and can be executed in any order.

While enabled by default, *Job Manager* can be disabled by setting the
**enable\_job\_manager** configuration parameter to `false` in the
<Badge>gpudb.conf</Badge> file.

The *Job Manager* interface is available through
[GAdmin](/content/admin/gadmin/jobs), which allows jobs to be monitored and
cancelled, if needed.

Because read requests are processed simultaneously, read jobs can only be
cancelled while a preceding write request is being processed, which is also
referred to as a checkpoint.

<Note>
  Insert, update, and delete requests **cannot** be cancelled.
  Otherwise, most user-facing non-admin jobs are cancellable.
</Note>

When using any endpoint, you can specify a name, number, or other tag to help
identify a particular job using the `job_user_data` options parameter; e.g.,
(in Python):

```python theme={null}
h_db.insert_records(
  table_name = "test_table_all_types",
  data = encoded_obj_list, list_encoding = 'binary',
  options = {
    "job_user_data":"insert_records_large_table"
  }
)
```


# Alerts
Source: https://docs.kinetica.com/content/admin/kagent/alerts



The **Alerts** page in *KAgent* hosts alert configuration and management
as well as alert history. Visit [Monitoring and Alerting](/content/admin/monitoring_alerting) for an
overview of *KAgent's* monitoring and alerting capabilities, including
configuring alerts and recipients. The **Alerts** page is divided into
five tabs:

<a />

## History

The **History** tab displays a detailed alert history. Use the paging
controls below the list of alerts to navigate through the history.

<img alt="../images/alerts_history.png" />

<a />

## Metric Alerts

The **Metric Alerts** tab displays the currently configured metric
alerts. Metric alerts can be used to track the value of a metric and send a
notification via email or in *KAgent* when the value crosses a given threshold.
Visit [Monitoring and Alerting](/content/admin/monitoring_alerting#metric-alerts-concept) for more
information on configuration and usage.

* Click **+ Add Metric Alert** to start
  [creating an alert](/content/admin/monitoring_alerting#create-metric-alert)
* For existing metric alerts:

  * Click **Recipients** to adjust the recipients of the alert
  * Click **Edit** to adjust the metric alert configuration
  * Click **Delete** to delete the metric alert

<img alt="../images/metric_alerts.png" />

<a />

## Event Alerts

The **Event Alerts** tab displays the currently configured event
alerts. Event alerts can be used to track specific system events and send a
notification via email or in *KAgent* when the event occurs. Visit
[Monitoring and Alerting](/content/admin/monitoring_alerting#event-alerts-concept) for more information on
configuration and usage.

* Click **+ Add Event Alert** to start
  [creating an alert](/content/admin/monitoring_alerting#create-event-alert)
* For existing event alerts:

  * Click **Recipients** to adjust the recipients of the alert
  * Click **Delete** to delete the alert

<img alt="../images/event_alerts.png" />

## Default Alerts

Default alerts are preconfigured by *Kinetica* and will be broadcast to all
web users as a notification. Click **Disable** to disable the default
alert.

<img alt="../images/default_alerts.png" />

<a />

## Recipients

The **Recipients** tab displays the available recipients for alerts.
Visit [Monitoring and Alerting](/content/admin/monitoring_alerting#recipients-concept) for more information
on configuration and usage.

* Click **+ Add Recipient** to start
  [creating a recipient](/content/admin/monitoring_alerting#create-recipient)
* For existing recipients:

  * Click **Test** to send a test alert to the recipient.
  * Click **Delete** to delete the recipient

<img alt="../images/recipients.png" />

<a />

## Channels

The **Channels** tab hosts configuration for delivery channels
currently supported by [KAgent](/content/admin/kagent/kagent). Visit
[Monitoring and Alerting](/content/admin/monitoring_alerting#delivery-channels-concept) for more information
on configuration and usage.

<img alt="../images/alerts_channels.png" />


# Dashboard
Source: https://docs.kinetica.com/content/admin/kagent/dashboard



The **Dashboard** page in *KAgent* hosts cluster and ring summary
information, which provides a quick way to gather the health of your
Kinetica environments.

<a />

<a />

## Rings

**Rings** is the default view for the **Dashboard** page.
The **Rings** view displays a list of the [rings](/content/ha)
added to this instance of *KAgent*. For each ring listed, the following
information is available: a list of clusters in the ring, a visual indicator of
the health of each node in each cluster, and a visual indicator of the health of
each rank in each cluster. If *etcd* and/or *RabbitMQ* are enabled on nodes
within the cluster, the status of those services is available as well as
some management controls.

* Click **Refresh** to refresh the list of rings
* For a given ring in the list, click **Details** to display the
  [Ring Summary](#ring-summary) view for that ring
* If a ring does not have any clusters currently, click
  **Add New Cluster** to begin the
  [cluster installation](/content/install/kagent_install) process.
* If *etcd* is present within the cluster, click **Modify** to update
  the *etcd* configuration file using the *KAgent* interface. If *RabbitMQ* is
  present within the ring, the [High Availability (HA)](/content/ha)
  configuration file will also be editable from the modify *etcd*
  configuration window.

<img alt="../images/dashboard_rings.png" />

<a />

## Ring Summary

The **Ring Summary** is accessed via the [Rings](#rings) view. The
**Ring Summary** displays the health of infrastructure services (e.g.,
*etcd*, *RabbitMQ* if [ring resiliency](/content/ha) is enabled, etc.),
the [Events Timeline](#events-timeline), and a list of clusters in the ring. For each cluster
listed, the following information is available: the name of the cluster, a
visual indicator of the health of each node and rank in the cluster, a list of
nodes (a detailed status is available upon cursor hover) in the cluster and
basic performance statistics & metrics. *Head nodes* are labeled with an `H`
to set them apart from worker nodes (`W`).

* Click one of the timeframe control buttons or select a date-time range to
  adjust the event timeline and the metric graphs to the selected duration
* Click **Refresh** to refresh the **Ring Summary** and
  **Events Timeline**
* Click **Back** to return to the [Rings](#rings) view
* Click **Collapse All** or **Expand All** to collapse or
  expand the cluster information cards in the list
* For a given cluster in the list, click **Details** to display the
  [Cluster Summary](#cluster-summary) view for that cluster
* Point the cursor to a graph to see the value at that time

<img alt="../images/dashboard_ring_summary.png" />

<a />

### Events Timeline

The **Events Timeline** displays events that have occurred within
the selected timeframe. A red cursor continuously moves through the timeline,
denoting seconds as they pass. Events will appear along the timeline in real
time.

<img alt="../images/dashboard_events_timeline.png" />

First, click the **Events Timeline**, then:

* Scroll to zoom in and out on the timeline
* Click and drag left and right to move the timeline backward and forward
  respectively
* Click an event dot to open detailed information, including the source of the
  event, the [event code](/content/admin/event_codes), the timestamp of the
  event, and more:

  <img alt="../images/dashboard_event_details.png" />

<a />

## Cluster Summary

The **Cluster Summary** is accessed via the [Ring Summary](#ring-summary) view. The
**Cluster Summary** displays similar information as the [Ring Summary](#ring-summary)
but with additional performance metrics and a list of nodes within the
cluster. For each node listed, the following information is available: the name
and IP address for the node, the services being hosted by the node, a visual
indicator of the health of each rank in the node, a list of ranks (a detailed
status is available upon cursor hover) in the cluster, and basic performance
statistics & metrics.

* Click one of the timeframe control buttons or select a date-time range to
  adjust the event timeline and the metric graphs to the selected duration
* Click **Refresh** to refresh the **Cluster Summary** and
  **Events Timeline**
* Click **Back** to return to the [Ring Summary](#ring-summary) view
* Click **Collapse All** or **Expand All** to collapse or
  expand the cluster and node information cards in the list
* Point the cursor to a graph to see the value at that time

<img alt="../images/dashboard_cluster_summary.png" />


# Events
Source: https://docs.kinetica.com/content/admin/kagent/events



The **Events** page in *KAgent* hosts a running log of all events
that have occurred. Events are configured via the [Alerts](/content/admin/kagent/alerts) page. Review
[Event Codes](/content/admin/event_codes) for a list of all available events.

<img alt="../images/events.png" />

## Actions

The available actions on the **Events** page are as follows:

* Refresh the list of events by clicking **Refresh**
* Update any of the **Advanced Filter** fields and click
  **Apply Filter** to filter the events list based on the
  provided values. Click **Clear** to remove the filter.
* Open a detailed view of an event or query by clicking **Detail** next
  to the desired event or query.


# KAgent
Source: https://docs.kinetica.com/content/admin/kagent/kagent



<a />

*KAgent* is a multi-faceted administration, installation, and configuration
management tool. It provides a centralized way to perform a consistent install
across an existing or yet-to-be-cloud-provisioned cluster of computers. *KAgent*
can also assist in automating tasks such as provisioning cloud hardware,
configuring cluster security, adding and removing nodes, data backup and
restoration, monitoring cluster health, managing and configuring cluster
[high availability](/content/ha/ha_architecture). It has both a graphical (web)
interface as well as a command line interface.

<a />

## Features

*KAgent* facilitates or directly performs the following operations:

* [Kinetica installation](/content/install/kagent_install)
* [Existing cluster addition](/content/admin/adding_cluster_kagent)
* [Cluster Back-ups](/content/admin/kagent/manage#kagent-ui-backups)
* [Cluster management](/content/admin/kagent/manage)
* [HA (Rings)](/content/admin/kagent/manage#kagent-ui-rings)
* Cluster [monitoring](/content/admin/monitoring_alerting) and
  [usage](/content/admin/kagent/usage)

## UI

The *KAgent* UI is usually available on port 8081
of the desired machine, so it can be accessed via `http://<kagent-host>:8081`.
The *KAgent* UI has a navigation pane on the left-hand side and a
**Notifications** pane on the right-hand side. Review
[Logging In / Out](/content/admin/kagent/kagent#kagent-ui-logout) for information on accessing the *KAgent* UI.

<img alt="../images/kagent_ui_dashboard_full.png" />

### Navigation

The navigation pane hosts quick access to all the features *KAgent* has to
offer. Available navigation menu options:

* [Dashboard](/content/admin/kagent/dashboard) -- Displays cluster health summary information. Not
  available until a new or existing cluster has been added to *KAgent*
* [Manage](/content/admin/kagent/manage) -- Hosts the
  *cluster management* and *cluster addition* / *cluster installation*
  interfaces.
* [Usage](/content/admin/kagent/usage) -- Displays cluster usage statistics. Not available until a
  new or existing cluster has been added to *KAgent*
* [Queries](/content/admin/kagent/queries) -- Displays a filterable log of all queries made against
  the given cluster
* [Events](/content/admin/kagent/events) -- Displays cluster events
* [Alerts](/content/admin/kagent/alerts) -- Displays cluster alerts
* **Logout** -- Logs out the current user. Not available until a new
  or existing cluster has been added to *KAgent*. Review
  [Logging In / Out](/content/admin/kagent/kagent#kagent-ui-logout) for more information

<a />

### Notifications

The **Notifications** pane lists notifications from metric or event
[Alerts](/content/admin/kagent/alerts). If there are no unread notifications, click
**See Past Notifications** to open the
[Alert History](/content/admin/kagent/alerts#alert-history) . Click **Mark All as Read** to
mark all unread notifications as read; click **Mark as Read** to mark
an individual unread notification as read.

<a />

### Logging In / Out

Once a cluster is added to *KAgent* (either via the installation or cluster
addition process), users must login to *KAgent* any time they need to use
any of its [features](/content/admin/kagent/kagent#kagent-features). Conversely, if no clusters are
in *KAgent*, there's no need to login, and thus, there's no way to log out (the
button won't be available) until a cluster is added. To log into *KAgent*:

1. Navigate to *KAgent* (`http://<kagent-host>:8081`)
2. Provide a username for the **Username** field. Only System Admin
   users have access to *KAgent*.
3. Provide a password for the **Password** field.
4. Select a cluster from the **Authentication Cluster** drop-down menu.
5. Click **Log In**.

   <Note>
     Authenticating against a particular cluster does not restrict
     users from accessing other clusters that have been added to
     this particular instance of *KAgent*.
   </Note>

After a successful login, the *KAgent* UI displays the **Dashboard**
page by default.

To log out of *KAgent*:

1. From the *KAgent* UI (`http://<kagent-host>:8081`), click
   **Logout** in the navigation pane.

## CLI

The *KAgent* CLI is available via the `kagent` executable typically stored in
`/opt/gpudb/kagent/bin/`.

The form of the command is as follows:

```bash theme={null}
kagent [-h] [--debug] [--quiet] [-f <path>] [--kagent-dir <path>]
   [-o <format>] [--user <username>] [-v]
   < ring | cluster | node | log | check | factory-reset | monitor | refresh-config | update >
```

<a />

### Options

<AccordionGroup>
  <Accordion title="< -h | --help >">
    Show the help menu.  When used following one of the subcommands, the subcommand-specific help menu will
    be shown.
  </Accordion>

  <Accordion title="--debug">
    Log debug messages.
  </Accordion>

  <Accordion title="--quiet">
    Suppress all output messages.
  </Accordion>

  <Accordion title="< -f | --dbfile > <path>">
    Path to KAgent cluster configuration database.
  </Accordion>

  <Accordion title="--kagent-dir <path>">
    Path to where KAgent and its playbooks reside.
  </Accordion>

  <Accordion title="< -o | --output > <format>">
    The output message format to use:

    * `human` - *(default)* output in human-readable form
    * `json` - output in JSON format
  </Accordion>

  <Accordion title="--user <username>">
    Specify what user is performing the actions, for logging purposes.
  </Accordion>

  <Accordion title="< -v | --verbose >">
    Run ansible-playbook with `-vvv` to debug issues.
  </Accordion>
</AccordionGroup>

### Subcommands

| Subcommand       | Description                                                                                                          |
| ---------------- | -------------------------------------------------------------------------------------------------------------------- |
| `ring`           | [Manage rings](/content/admin/kagent/kagent#kagent-cli-ring).                                                        |
| `cluster`        | [Manage clusters](/content/admin/kagent/kagent#kagent-cli-cluster).                                                  |
| `node`           | [Manage nodes](/content/admin/kagent/kagent#kagent-cli-node).                                                        |
| `log`            | [Manage logs](/content/admin/kagent/kagent#kagent-cli-log).                                                          |
| `check`          | [Check cluster connectivity](/content/admin/kagent/kagent#kagent-cli-check).                                         |
| `factory-reset`  | [Reset KAgent to its original state and uninstall Kinetica packages](/content/admin/kagent/kagent#kagent-cli-reset). |
| `monitor`        | [Set a monitor for checking cluster connectivity](/content/admin/kagent/kagent#kagent-cli-monitor).                  |
| `refresh-config` | [Force a refresh of the clusters from current status](/content/admin/kagent/kagent#kagent-cli-refresh).              |
| `update`         | [Update global KAgent settings](/content/admin/kagent/kagent#kagent-cli-update).                                     |

<a />

### Ring

The form of the command to manage rings is as follows:

```bash theme={null}
kagent ring <command>
```

<AccordionGroup>
  <Accordion title="add [options] <name>">
    Add a new ring with the given `name`.

    <div>
      <table>
        <thead>
          <tr>
            <th>Option</th>
            <th>Description</th>
          </tr>
        </thead>

        <tbody>
          <tr>
            <td><code>\< -a | --addr > \<addr></code></td>
            <td>Specify the load balancer address for the ring.</td>
          </tr>
        </tbody>
      </table>
    </div>
  </Accordion>

  <Accordion title="backup [options] <name>">
    Backup an existing ring with the given `name`.

    <div>
      <table>
        <thead>
          <tr>
            <th>Option</th>
            <th>Description</th>
          </tr>
        </thead>

        <tbody>
          <tr>
            <td><code>--backup-path \<path></code></td>
            <td>Specify the <code>path</code> in which the backup will be created.  Once given, will become the default backup path for subsequent backups.  Initial backup directory is <code>/opt/backups</code>.</td>
          </tr>
        </tbody>
      </table>
    </div>
  </Accordion>

  <Accordion title="control <name> <operation> <component>">
    Control the services of the ring with the given `name`.

    Apply one of the following operations:

    * `start`
    * `stop`
    * `restart`

    To one of the following components:

    * `gpudb`
    * `host_manager`
    * `tomcat`
    * `reveal`
    * `kml`
    * `stats`
    * `text_search`
    * `httpd`
    * `ha`
    * `mq`
    * `all_gpudb`
    * `all`
  </Accordion>

  <Accordion title="force-lock <name>">
    Force the ring with the given `name` to lock.
  </Accordion>

  <Accordion title="force-unlock <name>">
    Force the ring with the given `name` to unlock.
  </Accordion>

  <Accordion title="gather-logs [options] <name>">
    Download the logs from the ring with the given `name` to a destination on the *KAgent* host.

    <div>
      <table>
        <thead>
          <tr>
            <th>Option</th>
            <th>Description</th>
          </tr>
        </thead>

        <tbody>
          <tr>
            <td><code>--backtrace</code></td>
            <td>Add a process backtrace to the database process.</td>
          </tr>

          <tr>
            <td><code>--kagent-logs</code></td>
            <td>Add the *KAgent* logs to the archive, up to the point at which they are collected.</td>
          </tr>

          <tr>
            <td><code>--log-lines \<line\_count></code></td>
            <td>Specify the number of lines to collect from the log.  The first 100 lines are always saved.  Use <code>0</code> to collect the entire log or <code>ERROR</code> to collect only error log messages.  Default is <code>100,000</code> log lines.</td>
          </tr>

          <tr>
            <td><code>--output-dir \<path></code></td>
            <td>Specify the <code>path</code> where the log archive will be written. The directory must be writable by the **gpudb** user on the *KAgent* host.</td>
          </tr>

          <tr>
            <td><code>--package-verify</code></td>
            <td>Verify the installed *Kinetica* packages.</td>
          </tr>
        </tbody>
      </table>
    </div>
  </Accordion>

  <Accordion title="inspect <name>">
    Inspect the details of the ring with the given `name`.
  </Accordion>

  <Accordion title="install <name>">
    Install the HA platform on the ring with the given `name`.
  </Accordion>

  <Accordion title="list">
    List all managed rings.
  </Accordion>

  <Accordion title="rabbit-recovery [options] <name>">
    Attempt a RabbitMQ recovery; the process will clear all queues.

    <div>
      <table>
        <thead>
          <tr>
            <th>Option</th>
            <th>Description</th>
          </tr>
        </thead>

        <tbody>
          <tr>
            <td><code>--proceed \<yes|no></code></td>
            <td>Pass the final recovery confirmation (<code>yes</code> or <code>no</code>).</td>
          </tr>
        </tbody>
      </table>
    </div>
  </Accordion>

  <Accordion title="remove <name>">
    Remove the ring with the given `name`.
  </Accordion>

  <Accordion title="update [options] <name>">
    Update the details of the ring with the given `name`.

    <div>
      <table>
        <thead>
          <tr>
            <th>Option</th>
            <th>Description</th>
          </tr>
        </thead>

        <tbody>
          <tr>
            <td><code>--addr \<addr></code></td>
            <td>Specify the load balancer address for the ring.</td>
          </tr>

          <tr>
            <td><code>--ha-enabled \<yes|no></code></td>
            <td>Specify that HA has been enabled (<code>yes</code>) or not (<code>no</code>) for the ring.</td>
          </tr>
        </tbody>
      </table>
    </div>
  </Accordion>

  <Accordion title="upgrade [options] <name>">
    Upgrade Kinetica to the latest version on the ring with the given `name`.  This will perform a sequential
    in-place upgrade of each cluster within the ring.

    <div>
      <table>
        <thead>
          <tr>
            <th>Option</th>
            <th>Description</th>
          </tr>
        </thead>

        <tbody>
          <tr>
            <td><code>--offline-aaw-installer \<path></code></td>
            <td>Specify the file <code>path</code> or URL of the location for the *KML* installer package (rpm,deb).</td>
          </tr>

          <tr>
            <td><code>--offline-core-installer \<path></code></td>
            <td>Specify the file <code>path</code> or URL of the location for the *gpudb* installer package (rpm,deb).</td>
          </tr>

          <tr>
            <td><code>--offline-rabbit-installer \<path></code></td>
            <td>Specify the file <code>path</code> or URL of the location for the *gpudb HA* installer package (rpm,deb).</td>
          </tr>

          <tr>
            <td><code>--rabbit-drain-timeout \<timeout></code></td>
            <td>Specify the timeout in minutes that the upgrade will wait for queues to drain before beginning the upgrade. The upgrade will be aborted if the queues are not empty.  Default is <code>3</code>.</td>
          </tr>
        </tbody>
      </table>
    </div>
  </Accordion>
</AccordionGroup>

<a />

### Cluster

The form of the command to manage clusters is as follows:

```bash theme={null}
kagent cluster <command>
```

<AccordionGroup>
  <Accordion title="backup [options] <name>">
    Backup the data on the cluster with the given `name`.

    <div>
      <table>
        <thead>
          <tr>
            <th>Option</th>
            <th>Description</th>
          </tr>
        </thead>

        <tbody>
          <tr>
            <td><code>--backup-path \<path></code></td>
            <td>Specify the <code>path</code> in which the backup will be created.  Once given, will become the default backup path for subsequent backups.  Initial backup directory is <code>/opt/backups</code>.</td>
          </tr>

          <tr>
            <td><code>--list-schedule</code></td>
            <td>List backup schedules by backup <code>type</code>.</td>
          </tr>

          <tr>
            <td><code>--schedule \<schedule></code></td>
            <td>Specify the backup schedule.  Use <code>now</code> to run an immediate backup. Use a quoted crontab-style expression to schedule a backup in *cron*. Use <code>never</code> to remove a backup schedule.  Default is <code>now</code>.</td>
          </tr>

          <tr>
            <td><code>--table-list \<list></code></td>
            <td>Specify a space-separated list of tables to backup.</td>
          </tr>
        </tbody>
      </table>
    </div>
  </Accordion>

  <Accordion title="backup-configuration-files [options] <name>">
    Backup all configuration files on the cluster with the given `name`.

    <div>
      <table>
        <thead>
          <tr>
            <th>Option</th>
            <th>Description</th>
          </tr>
        </thead>

        <tbody>
          <tr>
            <td><code>--backup-path \<path></code></td>
            <td>Specify the <code>path</code> in which the backup will be created.  Once given, will become the default backup path for subsequent backups.  Initial backup directory is <code>/opt/backups</code>.  The directory must be writable by the **gpudb** user on the *KAgent* host.</td>
          </tr>
        </tbody>
      </table>
    </div>
  </Accordion>

  <Accordion title="backup-schedule <name>">
    List scheduled backups on the cluster with the given `name`.
  </Accordion>

  <Accordion title="bootstrap-kagent [options] <name>">
    Bootstrap the *KAgent* role to a different host in the cluster; further cluster management must happen
    through the *KAgent* on this different host.

    <div>
      <table>
        <thead>
          <tr>
            <th>Option</th>
            <th>Description</th>
          </tr>
        </thead>

        <tbody>
          <tr>
            <td><code>--kagent-hostname \<host></code></td>
            <td>Specify the name of the <code>host</code> where *KAgent* will be bootstrapped.</td>
          </tr>
        </tbody>
      </table>
    </div>
  </Accordion>

  <Accordion title="check-for-upgrades <name>">
    Check if upgrades are available on-line for the cluster with the given `name`.
  </Accordion>

  <Accordion title="clone [options]">
    Clone one cluster into another.

    <div>
      <table>
        <thead>
          <tr>
            <th>Option</th>
            <th>Description</th>
          </tr>
        </thead>

        <tbody>
          <tr>
            <td><code>--authentication \<yes|no></code></td>
            <td>Specify whether to copy (<code>yes</code>) or not copy (<code>no</code>) authentication settings.</td>
          </tr>

          <tr>
            <td><code>--data \<yes|no></code></td>
            <td>Specify whether to copy (<code>yes</code>) or not copy (<code>no</code>) data.</td>
          </tr>

          <tr>
            <td><code>--destination \<name></code></td>
            <td>Specify the <code>name</code> of the cluster to clone to.</td>
          </tr>

          <tr>
            <td><code>--graph \<yes|no></code></td>
            <td>Specify whether to copy (<code>yes</code>) or not copy (<code>no</code>) persisted graph information.</td>
          </tr>

          <tr>
            <td><code>--source \<name></code></td>
            <td>Specify the <code>name</code> of the cluster to clone from.</td>
          </tr>

          <tr>
            <td><code>--users \<yes|no></code></td>
            <td>Specify whether to copy (<code>yes</code>) or not copy (<code>no</code>) users and permissions.</td>
          </tr>
        </tbody>
      </table>
    </div>
  </Accordion>

  <Accordion title="control <name> <operation> <component>">
    Control the services of the cluster with the given `name`.

    Apply one of the following operations:

    * `start`
    * `stop`
    * `restart`

    To one of the following components:

    * `gpudb`
    * `host_manager`
    * `tomcat`
    * `reveal`
    * `kml`
    * `stats`
    * `text_search`
    * `httpd`
    * `ha`
    * `mq`
    * `all_gpudb`
    * `all`
  </Accordion>

  <Accordion title="gather-logs [options] <name>">
    Download the logs from the cluster with the given `name` to a destination on the *KAgent* host.

    <div>
      <table>
        <thead>
          <tr>
            <th>Option</th>
            <th>Description</th>
          </tr>
        </thead>

        <tbody>
          <tr>
            <td><code>--backtrace</code></td>
            <td>Add a process backtrace to the database process.</td>
          </tr>

          <tr>
            <td><code>--kagent-logs</code></td>
            <td>Add the *KAgent* logs to the archive, up to the point at which they are collected.</td>
          </tr>

          <tr>
            <td><code>--log-lines \<line\_count></code></td>
            <td>Specify the number of lines to collect from the log.  The first 100 lines are always saved.  Use <code>0</code> to collect the entire log or <code>ERROR</code> to collect only error log messages.  Default is <code>100,000</code> log lines.</td>
          </tr>

          <tr>
            <td><code>--output-dir \<path></code></td>
            <td>Specify the <code>path</code> where the log archive will be written.  The directory must be writable by the **gpudb** user on the *KAgent* host.</td>
          </tr>

          <tr>
            <td><code>--package-verify</code></td>
            <td>Verify the installed *Kinetica* packages.</td>
          </tr>
        </tbody>
      </table>
    </div>
  </Accordion>

  <Accordion title="get-conf-properties <name>">
    Show database configuration properties of the cluster with the given `name`.
  </Accordion>

  <Accordion title="get-logger [options] <name>">
    Show logger and logging level for the cluster with the given `name`.  To list the available loggers, run:

    ```bash theme={null}
    kagent cluster get-logger --ranks 0 <name>
    ```

    <div>
      <table>
        <thead>
          <tr>
            <th>Option</th>
            <th>Description</th>
          </tr>
        </thead>

        <tbody>
          <tr>
            <td><code>--logger \<name></code></td>
            <td>Specify the <code>name</code> of the logger to show.</td>
          </tr>

          <tr>
            <td><code>--ranks \<ranks></code></td>
            <td>Specify the number of the rank from which to retrieve logging config.</td>
          </tr>
        </tbody>
      </table>
    </div>
  </Accordion>

  <Accordion title="init [options] <name>">
    Initialize a new cluster with the given `name`.

    <div>
      <table>
        <tbody>
          <tr>
            <td>Option</td>
            <td>Description</td>
          </tr>

          <tr>
            <td><code>--ring \<name></code></td>
            <td>Specify the name of the ring in which to place this cluster.</td>
          </tr>

          <tr>
            <td><code>\< -k | --ssh-key > \<path></code></td>
            <td>Specify the <code>path</code> to the SSH private key to use for cluster operations.</td>
          </tr>

          <tr>
            <td><code>\< -u | --ssh-user > \<username></code></td>
            <td>Specify the SSH <code>username</code> to use for cluster operations. This overrides the <code>KAGENT\_SSH\_USER</code> environment variable.</td>
          </tr>

          <tr>
            <td><code>\< -p | --ssh-password ></code> <code>\<password></code></td>
            <td>Specify the SSH <code>password</code> to use for the SSH user. This overrides the <code>KAGENT\_SSH\_PASS</code> environment variable.</td>
          </tr>

          <tr>
            <td><code>\< -su | --sudo-user ></code> <code>\<username></code></td>
            <td>Specify the sudo <code>username</code> to use for cluster operations, in the case where root logins are not allowed.</td>
          </tr>

          <tr>
            <td><code>--sudo-password \<password></code></td>
            <td>Specify the sudo <code>password</code> to use for the sudo user. This overrides the <code>KAGENT\_SUDO\_PASSWORD</code> environment variable.</td>
          </tr>

          <tr>
            <td><code>\< -admpass | --admin-pass ></code> <code>\<password></code></td>
            <td>Specify the *Kinetica* admin user <code>password</code>.</td>
          </tr>

          <tr>
            <td><code>--connect-via \<method></code></td>
            <td>Specify whether to connect to each node's internal IP address (<code>ip\_addr</code>) or public IP address (<code>public\_ip\_addr</code>).</td>
          </tr>

          <tr>
            <td><code>\< -inf |</code> <code>--infrastructure-provider ></code> <code>\<provider\_code></code></td>
            <td>Specify the cluster's infrastructure provider: <ul><li><code>onprem</code> - On-premise (bare-metal) installation, or a cloud-based installation not provisioned via *KAgent*</li></ul></td>
          </tr>

          <tr>
            <td><code>\< -lic | --lic-key > \<key></code></td>
            <td>Specify the license <code>key</code> to use for this cluster.</td>
          </tr>

          <tr>
            <td><code>--aws-access-key \<key></code></td>
            <td>Specify the *AWS* access key to use for cluster provisioning and operations. This overrides the <code>KAGENT\_AWS\_ACCESS\_KEY</code> environment variable.</td>
          </tr>

          <tr>
            <td><code>--aws-secret-key \<key></code></td>
            <td>Specify the *AWS* secret key to use for cluster provisioning and operations. This overrides the <code>KAGENT\_AWS\_SECRET\_KEY</code> environment variable.</td>
          </tr>

          <tr>
            <td><code>--aws-ssh-key-name \<name></code></td>
            <td>Specify the <code>name</code> of the SSH key to use to log into cluster nodes.  If none is provided, a key will be created.</td>
          </tr>

          <tr>
            <td><code>--azure-client-id \<id></code></td>
            <td>Specify the client <code>id</code> from the *Azure* login profile, usually found in <Badge>/.azure/credentials</Badge>. This overrides the <code>KAGENT\_AZURE\_CLIENT\_ID</code> environment variable.</td>
          </tr>

          <tr>
            <td><code>--azure-secret \<secret></code></td>
            <td>Specify the <code>secret</code> from the *Azure* login profile, usually found in <Badge>/.azure/credentials</Badge>. This overrides the <code>KAGENT\_AZURE\_SECRET</code> environment variable.</td>
          </tr>

          <tr>
            <td><code>--azure-subscription-id \<id></code></td>
            <td>Specify the subscription <code>id</code> from the *Azure* login profile, usually found in <Badge>/.azure/credentials</Badge>. This overrides the <code>KAGENT\_AZURE\_SUBSCRIPTION\_ID</code> environment variable.</td>
          </tr>

          <tr>
            <td><code>--azure-tenant \<tenant></code></td>
            <td>Specify the <code>tenant</code> from the *Azure* login profile, usually found in <Badge>/.azure/credentials</Badge>. This overrides the <code>KAGENT\_AZURE\_TENANT</code> environment variable.</td>
          </tr>

          <tr>
            <td><code>--cloud-region \<region></code></td>
            <td>Specify the *AWS* region, *Azure* location, or *GCP* zone for the cluster.</td>
          </tr>

          <tr>
            <td><code>--cloud-ssh-user \<username></code></td>
            <td>Specify the <code>username</code> to create a login for on *Azure* or *GCP* provisioned instances.</td>
          </tr>

          <tr>
            <td><code>--cloud-ssh-public-key-file \<path></code></td>
            <td>Specify the <code>path</code> to the public key to use for authentication on *Azure* or *GCP* instances.</td>
          </tr>

          <tr>
            <td><code>--gcp-project \<project></code></td>
            <td>Specify the *GCP* <code>project</code> with which this cluster should be associated.</td>
          </tr>

          <tr>
            <td><code>--gcp-service-account-file \<path></code></td>
            <td>Specify the *GCP* service account file (JSON) for the user.</td>
          </tr>
        </tbody>
      </table>
    </div>
  </Accordion>

  <Accordion title="inspect <name>">
    Inspect the details of the cluster with the given `name`.
  </Accordion>

  <Accordion title="install [options] <name>">
    Install *Kinetica* on a new cluster.  **Note:**  specifying any offline installer will switch the install to
    offline mode.

    <div>
      <table>
        <thead>
          <tr>
            <th>Option</th>
            <th>Description</th>
          </tr>
        </thead>

        <tbody>
          <tr>
            <td><code>--auto-config \<yes|no></code></td>
            <td>Whether to update (<code>yes</code>) or not update (<code>no</code>) the configuration on the cluster during install.  Default is to update the configuration.</td>
          </tr>

          <tr>
            <td><code>\< -c | --cuda > \<yes|no></code></td>
            <td>Whether to use a CUDA (GPU) build (<code>yes</code>) or Intel (CPU) build (<code>no</code>).</td>
          </tr>

          <tr>
            <td><code>--k8s-config-file \<path></code></td>
            <td>Specify the path to the kubeconfig file of the external K8s cluster which KML will use.</td>
          </tr>

          <tr>
            <td><code>--k8s-public-ip \<addr></code></td>
            <td>Specify the IP address at which the K8s cluster is accessible by the *Kinetica* cluster.</td>
          </tr>

          <tr>
            <td><code>\< -nv | --nvidia > \<yes|no></code></td>
            <td>Whether to install (<code>yes</code>) or not install (<code>no</code>) the Nvidia driver when none is detected.</td>
          </tr>

          <tr>
            <td><code>--open-firewall-ports \<yes|no></code></td>
            <td>Whether to open (<code>yes</code>) or not open (<code>no</code>) relevant firewall ports if an enabled firewall is detected.</td>
          </tr>

          <tr>
            <td><code>--offline-aaw-installer \<path></code></td>
            <td>Specify the file <code>path</code> or URL of the location for the *KML* installer package (rpm,deb).</td>
          </tr>

          <tr>
            <td><code>--offline-core-installer \<path></code></td>
            <td>Specify the file <code>path</code> or URL of the location for the *gpudb* installer package (rpm,deb).</td>
          </tr>

          <tr>
            <td><code>--offline-kagent-installer \<path></code></td>
            <td>Specify the file <code>path</code> or URL of the location for the *KAgent* installer package (rpm,deb).</td>
          </tr>

          <tr>
            <td><code>--offline-nvidia-installer \<path></code></td>
            <td>Specify the file <code>path</code> or URL of the location for the *Nvidia* installer package (rpm,deb).</td>
          </tr>

          <tr>
            <td><code>--offline-rabbit-installer \<path></code></td>
            <td>Specify the file <code>path</code> or URL of the location for the *gpudb HA* installer package (rpm,deb).</td>
          </tr>

          <tr>
            <td><code>--reserve-k8s-gpus \<number></code></td>
            <td>Specify the <code>number</code> of GPUs to reserve for K8s/UDF usage.</td>
          </tr>
        </tbody>
      </table>
    </div>
  </Accordion>

  <Accordion title="list">
    List all managed clusters.
  </Accordion>

  <Accordion title="list-backup-contents [options] <name>">
    List the contents of a backup on the cluster with the given `name`.

    <div>
      <table>
        <thead>
          <tr>
            <th>Option</th>
            <th>Description</th>
          </tr>
        </thead>

        <tbody>
          <tr>
            <td><code>--backup-path \<path></code></td>
            <td>Specify the <code>path</code> to the backup directory.</td>
          </tr>

          <tr>
            <td><code>--restore-from \<path></code></td>
            <td>Specify the backup whose contents will be listed; this will be the name of a backup directory under the path given in <code>--backup-path</code>.</td>
          </tr>
        </tbody>
      </table>
    </div>
  </Accordion>

  <Accordion title="list-backups [options] <name>">
    List the available backups on the cluster with the given `name`.

    <div>
      <table>
        <thead>
          <tr>
            <th>Option</th>
            <th>Description</th>
          </tr>
        </thead>

        <tbody>
          <tr>
            <td><code>--backup-path \<path></code></td>
            <td>Specify the <code>path</code> to the backup directory.</td>
          </tr>
        </tbody>
      </table>
    </div>
  </Accordion>

  <Accordion title="list-cluster-contents <name>">
    List all of the tables on the cluster with the given `name`.
  </Accordion>

  <Accordion title="preflight <name>">
    Detect/regenerate environment settings for running *KAgent* commands on the cluster with the given `name`.
  </Accordion>

  <Accordion title="remove <name>">
    Remove the cluster with the given `name`.
  </Accordion>

  <Accordion title="restore [options] <name>">
    Restore the contents of a backup to the cluster with the given `name`.

    <div>
      <table>
        <thead>
          <tr>
            <th>Option</th>
            <th>Description</th>
          </tr>
        </thead>

        <tbody>
          <tr>
            <td><code>--backup-path \<path></code></td>
            <td>Specify the <code>path</code> to the backup directory.</td>
          </tr>

          <tr>
            <td><code>--preserve-persist \<yes|no></code></td>
            <td>Whether to move (<code>yes</code>) or not move (<code>no</code>) the existing database persist folder to a safe location before overwriting. Default is <code>no</code>.</td>
          </tr>

          <tr>
            <td><code>--restore-from \<path></code></td>
            <td>Specify the backup to restore; this will be the name of a backup directory under the path given in <code>--backup-path</code>.</td>
          </tr>

          <tr>
            <td><code>--table-list \<list></code></td>
            <td>Specify a space-delimited set of tables to restore from the backup.</td>
          </tr>
        </tbody>
      </table>
    </div>
  </Accordion>

  <Accordion title="secure [options] <name>">
    Secure the cluster with the given `name` by enabling HTTPS and/or authentication via *LDAP*, *Active*
    *Directory*, *Kerberos*, or *OAuth2*.  **Note:** All parameters relevant to the desired authentication
    mechanism must be specified upon each invocation of this command--no existing settings will be used as
    defaults.

    <div>
      <table>
        <thead>
          <tr>
            <th>Option</th>
            <th>Description</th>
          </tr>
        </thead>

        <tbody>
          <tr>
            <td><code>--ssl \<yes|no></code></td>
            <td>Whether to enforce (<code>yes</code>) or not enforce (<code>no</code>) SSL connections to the cluster via https.</td>
          </tr>

          <tr>
            <td><code>--generate-certs \<yes|no></code></td>
            <td>Whether to generate (<code>yes</code>) or not generate (<code>no</code>) self-signed certificates.  Certificates can also be assigned directly to each node with the [kagent node](/content/admin/kagent/kagent#kagent-cli-node) command.</td>
          </tr>

          <tr>
            <td><code>--authentication \<type></code></td>
            <td>Specify the <code>type</code> of authentication to use: <ul><li><code>none</code></li><li><code>ad</code></li><li><code>kerberos</code></li><li><code>ldap</code></li><li><code>oauth2</code></li></ul></td>
          </tr>

          <tr>
            <td><code>--connection-type \<type></code></td>
            <td>When using *LDAP*, the <code>type</code> to use (<code>ldap</code> | <code>ldaps</code>).</td>
          </tr>

          <tr>
            <td><code>--ldaps-cert \<path></code></td>
            <td>When using *LDAPS* and a certificate is necessary, the <code>path</code> of the *LDAP* certificate.</td>
          </tr>

          <tr>
            <td><code>--ldap-host \<name></code></td>
            <td>When using *LDAP*, the <code>name</code> of the *LDAP* bind host.</td>
          </tr>

          <tr>
            <td><code>--ldap-port \<port></code></td>
            <td>When using *LDAP*, the <code>port</code> to bind to.</td>
          </tr>

          <tr>
            <td><code>--ldap-base-filter \<filter></code></td>
            <td>When using *LDAP*, the <code>filter</code> to use when searching the directory for logins.</td>
          </tr>

          <tr>
            <td><code>--ldap-bind-user \<username></code></td>
            <td>When using *LDAP*, the <code>username</code> of the account to use when connecting to the directory.</td>
          </tr>

          <tr>
            <td><code>--ldap-bind-pwd \<password></code></td>
            <td>When using *LDAP*, the <code>password</code> of the account to use when connecting to the directory. This overrides the <code>KAGENT\_LDAP\_BIND\_PWD</code> environment variable.</td>
          </tr>

          <tr>
            <td><code>--kerberos-realm \<realm></code></td>
            <td>When using *Kerberos*, the <code>realm</code> to authenticate against.  For example: <code>MY-REALM.ACME.COM</code>.</td>
          </tr>

          <tr>
            <td><code>--kerberos-service-name \<name></code></td>
            <td>When using *Kerberos*, specify the *Kerberos* service location.  For example: <code>HTTP/kerb-server.acme.com</code>.</td>
          </tr>

          <tr>
            <td><code>--kerberos-keytab \<path></code></td>
            <td>When using *Kerberos*, specify the <code>path</code> to the keytab file to use.</td>
          </tr>

          <tr>
            <td><code>--external-auth-role-maps-file</code> <code>\<path></code></td>
            <td>When using *LDAP* or *AD*, the path to the JSON file containing the role maps used to limit authorization, mapping certain groups to *Kinetica* roles.  The mapping file should have the following format: .. code-block:: json \{ "role1": \["cn=g1,dc=abc,dc=com"], "role2": \[ "cn=g1,dc=abc,dc=com", "cn=g2,dc=abc,dc=com" ] }</td>
          </tr>

          <tr>
            <td><code>--ui-auth-type \<type></code></td>
            <td>The type of authentication to use when logging in to the UIs: <ul><li><code>none</code></li><li><code>openid-connect</code> - use with <code>--authentication oauth2</code> setups</li></ul></td>
          </tr>

          <tr>
            <td><code>--oauth-metadata-url \<url></code></td>
            <td>When using *OAuth*, the <code>url</code> that identifies the *OAuth* server settings.</td>
          </tr>

          <tr>
            <td><code>--oauth-user-claim \<claim></code></td>
            <td>When using *OAuth*, the name of the <code>claim</code> on the *OAuth* token representing the user's username in *Kinetica*.</td>
          </tr>

          <tr>
            <td><code>--oauth-cliend-id \<id></code></td>
            <td>When using *OAuth*, the <code>id</code> of the client used to connect to the *OAuth* server.</td>
          </tr>

          <tr>
            <td><code>--oauth-client-secret \<secret></code></td>
            <td>When using *OAuth*, the <code>secret</code> of the client used to connect to the *OAuth* server.</td>
          </tr>

          <tr>
            <td><code>--oauth-db-roles-claim \<claim></code></td>
            <td>When using *OAuth*, the name of the <code>claim</code> on the *OAuth* token that contains a comma-separated list of database roles that the user should be assigned.</td>
          </tr>

          <tr>
            <td><code>--oauth-reveal-roles-claim</code> <code>\<claim></code></td>
            <td>When using *OAuth*, the name of the <code>claim</code> on the *OAuth* token that contains a comma-separated list of *Reveal* roles that the user should be assigned.</td>
          </tr>

          <tr>
            <td><code>--oauth-gadmin-redirect-uri</code> <code>\<uri></code></td>
            <td>When using *OAuth*, the <code>url</code> that can be used as a return redirect for *GAdmin* from the *OAuth* server, necessary when the hostname or port the user is using to access *GAdmin* is different than those found on the standard public-facing URL.</td>
          </tr>

          <tr>
            <td><code>--oauth-reveal-redirect-uri</code> <code>\<uri></code></td>
            <td>When using *OAuth*, the <code>url</code> that can be used as a return redirect for *Reveal* from the *OAuth* server, necessary when the hostname or port the user is using to access *Reveal* is different than those found on the standard public-facing URL.</td>
          </tr>

          <tr>
            <td><code>--oauth-workbench-redirect-uri</code> <code>\<uri></code></td>
            <td>When using *OAuth*, the <code>url</code> that can be used as a return redirect for *Workbench* from the *OAuth* server, necessary when the hostname or port the user is using to access *Workbench* is different than those found on the standard public-facing URL.</td>
          </tr>

          <tr>
            <td><code>--offline-httpd-oauth-installer</code> <code>\<path></code></td>
            <td>When using *OAuth*, the <code>path</code> of the file or URL for the add-on *OAuth* <code>httpd</code> module installer package (rpm, deb).</td>
          </tr>
        </tbody>
      </table>
    </div>
  </Accordion>

  <Accordion title="set-conf-properties [options] <name>">
    Set database configuration properties for the cluster with the given `name`.

    <div>
      <table>
        <thead>
          <tr>
            <th>Option</th>
            <th>Description</th>
          </tr>
        </thead>

        <tbody>
          <tr>
            <td><code>--properties-map \<map></code></td>
            <td>Specify a <code>map</code> of key-value pairs of database configuration parameters to set.  For example: .. code-block:: json \{"np1.load\_vectors\_on\_migration":"always"}</td>
          </tr>
        </tbody>
      </table>
    </div>
  </Accordion>

  <Accordion title="set-logger [options] <name>">
    Set logger and logging level for the cluster with the given `name`.

    <div>
      <table>
        <thead>
          <tr>
            <th>Option</th>
            <th>Description</th>
          </tr>
        </thead>

        <tbody>
          <tr>
            <td><code>--level \<level></code></td>
            <td>Specify the <code>level</code> of logging for the selected logger(s).  One of: <ul><li><code>TRACE</code></li><li><code>DEBUG</code></li><li><code>INFO</code></li><li><code>WARN</code></li><li><code>ERROR</code></li><li><code>FATAL</code></li><li><code>OFF</code></li></ul></td>
          </tr>

          <tr>
            <td><code>--logger \<name></code></td>
            <td>Specify the <code>name</code> of the logger to modify.</td>
          </tr>

          <tr>
            <td><code>--ranks \<ranks></code></td>
            <td>Specify the number of the rank to where the logging modification will be applied.  A comma-separated list of rank numbers can be used to specify multiple ranks to modify; e.g., <code>0,3,4</code>.  Use <code>-1</code> to apply the modification across the cluster.</td>
          </tr>
        </tbody>
      </table>
    </div>
  </Accordion>

  <Accordion title="uninstall <name>">
    Remove the cluster with the given `name`, including all components except this instance of *KAgent*.
  </Accordion>

  <Accordion title="update [options] <name>">
    Modify select parameters of the cluster with the given `name`.

    <div>
      <table>
        <thead>
          <tr>
            <th>Option</th>
            <th>Description</th>
          </tr>
        </thead>

        <tbody>
          <tr>
            <td><code>--connect-via \<method></code></td>
            <td>Specify whether to connect to each node's internal IP address (<code>ip\_addr</code>) or public IP address (<code>public\_ip\_addr</code>).</td>
          </tr>

          <tr>
            <td><code>--is-installed \<yes|no></code></td>
            <td>Whether to mark (<code>yes</code>) or not mark (<code>no</code>) this cluster as installed.</td>
          </tr>

          <tr>
            <td><code>--move-to-ring \<name></code></td>
            <td>Specify the <code>name</code> of an existing ring to move this cluster into.</td>
          </tr>
        </tbody>
      </table>
    </div>
  </Accordion>

  <Accordion title="verify [options] <name>">
    Verify connectivity and basic configuration of the cluster with the given `name`.

    <div>
      <table>
        <thead>
          <tr>
            <th>Option</th>
            <th>Description</th>
          </tr>
        </thead>

        <tbody>
          <tr>
            <td><code>--include-dependency</code></td>
            <td>Include info from related cluster services like *RabbitMQ*.</td>
          </tr>

          <tr>
            <td><code>--status-only</code></td>
            <td>Only gather the service status on the nodes.</td>
          </tr>
        </tbody>
      </table>
    </div>
  </Accordion>

  <Accordion title="write-inventory [options] <name>">
    Write out an inventory file for the cluster with the given `name`.

    <div>
      <table>
        <thead>
          <tr>
            <th>Option</th>
            <th>Description</th>
          </tr>
        </thead>

        <tbody>
          <tr>
            <td><code>\< -i | --inventory-dir > \<path></code></td>
            <td>The <code>path</code> to write the inventory file to.  Default is <code>./ansible-inventory-\<cluster\_name></code>.</td>
          </tr>

          <tr>
            <td><code>--vault-password \<password></code></td>
            <td>Specify the password to use for the Ansible vault. This overrides the <code>KAGENT\_VAULT\_PASSWORD</code> environment variable.</td>
          </tr>
        </tbody>
      </table>
    </div>
  </Accordion>
</AccordionGroup>

<a />

### Node

The form of the command to manage nodes is as follows:

```bash theme={null}
kagent node <command>
```

<AccordionGroup>
  <Accordion title="discover-hostname [options] <name>">
    Attempt to auto-discover (and update) the hostname of the node with the given `name`.
  </Accordion>

  <Accordion title="gather-logs [options] <name>">
    Download the logs from the node with the given `name` to a destination on the *KAgent* host.

    <div>
      <table>
        <thead>
          <tr>
            <th>Option</th>
            <th>Description</th>
          </tr>
        </thead>

        <tbody>
          <tr>
            <td><code>--backtrace</code></td>
            <td>Add a process backtrace to the database process.</td>
          </tr>

          <tr>
            <td><code>--kagent-logs</code></td>
            <td>Add the *KAgent* logs to the archive, up to the point at which they are collected.</td>
          </tr>

          <tr>
            <td><code>--log-lines \<line\_count></code></td>
            <td>Specify the number of lines to collect from the log.  The first 100 lines are always saved.  Use <code>0</code> to collect the entire log or <code>ERROR</code> to collect only error log messages.  Default is <code>100,000</code> log lines.</td>
          </tr>

          <tr>
            <td><code>--output-dir \<path></code></td>
            <td>Specify the <code>path</code> where the log archive will be written.  The directory must be writable by the **gpudb** user on the *KAgent* host.</td>
          </tr>

          <tr>
            <td><code>--package-verify</code></td>
            <td>Verify the installed *Kinetica* packages.</td>
          </tr>
        </tbody>
      </table>
    </div>
  </Accordion>

  <Accordion title="init [options] <name> <addr> <cluster>">
    Initialize a new node with the given `name` and IP `addr` on the given `cluster`.  The `name` must
    be unique across all nodes in the cluster.

    <div>
      <table>
        <thead>
          <tr>
            <th>Option</th>
            <th>Description</th>
          </tr>
        </thead>

        <tbody>
          <tr>
            <td><code>--cloud-instance-name \<name></code></td>
            <td>Specify an optional <code>name</code> for the node.</td>
          </tr>

          <tr>
            <td><code>--cloud-instance-type \<type></code></td>
            <td>Specify the <code>type</code> of the node, based on the cloud provider.</td>
          </tr>

          <tr>
            <td><code>--data-size \<size></code></td>
            <td>Specify the <code>size</code> of the storage to allocate for the node in GB.</td>
          </tr>

          <tr>
            <td><code>--gcp-gpu-card \<card></code></td>
            <td>Specify the GPU <code>card</code> to attach to the node (if available and using *GCP* as the provider).</td>
          </tr>

          <tr>
            <td><code>--public-ip-addr \<addr></code></td>
            <td>Specify the IP <code>addr</code> of the node accessible outside the DMZ, if applicable.</td>
          </tr>

          <tr>
            <td><code>--public-hostname \<hostname></code></td>
            <td>Specify the <code>hostname</code> of the node accessible outside the DMZ, if applicable.</td>
          </tr>

          <tr>
            <td><code>--roles \<list></code></td>
            <td>Specify a comma-separated <code>list</code> of roles for the node. <div><table>  <thead>  <tr>    <th>Role</th>    <th>Description</th>  </tr>  </thead>  <tbody>  <tr>    <td><code>head</code></td>    <td>Head node for the cluster</td>  </tr>  <tr>    <td><code>worker</code></td>    <td>One of the worker nodes in the cluster</td>  </tr>  <tr>    <td><code>graph</code></td>    <td>[Graph](/content/graph_solver/network_graph_solver) node</td>  </tr>  <tr>    <td><code>kml</code></td>    <td>[KML](/content/ml/concepts) node</td>  </tr>  <tr>    <td><code>ha\_queue</code></td>    <td>*RabbitMQ* node for [ring resiliency](/content/ha)</td>  </tr>  <tr>    <td><code>kagent</code></td>    <td>Bootstrapped in-cluster *KAgent* for cluster/ring management</td>  </tr>  </tbody></table></div></td>
          </tr>

          <tr>
            <td><code>--ssh-port \<port></code></td>
            <td>Specify the <code>port</code> to use for SSH connections to the node.</td>
          </tr>

          <tr>
            <td><code>--ssl-cert \<path></code></td>
            <td>Specify the <code>path</code> to the SSL certificate for the node.</td>
          </tr>

          <tr>
            <td><code>--ssl-key \<path></code></td>
            <td>Specify the <code>path</code> to the SSL key for the node.</td>
          </tr>
        </tbody>
      </table>
    </div>
  </Accordion>

  <Accordion title="inspect <name>">
    Inspect the details of the node with the given `name`.
  </Accordion>

  <Accordion title="list">
    List all managed nodes.
  </Accordion>

  <Accordion title="remove [options] <name>">
    Remove the node with the given `name`.

    <div>
      <table>
        <thead>
          <tr>
            <th>Option</th>
            <th>Description</th>
          </tr>
        </thead>

        <tbody>
          <tr>
            <td><code>\< -f | --force ></code></td>
            <td>Always remove the node, even if some aspect of the removal fails.</td>
          </tr>
        </tbody>
      </table>
    </div>
  </Accordion>

  <Accordion title="update [options] <name>">
    Modify select parameters of the node with the given `name`.

    <div>
      <table>
        <thead>
          <tr>
            <th>Option</th>
            <th>Description</th>
          </tr>
        </thead>

        <tbody>
          <tr>
            <td><code>--public-hostname \<hostname></code></td>
            <td>Specify the <code>hostname</code> of the node accessible outside the DMZ, if applicable.</td>
          </tr>

          <tr>
            <td><code>--ssl-cert \<path></code></td>
            <td>Specify the <code>path</code> to the SSL certificate for the node.</td>
          </tr>

          <tr>
            <td><code>--ssl-key \<path></code></td>
            <td>Specify the <code>path</code> to the SSL key for the node.</td>
          </tr>
        </tbody>
      </table>
    </div>
  </Accordion>
</AccordionGroup>

<a />

### Log

The form of the command to manage *KAgent* logs is as follows:

```bash theme={null}
kagent log <command>
```

<AccordionGroup>
  <Accordion title="list [options]">
    Show a list of *KAgent* log events.

    <div>
      <table>
        <thead>
          <tr>
            <th>Option</th>
            <th>Description</th>
          </tr>
        </thead>

        <tbody>
          <tr>
            <td><code>\< -n | --number > \<number></code></td>
            <td>Specify the maximum <code>number</code> of log events to show.</td>
          </tr>
        </tbody>
      </table>
    </div>
  </Accordion>
</AccordionGroup>

<a />

### Check

This command is used to ensure that all the nodes of a cluster are up by
checking for connectivity and then interjecting *spare* nodes, if available, to
fill in any gaps.

The form of the command to perform this check is as follows:

```bash theme={null}
kagent check [options]
```

<AccordionGroup>
  <Accordion title="--retry-count <number>">
    Specify the `number` of connectivity check retries before failing over nodes.
  </Accordion>

  <Accordion title="--retry-delay <seconds>">
    Specify the `seconds` to wait between each connectivity check retry.
  </Accordion>
</AccordionGroup>

<a />

### Factory Reset

This command uninstalls all *Kinetica* packages and resets *KAgent*
configurations to an out-of-the-box condition.  No directories will be removed
unless requested.

The form of the command to perform a factory reset is as follows:

```bash theme={null}
kagent factory-reset [options]
```

<AccordionGroup>
  <Accordion title="--clear-data <yes|no>">
    Whether to remove (`yes`) or not remove (`no`) directories left by the installation.  Default is to
    not remove directories.
  </Accordion>

  <Accordion title="--proceed <yes|no>">
    Whether to automatically proceed (`yes`) or ask for confirmation (`no`) before performing a reset.
  </Accordion>
</AccordionGroup>

<a />

### Monitor

This command sets a monitor for checking cluster connectivity.

The form of the command is as follows:

```bash theme={null}
kagent monitor [options]
```

<AccordionGroup>
  <Accordion title="--interval <schedule>">
    Specify how often the check command will be run, in crontab format.  Default is `*/5 * * * *`.
  </Accordion>

  <Accordion title="--retry-count <number>">
    Specify the `number` of check retries before failing over a node.
  </Accordion>

  <Accordion title="--retry-delay <seconds>">
    Specify the `seconds` to wait between each check retry.
  </Accordion>
</AccordionGroup>

<a />

### Refresh Config

This command forces a refresh of the cluster configuration and roles, given its current status.

The form of the command is as follows:

```bash theme={null}
kagent refresh-config
```

<a />

### Update

This command updates global *KAgent* settings.

The form of the command is as follows:

```bash theme={null}
kagent update [options]
```

<AccordionGroup>
  <Accordion title="--is-bootstrapped <yes|no>">
    Whether to mark this *KAgent* as bootstrapped (`yes`) or not (`no`).  A bootstrapped
    *KAgent* is one that is deployed into a cloud-provisioned cluster during installation.  This
    marking will determine which set of IPs this *KAgent* will use in connecting via SSH to the
    cluster nodes.
  </Accordion>

  <Accordion title="--force-bootstrap-unlock <yes|no>">
    Whether to remove (`yes`) or not remove (`no`) the lock placed on this *KAgent* if it had
    been used to bootstrap an in-cluster *KAgent*.
  </Accordion>
</AccordionGroup>


# Manage
Source: https://docs.kinetica.com/content/admin/kagent/manage



<a />

The **Manage** page allows users to install new clusters, add existing
clusters, review *KAgent* logs and jobs, manage cluster
[high availability](/content/ha/ha_architecture) rings, and more. The
**Manage** page has two main views depending on whether there is a
cluster in *KAgent* or not. If no clusters have been added to *KAgent* yet,
the **Welcome** page will appear by default allowing you to quickly
jump into [adding a cluster](/content/admin/kagent/manage#manage-add-cluster). If there are clusters in
*KAgent*, the [Clusters](#clusters) page will appear by default.

* Click **Rings** to view *KAgent* rings
* Click **Jobs** to view *KAgent* [jobs](/content/admin/kagent/manage#kagent-ui-jobs).
* Click **Logs** to view *KAgent* [logs](/content/admin/kagent/manage#kagent-ui-logs).
* Click **Console**  to open the *KAgent*
  [console log](/content/admin/kagent/manage#kagent-ui-console).

<a />

## Add Cluster

The **Add Cluster** interface allows users to install a new
cluster or add an existing cluster; this page will only appear if this instance
of *KAgent* is not currently managing any *Kinetica* clusters. For full details
on installing a cluster using *KAgent*, visit
[Kinetica Installation with KAgent](/content/install/kagent_install). For more information about adding an
existing cluster, see [Adding a Cluster to KAgent](/content/admin/adding_cluster_kagent).

<img alt="../images/add_cluster_ui.png" />

<a />

## Clusters

The **Clusters** page is the home page for the *KAgent* management UI
and displays all existing clusters. This page is only accessible if a cluster
has been previously added to or installed with *KAgent*.

* Click **+ Cluster** to begin adding a cluster. See
  [Add Cluster](/content/admin/kagent/manage#manage-add-cluster) for more information.
* Click **Clone** to begin cloning an existing cluster. See
  [Clone](/content/admin/kagent/manage#kagent-ui-clone) for more information.
* Click **Refresh** to refresh the cluster list.
* Click the <img alt="headnode" /> icon in the **Nodes** column to open a browser
  tab to the head node's *Admin Application*
  ([GAdmin](/content/admin/gadmin) -- `http://<host>:8080`)
* Click **Apps** to open a small menu containing links to the
  Kinetica-related applications available on this cluster; e.g., *GAdmin* or
  [Reveal](/content/bi/reveal)
* Click **Manage** next to a cluster to open the
  [management](/content/admin/kagent/manage#kagent-manage) options for the cluster.
* Click **Logging** to open a window where you can enable additional
  SQL Analyzer logging for the cluster.
* Click **Logs** to open the **Gather Logs** modal, which will
  assist in *KAgent* log gathering, *KAgent* package verification, and a
  process backtracing for the `gpudb` service of the selected cluster. Select
  the desired options and click **Gather Logs** to initiate the process;
  a download link will be presented once processing is complete.
* Click **X** to remove the cluster from *KAgent*. This will
  **not** uninstall *Kinetica* or any other services.

<img alt="../../images/kagent_clusters.png" />

<a />

### Clone

**Clone** provides the ability to clone a cluster's authentication
settings, users, and/or data to another cluster. To clone a cluster:

1. From the **Clusters** page, click **Clone**.

2. Select a **Source Cluster** from the drop-down menu.

3. Select a **Target Cluster** from the drop-down menu.

4. Select the **Clone Options**:

   * **Authentication**: the source cluster's authentication settings
     (LDAP, Kerberos, etc.) will be cloned to the target cluster
   * **Users**: the source cluster's users and permissions setup will
     be cloned to the target cluster
   * **Data**: the source cluster's data will be cloned to the target
     cluster
   * **Graph**: the source cluster's persisted
     [graphs](/content/graph_solver) will be cloned to the target cluster

5. Click **Clone**.

   <Note>
     Cloning a cluster should be performed during downtime as
     cloning a cluster while modifying any of the related data
     can lead to inconsistencies between the two clusters.
   </Note>

<img alt="../images/kagent_manage_clone.png" />

<a />

### Manage

Users can manage cluster nodes, security, backups, and more from a particular
cluster's management interface. Click **Refresh** to refresh the
management page.

#### Nodes

**Nodes** is divided into three tabs: **List**,
**Switchover**, **Failover Configuration**.

* *List* -- Provides a summary of the nodes and services enabled in the
  cluster. Click **Remove Node** to remove a node from the cluster.
  Click **Add Spare** to bring additional nodes into the
  cluster.
* *Switchover* -- No longer used
* *Failover Configuration* -- No longer used

<img alt="../../images/kagent_nodes.png" />

#### Detail

**Detail** provides basic information about the cluster, including
ring (HA), SSL, license, and more.

<img alt="../../images/kagent_detail.png" />

#### Security

**Security** provides the ability to adjust the existing security
configuration for the cluster.

To update the security configuration:

1. Select an **SSL Update Mode**:

   * **Cert/key setup not required** -- no SSL certificate/key
     creation/upload required and no updates to security configuration settings
   * **User-provided cert/key per node** -- user must upload an SSL
     certificate and key and optionally a public hostname for each node;
     *Kinetica* copies the cert/key pair to <Badge>/opt/gpudb/certs</Badge>, enables
     HTTPD, and configures HTTPD to use HTTPS
   * **Generate self-signed cert/key per node** -- *KAgent* generates
     a self-signed certificate and key for each node and places it in
     <Badge>/opt/gpudb/certs</Badge>, enables HTTPD, and configures HTTPD to use HTTPS

2. Click **Update SSL**. This will override any existing configuration.

3. Select an **Authentication** type and fill the fields as necessary:

   * **None** -- no authentication or authorization
   * **LDAP** -- configures *Kinetica* to authenticate via *LDAP*;
     requires authentication to connect to the database, enables authorization,
     enables external authentication, automatically creates users in the
     database for *LDAP* users, and automatically grants roles in the database
     to *LDAP* users
   * **Active Directory** -- configures *Kinetica* to authenticate via
     *Microsoft Active Directory*; requires authentication to connect to the
     database, enables authorization, enables external authentication,
     automatically creates users in the database for *Active Directory* users,
     and automatically grants roles in the database to *Active Directory* users
   * **Kerberos** -- configures *Kinetica* to authenticate via
     *Kerberos*; requires authentication to connect to the database, enables
     authorization, enables external authentication, automatically creates users
     in the database for *Kerberos* users, and automatically grants roles in the
     database to *Kerberos* users

   <Info>
     For more information on security configurations and settings as well as
     how to manually configure *Kinetica* for a secure setup, see
     [Security Configuration](/content/security/sec_configuration)
   </Info>

4. Click **Update**. This will override any existing configuration.

<img alt="../../images/kagent_security.png" />

<a />

<a />

#### Backups

**Backups** provides the ability to schedule backups of your entire
database. In this section, the system can also be restored from a previous
snapshot. Consult [Backing Up/Restoring Kinetica](/content/admin/backup_restore) for information on
backing up Kinetica using KAgent from the command line.

<img alt="../../images/kagent_backups.png" />

<p><strong>Schedule</strong></p>

To schedule a backup in the future:

1. Provide a **Backup Path**. This directory should be accessible on
   all nodes and to the `gpudb` user.

2. Select the **Hour**, **Day**, or **Month** tab.

3. Select one of the options:

   * For backups every *hour | day | month*
   * For backups every `<n>` *hour(s) | day(s) | month(s)* starting with
     *hour | day | month* `<n>`
   * For backups during specific *hour(s) of the day | day(s) of the week | month(s) of the year*

4. Optionally, select as many tables to backup as desired in the
   **Table List**.

   <Warning>
     Only the records in the tables selected will be available upon
     restoring from backup. All other tables that existed at the time
     of backup will be restored but they will have no records.
   </Warning>

5. Click **Update**.

To clear an existing scheduled backup:

1. Click **Clear**.

To backup immediately:

1. Click **Backup Now**.

2. Optionally, provide a **Backup Path**. This directory should be
   accessible on all nodes and to the `gpudb` user. If no directory is
   provided, `/opt/backups` will be used.

   <Note>
     If this path provided differs from the path for the scheduled
     backups, users will not be able to restore from this backup
     via *KAgent*.
   </Note>

3. Optionally, select as many tables to backup as desired in the
   **Table List**.

   <Warning>
     Only the records in the tables selected will be available upon
     restoring from backup. All other tables that existed at the time
     of backup will be restored but they will have no records.
   </Warning>

4. Click **Backup Now**.

<a />

<p><strong>Snapshots</strong></p>

By default, **Snapshots** displays all backups in the set backup path
directory.

* Provide a backup directory path to **View Backup Path** and click
  **Refresh** to display any backups located in the given path.
* Click **Restore** and confirm to restore the database from a snapshot.

<img alt="../../images/kagent_snapshots.png" />

#### Config

**Config** allows users to edit the `external_files_directory`
[config parameter](/content/config#config-main-external-files). This parameter is used for
setting the directory that stores the files upon which
[external tables](/content/concepts/external_tables) are based and restricts the
path of files accessed via [/insert/records/fromfiles](/content/api/rest/insert_records_fromfiles_rest) and
the `SQL LOAD INTO` command.

To update the directory:

1. Adjust the directory in the **external\_files\_directory** field as
   necessary.

   <Note>
     The provided directory must exist prior to the update.
   </Note>

2. Click **Update**.

3. Confirm the cluster restart by clicking **Yes**. The cluster will
   restart and the setting will be updated.

<a />

#### Admin

**Admin** provides the ability to start, stop, or restart any of the
Kinetica-managed services. *KAgent* must first check for the installed services
across the cluster, then each service can be managed. Click **Refresh**
to refresh the list of system services.  The **Admin** tab also
provides access to the **Clone** utility.

<img alt="../../images/kagent_admin.png" />

<p><strong>Clone</strong></p>

**Clone** provides the ability to clone a cluster's authentication
settings, users, and/or data to another cluster. To clone a cluster:

1. Select a **Target Cluster** from the drop-down menu.

2. Select the **Clone Options**:

   * **Authentication**: the source cluster's authentication settings
     (LDAP, Kerberos, etc.) will be cloned to the target cluster
   * **Users**: the source cluster's users and permissions setup will
     be cloned to the target cluster
   * **Data**: the source cluster's data will be cloned to the target
     cluster

3. Click **Clone Cluster**.

   <Note>
     Cloning a cluster should be performed during downtime as
     cloning a cluster while modifying any of the related data
     can lead to inconsistencies between the two clusters.
   </Note>

<img alt="../../images/kagent_cluster_clone.png" />

<a />

## Rings

The **Rings** page allows users to add and configure
[high availability](/content/ha/ha_architecture) (*HA*) rings and create immediate
ring backups.

* Click **+ Ring** to create a ring.
* Click **Refresh** to refresh the list of rings.
* Click **Upgrade** to proceed with a
  [ring upgrade](/content/admin/upgrade).
* Click **Clusters** to display the [Clusters](#clusters) page.
* Click **Enable HA** to enable [ring resiliency](/content/ha)
  for the desired ring.
* Click **Config HA** (once *ring resiliency* is enabled) to configure
  the most important *high availability (HA)* settings. See
  [High Availability Configuration & Management](/content/ha/ha_configuration) for more information.
* Click **Backup** to initiate a backup operation immediately; similar
  to the **Backup Now** functionality in [Backups](#backups).
* Click **Logs** to open the **Gather Logs** modal, which will
  assist in *KAgent* log gathering, *KAgent* package verification, and a
  process backtracing for the `gpudb` service of the selected cluster. Select
  the desired options and click **Gather Logs** to initiate the process;
  a download link will be presented once processing is complete.
* Click **X** to delete the ring.

For more information on enabling and configuring *HA* rings, see
[High Availability Configuration & Management](/content/ha/ha_configuration).

<img alt="../images/manage_rings.png" />

<a />

## Jobs

The **Jobs** page displays all historical and currently active *KAgent*
jobs.

* Click **Refresh** to refresh the list of jobs.
* Click a job's **Name** to open a status window for the job.
* Click **Cancel** to cancel a running job.
* Click **Clear Log** to clear the log for this job.

<img alt="../../../install/img/kagent_jobs.png" />

<a />

## Logs

The **Logs** page hosts the logs for each *KAgent* command and result
during the verification and installation processes as well as any later
interactions with *KAgent*. Click **Refresh** to refresh the log.

<img alt="../../../install/img/kagent_logs.png" />

<a />

## Console

The **Console** window hosts a running log of *KAgent's* activity while
it interacts with the local/provisioned instances to install or upgrade Kinetica
and its components, create backups, and more. Click **Show Details** to
display detailed information about each interaction.

<img alt="../../../install/img/kagent_console.png" />


# Queries
Source: https://docs.kinetica.com/content/admin/kagent/queries



The **Queries** page in *KAgent* hosts a running log of all queries
made against the database.

<img alt="../images/queries.png" />

## Actions

The available actions on the **Queries** page are as follows:

* Refresh the list of queries by clicking **Refresh**
* Update any of the **Advanced Filter** fields and click
  **Apply Filter** to filter the queries list based on the
  provided values. Click **Clear** to remove the filter.
* Open a detailed view of a query by clicking **Detail** next to the
  desired query:

  <img alt="../images/queries_details.png" />


# Events Timeline
Source: https://docs.kinetica.com/content/admin/kagent/shared/events_timeline



The **Events Timeline** displays events that have occurred within
the selected timeframe. A red cursor continuously moves through the timeline,
denoting seconds as they pass. Events will appear along the timeline in real
time.

<img alt="../images/dashboard_events_timeline.png" />

First, click the **Events Timeline**, then:

* Scroll to zoom in and out on the timeline
* Click and drag left and right to move the timeline backward and forward
  respectively
* Click an event dot to open detailed information, including the source of the
  event, the [event code](/content/admin/event_codes), the timestamp of the
  event, and more:

  <img alt="../images/dashboard_event_details.png" />


# Usage
Source: https://docs.kinetica.com/content/admin/kagent/usage



The **Usage** page in *KAgent* hosts detailed system and
[resource group](/content/rm) usage statistics and metrics.

## System

The **System** tab under the **Usage** page displays several
system usage metric and statistics graphs as well as an [Events Timeline](#events-timeline).

* Click one of the timeframe control buttons or select a date-time range to
  adjust the event timeline and the metric graphs to the selected duration
* Adjust the **Ring**, **Cluster**, and/or **Node**
  drop-down menus to filter the graphs for the selected ring / cluster / node
* Point the cursor to a graph to see the value at that time

<img alt="../images/usage.png" />

<a />

### Events Timeline

The **Events Timeline** displays events that have occurred within
the selected timeframe. A red cursor continuously moves through the timeline,
denoting seconds as they pass. Events will appear along the timeline in real
time.

<img alt="../images/dashboard_events_timeline.png" />

First, click the **Events Timeline**, then:

* Scroll to zoom in and out on the timeline
* Click and drag left and right to move the timeline backward and forward
  respectively
* Click an event dot to open detailed information, including the source of the
  event, the [event code](/content/admin/event_codes), the timestamp of the
  event, and more:

  <img alt="../images/dashboard_event_details.png" />

## Resource Groups

The **Resources Groups** tab under the **Usage** page displays
metrics and statistics graphs for select configured storage tiers as well as
an [Events Timeline](#events-timeline).

* Click one of the timeframe control buttons or select a date-time range to
  adjust the event timeline and the metric graphs to the selected duration
* Adjust the **Ring**, **Cluster**, and/or **Node**
  drop-down menus to filter the graphs for the selected ring / cluster / node
* Point the cursor to a graph to see the value at that time

<img alt="../images/usage_resource_groups.png" />


# Custom Logging
Source: https://docs.kinetica.com/content/admin/logging



The default core *Kinetica* log that records database interactions,
startup/shutdown, error information, and more is located at
`/opt/gpudb/core/logs/gpudb.log`. This log file can be configured to use a
custom format that conforms to a rolling logging standard, enable various
appenders and/or loggers, change the logging level, and more using the
`/opt/gpudb/core/etc/gpudb_logger.conf` file.

## Customizing the Log

1. Review the available [Log Levels](/content/admin/logging#log-levels).

   * `OFF`
   * `FATAL`
   * `ERROR`
   * `WARN`
   * `UERR`
   * `INFO`
   * `DEBUG`
   * `TRACE`
   * `NOTSET`

2. Review the available [Appenders](/content/admin/logging#appenders).

   * `ToConsole`
   * `ToSysLog`
   * `ToFile`
   * `ToRollingFile`
   * `ToRollingDatedFile`
   * `ToBacktraceFile`

3. Review the available [Loggers](/content/admin/logging#loggers).

4. Open `/opt/gpudb/core/etc/gpudb_logger.conf` with a text editor.

5. Update the `rootLogger` setting with the desired level and appender(s):

   ```
   log4cplus.rootLogger=<log-level>, <appender1>[, <appender2>, ..., <appenderN>]
   ```

6. Uncomment the desired appender setting section(s):

   ```
   # ---------------------------------------------------------------------------
   # Rolling dated log file appender.
   # ...

   log4cplus.appender.ToRollingDatedFile=log4cplus::RollingDatedFileAppender
   ...
   ```

7. Adjust the appender settings as necessary, e.g., log size, threshold, file
   name, etc.

8. Adjust additional logger levels and/or appender(s) as necessary:

   ```
   # ===========================================================================
   # Loggers
   # ...

   # Log memory info, logs at DEBUG.
   log4cplus.logger.MEMORY=<log-level>, <appender1>[, <appender2>, ..., <appenderN>]
   ...
   ```

9. Save and exit the file.

10. Restart the [host manager](/content/admin/host_manager) and the database:

    ```
    service restart gpudb_host_manager && service restart gpudb
    ```

<a />

## Log Levels

Log levels can be attributed to the `rootLogger` (the base logger, default
level is `INFO`), the individual loggers at the bottom of the file, or as the
threshold for an appender. The log levels can be ranked in order from least
information to most information logged like so: `OFF`, `FATAL`, `ERROR`,
`WARN`, `UERR`, `INFO`, `DEBUG`, `TRACE`. Some loggers will not
provide their information unless a certain level is set.

| Level    | Description                                                                                                                                                                                       |
| -------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `OFF`    | Does not log at all.                                                                                                                                                                              |
| `FATAL`  | Logs unrecoverable errors that occur and cause the database or a component to exit.                                                                                                               |
| `ERROR`  | Logs serious and unexpected errors that may severely impact the database, e.g., network errors, disk full, etc.                                                                                   |
| `WARN`   | Logs unfavorable conditions or states that may impair the database, e.g., network outage, slow disks, etc.                                                                                        |
| `UERR`   | Logs malformed user requests or requests that could not be processed, e.g., invalid table names, bad options, etc.                                                                                |
| `INFO`   | Logs informational messages recorded during startup and shutdown. There are two `INFO` logs per request by the head node: one when the request is received and one when the request is completed. |
| `DEBUG`  | Logs verbose messages about program processing and state.                                                                                                                                         |
| `TRACE`  | Logs even more verbose messages about program processing and state.                                                                                                                               |
| `NOTSET` | Logs at the level of the next logger in the chain, up to the `rootLogger`. This is equivalent to commenting out the logger.                                                                       |

Some loggers may have chained sub loggers; these sub
loggers will use the same level as the next logger up the chain (if set). If
none of the loggers or sub loggers in the chain are set, the logger will use the
`rootLogger` level. For example, if the following sub logger is `NOTSET`:

```
log4cplus.logger.GlobalManager.pub.socket=NOTSET
```

It will use the level of the next logger up the chain:

```
log4cplus.logger.GlobalManager.pub=INFO
```

<a />

## Appenders

The <Badge>gpudb\_logger.conf</Badge> file comes with preconfigured appenders that can
be used to create different log types. Multiple appenders can be used if
necessary as long as the appropriate settings are uncommented and the appender
name is added to the `rootLogger` appender list. Default database setups have
the `ToConsole` appender enabled.

<Note>
  For sizing considerations, a request typically logs for about
  500 bytes, but [joins](/content/concepts/joins) and multi-step
  queries will log quite a bit more.
</Note>

### ToConsole

The Console appender pipes the output of the `/opt/gpudb/core/bin/gpudb`
script to a `/opt/gpudb/core/logs/gpudb-<hostname>-<date>.log` file. This
file is symbolically linked to `/opt/gpudb/core/logs/gpudb.log`.

| Setting                    | Description                                                                                                                                                                                                                |
| -------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `layout`                   | Dictates the type of layout the logging of which the logging will take form.                                                                                                                                               |
| `layout.ConversionPattern` | The log4cplus pattern to use for the layout. See the `PatternLayout` class [reference documentation](https://log4cplus.github.io/log4cplus/docs/log4cplus-2.1.0/doxygen/classlog4cplus_1_1PatternLayout.html) for details. |

### ToSysLog

The SysLog appender sends the log output to the centralized SysLog host.

| Setting                    | Description                                                                                                                                                                                                                |
| -------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `layout`                   | Dictates the type of layout the logging of which the logging will take form.                                                                                                                                               |
| `layout.ConversionPattern` | The log4cplus pattern to use for the layout. See the `PatternLayout` class [reference documentation](https://log4cplus.github.io/log4cplus/docs/log4cplus-2.1.0/doxygen/classlog4cplus_1_1PatternLayout.html) for details. |
| `syslogHost`               | Hostname for the SysLog host.                                                                                                                                                                                              |
| `Facility`                 | Source of the log messages.                                                                                                                                                                                                |
| `Threshold`                | The level of messages to log. See [Log Levels](/content/admin/logging#log-levels) for more information.                                                                                                                    |

### ToFile

The File appender sends each *Kinetica* process' (rank and host manager) logs to
a separate file.

<Note>
  This appender is demanding in terms of disk space.
</Note>

| Setting                    | Description                                                                                                                                                                                                                                                                   |
| -------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `File`                     | The name and directory of the files to which to send the logs. The files will have an `-r<rank-number>` or `-hm` appended for each rank and the host manager respectively.                                                                                                    |
| `Threshold`                | The log level required to log messages. See [Log Levels](/content/admin/logging#log-levels) for more information.                                                                                                                                                             |
| `Append`                   | Enables appending log messages to the end of the files. Leave as `true`.                                                                                                                                                                                                      |
| `ImmediateFlush`           | Enables flushing the output stream to the files with each append operation.                                                                                                                                                                                                   |
| `layout`                   | Dictates the type of layout the logging of which the logging will take form.                                                                                                                                                                                                  |
| `layout.ConversionPattern` | The log4cplus pattern to use for the layout. See the `PatternLayout` class [reference documentation](https://log4cplus.github.io/log4cplus/docs/log4cplus-2.1.0/doxygen/classlog4cplus_1_1PatternLayout.html) for details.                                                    |
| `UseLockFile`              | Enables the use of a logger lockfile to create a single log file per host. <br /> <Note> Setting this value to `true` results in slower performance as the system will need to check the file lock for each append. It's recommended this setting be left as `false`. </Note> |

### ToRollingFile

The Rolling File appender processes logs to a rolling log file where a new log
file is created once the previous log file reaches the maximum file size. The
maximum file size and number of files to keep is configurable.

| Setting                    | Description                                                                                                                                                                                                                                                                                                     |
| -------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `File`                     | The name and directory of the files to which to send the logs. The files will have an `-r<rank-number>` or `-hm` appended for each rank and the host manager respectively. As files are periodically replaced, older files are renamed `<filename>.1` to `<filename>.n` where `n` is equal to `MaxBackupIndex`. |
| `Threshold`                | The log level required to log messages. See [Log Levels](/content/admin/logging#log-levels) for more information.                                                                                                                                                                                               |
| `MaxFileSize`              | The maximum file size a log file can reach before a new one is created.                                                                                                                                                                                                                                         |
| `MaxBackupIndex`           | The maximum number of log files to keep until older files are deleted to make room for new ones. Note that this setting defines the maximum backup index for each process, e.g., if `MaxBackupIndex` is set to 4, the host manager can have up to four files, rank 0 can have up to four files, etc.            |
| `Append`                   | Enables appending log messages to the end of the file. Leave as `true`.                                                                                                                                                                                                                                         |
| `ImmediateFlush`           | Enables flushing the output stream to the file with each append operation.                                                                                                                                                                                                                                      |
| `layout`                   | Dictates the type of layout the logging of which the logging will take form.                                                                                                                                                                                                                                    |
| `layout.ConversionPattern` | The log4cplus pattern to use for the layout. See the `PatternLayout` class [reference documentation](https://log4cplus.github.io/log4cplus/docs/log4cplus-2.1.0/doxygen/classlog4cplus_1_1PatternLayout.html) for details.                                                                                      |
| `UseLockFile`              | Enables the use of a logger lockfile to create a single log file per host. <br /> <Note> Setting this value to `true` results in slower performance as the system will need to check the file lock for each append. It's recommended this setting be left as `false`. </Note>                                   |

### ToRollingDatedFile

The Rolling Dated File appender processes logs to a dated rolling log file where
a new log file is created (with the time the file is created appended to the
name) once the previous log file reaches the maximum file size. The maximum file
size and number of files to keep is configurable.

| Setting                    | Description                                                                                                                                                                                                                                                                                                                       |
| -------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `File`                     | The name and directory of the files to which to send the logs. The files will have an `-r<rank-number>` or `-hm` appended for each rank and the host manager respectively. As files are periodically replaced, older files are renamed `<filename-datetime>-1` to `<filename-datetime>-n` where `n` is equal to `MaxBackupIndex`. |
| `Threshold`                | The log level required to log messages. See [Log Levels](/content/admin/logging#log-levels) for more information.                                                                                                                                                                                                                 |
| `MaxFileSize`              | The maximum file size a log file can reach before a new one is created.                                                                                                                                                                                                                                                           |
| `MaxBackupIndex`           | The maximum number of log files to keep until older files are deleted to make room for new ones. Note that this setting defines the maximum backup index for each process, e.g., if `MaxBackupIndex` is set to 4, the host manager can have up to four files, rank 0 can have up to four files, etc.                              |
| `Append`                   | Enables appending log messages to the end of the file. Leave as `true`.                                                                                                                                                                                                                                                           |
| `ImmediateFlush`           | Enables flushing the output stream to the file with each append operation.                                                                                                                                                                                                                                                        |
| `layout`                   | Dictates the type of layout the logging of which the logging will take form.                                                                                                                                                                                                                                                      |
| `layout.ConversionPattern` | The log4cplus pattern to use for the layout. See the `PatternLayout` class [reference documentation](https://log4cplus.github.io/log4cplus/docs/log4cplus-2.1.0/doxygen/classlog4cplus_1_1PatternLayout.html) for details.                                                                                                        |
| `UseLockFile`              | Enables the use of a logger lockfile to create a single log file per host. <br /> <Note> Setting this value to `true` results in slower performance as the system will need to check the file lock for each append. It's recommended this setting be left as `false`. </Note>                                                     |

### ToBacktraceFile

The Backtrace File appender redirects the backtrace logs generated by the
`ErrorBacktrace` logger so they do not appear in the `rootLogger` output.
Add the `ERROR` log level and the `ToBacktraceFile` appender to the
`ErrorBacktrace` like so to properly setup this appender:

```
log4cplus.ErrorBacktrace=ERROR, ToBacktraceFile
```

<Note>
  It's advised that this appender also be added to the
  `rootLogger` so that logs with a threshold of `ERROR` are
  also logged to give context to a backtrace.
</Note>

| Setting                    | Description                                                                                                                                                                                                                |
| -------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `File`                     | The name and directory of the file to which to send the logs.                                                                                                                                                              |
| `Threshold`                | The log level required to log messages. See [Log Levels](/content/admin/logging#log-levels) for more information.                                                                                                          |
| `Append`                   | Enables appending log messages to the end of the file. Leave as `true`.                                                                                                                                                    |
| `ImmediateFlush`           | Enables flushing the output stream to the file with each append operation.                                                                                                                                                 |
| `layout`                   | Dictates the type of layout the logging of which the logging will take form.                                                                                                                                               |
| `layout.ConversionPattern` | The log4cplus pattern to use for the layout. See the `PatternLayout` class [reference documentation](https://log4cplus.github.io/log4cplus/docs/log4cplus-2.1.0/doxygen/classlog4cplus_1_1PatternLayout.html) for details. |
| `additivity`               | If using an alternate appender for the `ErrorBacktrace` logger, set the additivity to `false` to avoid duplicated the backtrace logs in the `rootLogger` output.                                                           |

<a />

## Loggers

Loggers control specific types of information. Each logger can have its own
[log level](/content/admin/logging#log-levels) and [appender](/content/admin/logging#appenders). If the level or
appender are not specified, the `rootLogger` level and/or appender(s) are
used.

Loggers are divided into sections:

* System and process information -- memory, CPU
* GlobalManager and GlobalRegistry -- publish and subscribe sockets
* All ranks (not exclusive to a particular rank) -- filter planner, job manager,
  security manager
* Head node -- endpoint manager, graph client, WMS
* Worker nodes -- bytes and GPU manager, queue, tasks

<a />

## Auditing

The location of the request auditor logs can also be controlled via the
<Badge>gpudb\_logger.conf</Badge> file. Auditing must be enabled before the logging
can be configured; see [Auditing](/content/security/auditing) for more information.

The auditor uses its own appender to separate audit messages from
other log messages. All audit messages are at the `INFO` or `ERROR`
[level](/content/admin/logging#log-levels); it's recommended the audit log level be kept to at
least `INFO`. If desired, the auditor can use a different appender.

The audit log comes with a few preconfigured
[appender types](/content/admin/logging#audit-appenders) that are similar to the `rootLogger`
[appenders](/content/admin/logging#appenders).

### Customizing the Log

1. Review the available [Log Levels](/content/admin/logging#log-levels).

   * `OFF`
   * `FATAL`
   * `ERROR`
   * `WARN`
   * `UERR`
   * `INFO`
   * `DEBUG`
   * `TRACE`
   * `NOTSET`

2. Review the available [Appenders](/content/admin/logging#appenders).

   * `ToConsole`
   * `ToSysLog`
   * `ToFile`
   * `ToRollingFile`
   * `ToRollingDatedFile`
   * `ToBacktraceFile`

3. Open `/opt/gpudb/core/etc/gpudb_logger.conf` with a text editor.

4. Adjust the default `logger.Audit` setting as necessary:

   ```
   log4cplus.logger.Audit=INFO, AuditAppender
   ```

5. Optionally, update the `additivity` setting if audit information is desired
   in both the `rootLogger` and the audit log. In most cases, this will not
   need to be updated.

6. Optionally, uncomment one of the other audit appenders (File or Rolling
   File). If uncommenting a new appender, the Console appender will need to be
   commented out.

7. Adjust the appender settings as necessary, e.g., log size, threshold, file
   name, etc.

8. Save and exit the file.

9. Restart the [host manager](/content/admin/host_manager) and the database:

   ```
   service restart gpudb_host_manager && service restart gpudb
   ```

<a />

### Audit Appenders

#### Console

The Console appender for the audit log will direct output to the `rootLogger`
file(s).

| Setting                    | Description                                                                                                                                                                                                                |
| -------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `layout`                   | Dictates the type of layout the logging of which the logging will take form.                                                                                                                                               |
| `layout.ConversionPattern` | The log4cplus pattern to use for the layout. See the `PatternLayout` class [reference documentation](https://log4cplus.github.io/log4cplus/docs/log4cplus-2.1.0/doxygen/classlog4cplus_1_1PatternLayout.html) for details. |

#### File

The File appender for the audit log will direct output to a file.

| Setting                    | Description                                                                                                                                                                                                                |
| -------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `File`                     | The name and directory of the files to which to send the logs. The files will have an `-r<rank-number>` or `-hm` appended for each rank and the host manager respectively.                                                 |
| `layout`                   | Dictates the type of layout the logging of which the logging will take form.                                                                                                                                               |
| `layout.ConversionPattern` | The log4cplus pattern to use for the layout. See the `PatternLayout` class [reference documentation](https://log4cplus.github.io/log4cplus/docs/log4cplus-2.1.0/doxygen/classlog4cplus_1_1PatternLayout.html) for details. |

#### Rolling File

The Rolling File appender for the audit log will direct output to a rolling
file.

| Setting                    | Description                                                                                                                                                                                                                                                                                                     |
| -------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `File`                     | The name and directory of the files to which to send the logs. The files will have an `-r<rank-number>` or `-hm` appended for each rank and the host manager respectively. As files are periodically replaced, older files are renamed `<filename>.1` to `<filename>.n` where `n` is equal to `MaxBackupIndex`. |
| `MaxFileSize`              | The maximum file size a log file can reach before a new one is created.                                                                                                                                                                                                                                         |
| `MaxBackupIndex`           | The maximum number of log files to keep until older files are deleted to make room for new ones. Note that this setting defines the maximum backup index for each process, e.g., if `MaxBackupIndex` is set to 4, the host manager can have up to four files, rank 0 can have up to four files, etc.            |
| `Append`                   | Enables appending log messages to the end of the file. Leave as `false`.                                                                                                                                                                                                                                        |
| `layout`                   | Dictates the type of layout the logging of which the logging will take form.                                                                                                                                                                                                                                    |
| `layout.ConversionPattern` | The log4cplus pattern to use for the layout. See the `PatternLayout` class [reference documentation](https://log4cplus.github.io/log4cplus/docs/log4cplus-2.1.0/doxygen/classlog4cplus_1_1PatternLayout.html) for details.                                                                                      |


# Monitoring and Alerting
Source: https://docs.kinetica.com/content/admin/monitoring_alerting



Kinetica's monitoring and alerting features are available via the
[KAgent](/content/admin/kagent/kagent) application. Detailed cluster, usage,
and query statistics and metrics are available to assist administrators in
monitoring their Kinetica environment. Administrators can configure alerts that
are triggered when specific performance metric thresholds are exceeded
([Metric Alerts](/content/admin/monitoring_alerting#metric-alerts-concept)) or by specific system events
([Event Alerts](/content/admin/monitoring_alerting#event-alerts-concept)). Administrators can then choose who should be
notified when those alerts fire by configuring [Recipients](/content/admin/monitoring_alerting#recipients-concept) and
[Delivery Channels](/content/admin/monitoring_alerting#delivery-channels-concept) for alert delivery. Visit
[KAgent](/content/admin/kagent/kagent) for an overview of the *KAgent* (and
Monitoring and Alerting) user interface. For information on simpler alerting
via *Host Manager*, see [Alerting](/content/admin/alerting).

## Monitoring

Monitoring in *Kinetica* is enabled via the detailed cluster and ring metrics
and information on the [Dashboard](/content/admin/kagent/dashboard), usage statistics and metrics in
[Usage](/content/admin/kagent/usage), and query logging in [Queries](/content/admin/kagent/queries).

## Alerting

Alerting in *Kinetica* consists of sending notifications at regular intervals
to desired recipients when a given event or metric alert is triggered.

<a />

### Delivery Channels

Delivery channels determine how and/or where notifications are sent. Review the
[Channels](/content/admin/kagent/alerts#channels-ui) interface documentation for more information on accessing the
existing delivery channel configuration settings. The supported delivery
channels are as follows:

* *Email* -- An SMTP host can be configured to send notifications when alerts
  are triggered
* *Slack* -- A *Slack* application's incoming Webhook URL can be provided to
  send notifications to a channel in the specified workplace when alerts are
  triggered

#### Configure Email

1. From the **Channels** tab on the **Alerts** page in *KAgent*,
   click the **Email Settings** sub-tab.
2. Provide a **Host** and **From** value.
3. Optionally, provide a **Hello** hostname.
4. For the **Authentication** settings, provide at least a
   **Username** and **Password** **or** an **Identity**
   and **Secret**.
5. For the **TLS Options**, adjust and provide values as necessary.

<p><strong>Example</strong></p>

To configure notifications to be sent using your *Gmail* account:

1. [Generate a Custom App Password](https://support.google.com/mail/answer/185833)
   using the desired *Gmail* account.

2. For the **Host**, input `smtp.gmail.com:587`.

3. For the **From**, input the address from which the email alert will
   be sent.

4. For the **Authentication**:

   1. Provide the **Username**  for the *Gmail* account used to generate
      the *App Password*.
   2. Input the *App Password* into the **Password** field.

5. Under **TLS Options**, enable the **Use TLS** slider.

6. Click **Save**.

<img alt="../kagent/images/example_email_settings.png" />

<a />

#### Configure Slack

Configuring *Slack* to receive *KAgent* alerts involves creating an app
using the *Slack* API. Follow the
[incoming Webhook creation documentation](https://api.slack.com/messaging/webhooks)
on the *Slack* API website. Once the webhook URL is available, copy it and
provide it when [creating a Slack recipient](/content/admin/monitoring_alerting#create-recipient).

<a />

### Recipients

Recipients determine to whom notifications are sent when an alert is triggered.
Review the [Recipients](/content/admin/kagent/alerts#recipients-ui) interface documentation for more information
on accessing the currently configured recipients. The supported types of
recipients are as follows:

* *Web* -- A notification will be displayed in the *KAgent*
  [notifications pane](/content/admin/kagent/kagent#kagent-ui-notifications) for the selected
  recipient
* *Email* -- A notification will be sent via email using the configured
  SMTP server for the selected recipient
* *Slack* -- A notification will be sent to a given *Slack* channel using the
  configured *Slack* incoming Webhook URL

<a />

#### Create a Recipient

1. From the **Recipients** tab on the **Alerts** page in
   *KAgent*, click **+ Add Recipient**.

2. Select a recipient type:

   * *Email*: Provide an **Email Address**.

     <Tip>
       A distribution list can also be provided if multiple people
       should be notified.
     </Tip>

   * *Web*: Provide a valid **Username**.

     <Note>
       The provided user must have system admin permissions to
       access [KAgent](/content/admin/kagent/kagent).
     </Note>

   * *Slack*: Provide an incoming Webhook URL. See [Configure Slack](/content/admin/monitoring_alerting#config-slack) for more
     information.

3. Click **OK**. The recipient will be created but must be added to
   the alerts via the **Event Alerts** or **Metric Alerts**
   lists.

<img alt="../kagent/images/add_recipient.png" />

<p><strong>Example</strong></p>

To add `sys_admn`, a user with the `system_admin` role, as a *Web*
recipient:

1. Click **+ Add Recipient**.
2. Select the **Web** tab.
3. Input `sys_admn` for the **Username** field.
4. Click **OK**.

<a />

### Metric Alerts

Metric Alerts are triggered when specific performance metric thresholds are
exceeded, such as CPU utilization, memory usage, or rate of API requests.
Review the [Metric Alerts](/content/admin/kagent/alerts#metric-alerts-ui) interface documentation for more information
on accessing the currently configured metric alerts.

<a />

#### Create a Metric Alert

1. From the **Metric Alerts** tab on the **Alerts** page in
   [KAgent](/content/admin/kagent/kagent):, click **+ Add Metric Alert**.

2. Provide a **Name** for the alert.

   <Tip>
     This will be used when generating a notification, so this value
     should be short but relevant
   </Tip>

3. Select a **Severity** for the alert.

4. Provide a **Description** for the alert.

   <Tip>
     This will be used when generating a notification, so this value
     should be short but relevant
   </Tip>

5. Define the **Trigger** condition that will cause the alert to fire:

   1. First, select a **When** condition and an **Of** *metric*.
   2. Next, select an **Is** comparative condition and input a value
      for the given units associated with the selected *metric*.
   3. Select an **On** condition to determine to which (or any/all)
      ring, cluster, and/or node this alert applies.
   4. Select an **For** condition to determine for how long the
      selected metric must be consistently meeting the configured condition.

      <Tip>
        Set the value to `0` to send an alert as soon as the condition
        is met.
      </Tip>

6. Optionally, click **Recipients** and select an available recipient to
   send the notification to when the alert triggered. A recipient can also be
   set via the **Metric Alerts** list.

7. Click **Save**.

<img alt="../kagent/images/add_metric_alert.png" />

<p><strong>Examples</strong></p>

To create a warning metric alert for high (> 90%) CPU usage on any node within
a ring/cluster for 5 minutes (or more):

1. Click **+ Add Metric Alert**.
2. For the **Name**, input `High CPU Usage`.
3. For the **Severity**, select **WARNING** from the
   drop-down menu.
4. For the **Description**, input
   `CPU usage has been greater than 90% for 5 minutes (or more)`.
5. For the **Trigger**:

   1. Leave **When** as **Value**.
   2. For the **Of** *metric*, select **CPU Usage** from the
      drop-down menu. Notice the **units**  will automatically change to
      **%**.
   3. Update the **Is** comparative condition to
      **Greater than** and set the associated value to `90`.
   4. For **On**, select **Any Ring, Cluster, or Node** from the
      drop-down menu.
   5. Leave the default values for **For**.
   6. Click **Save**.

      <Tip>
        If a recipient has already been created, click
        **Recipient** next to the new metric alert, then select
        the desired recipient for the alert.
      </Tip>

<img alt="../kagent/images/example_metric_alert.png" />

To create a fatal metric alert for average memory usage of 100% across a given
cluster for 0 minutes (triggering an immediate notification upon meeting the
condition):

1. Click **+ Add Metric Alert**.
2. For the **Name**, input `Max Memory Usage`.
3. For the **Severity**, select **FATAL** from the drop-down
   menu.
4. For the **Description**, input
   `Average memory usage across cluster is 100%`.
5. For the **Trigger**:

   1. For the **When**, select **Average** from the drop-down
      menu.
   2. For the **Of** *metric*, select **Memory Usage** from the
      drop-down menu. Notice the **units**  will automatically change to
      **%**.
   3. Leave the **Is** comparative condition as **Equal to**,
      but set the associated value to `100`.
   4. For **On**, select the desired ring then a desired cluster from
      the drop-down menu.
   5. Set the **For** value to `0`.
   6. Click **Save**.

      <Tip>
        If a recipient has already been created, click
        **Recipient** next to the new metric alert, then select
        the desired recipient for the alert.
      </Tip>

<img alt="../kagent/images/example_metric_alert_mem_usage.png" />

<a />

### Event Alerts

Event Alerts are triggered when specific system events occur, such as nodes
terminating or data ingestion completing. Review the [Event Alerts](/content/admin/kagent/alerts#event-alerts-ui)
interface documentation for more information on accessing the currently
configured event alerts. Review the list of [Event Codes](/content/admin/event_codes) to see the
available events.

<a />

#### Create an Event Alert

1. From the **Event Alerts** tab on the **Alerts** page in
   *KAgent*, click **+ Add Event Alert**.
2. Select a system event from the **Events** drop-down menu.
3. Optionally, select a ring from the **Ring** drop-down menu.
4. Optionally, select a cluster from the **Cluster** drop-down menu.
5. Optionally, select a node from the **Node** drop-down menu.
6. Optionally, select an available recipient to send the notification to when
   the alert triggered. A recipient can also be set via the
   **Event Alerts** list.
7. Click **OK**.

<img alt="../kagent/images/add_event_alert.png" />

<p><strong>Example</strong></p>

To create an event alert for when a rank crashes in a given cluster:

1. Click **+ Add Event Alert**.
2. For the **Event**, select **Rank crashed** from the drop-down
   menu.
3. Select the desired **Ring** and **Cluster**. Leave
   **Node** as the default value.
4. Click **OK**.

   <Tip>
     If a recipient has already been created, click
     **Recipient** next to the new event alert, then select
     the desired recipient for the alert.
   </Tip>

<img alt="../kagent/images/example_event_alert.png" />


# Managing Kinetica Services
Source: https://docs.kinetica.com/content/admin/services



Typical maintenance of the system may require starting & stopping of Kinetica
services.

* [Managing Database Services](/content/admin/services#manage-db)
* [Managing System Processes](/content/admin/services#manage-sys)
* [Managing All Services](/content/admin/services#manage-all)

A variety of [service status checks](/content/admin/services#status-check) are available for
assessing the health of the system and troubleshooting.

<a />

## Managing Database Services

* [Start Database Services](/content/admin/services#start-db)
* [Stop Database Services](/content/admin/services#stop-db)

<a />

### Start Database Services

The following database services can be started via *GAdmin* or command-line:

* Database

  * *httpd*
  * *Query Service*
  * *Text Search*

* *Reveal*

* *Graph Service*

<Tip>
  All services can be started via *KAgent*. Consult [Admin](/content/admin/kagent/manage#kagent-ui-admin) for
  details.
</Tip>

#### Database Services Startup

There are two methods of starting database services:

* [GUI Startup](#gui-startup)
* [Command-Line Startup](#command-line-startup)

<a />

<p><strong>GUI Startup</strong></p>

If *GAdmin* is not running,
[start system management processes](/content/admin/services#start-sys) first.

1. Log in to [GAdmin](/content/admin/gadmin)
2. Click **Admin** on the left menu
3. Click **Start**
4. On the **Start Service?** pop-up, click **Start**
5. Click **Continue** when the database has started

<a />

<p><strong>Command-Line Startup</strong></p>

This method will automatically start system management processes, if they are
not already running.

Run the following as the <Badge>root</Badge> user:

```
systemctl start gpudb
```

Verify that Kinetica is running by browsing to
`http://<yourhostname>:8080/gadmin`

<a />

### Stop Database Services

The following database services can be stopped via *GAdmin* or command-line:

* *Reveal*
* *Graph Service*
* Database

  * *httpd*
  * *Query Service*
  * *Text Search*

<Tip>
  All services can be stopped via *KAgent*. Consult [Admin](/content/admin/kagent/manage#kagent-ui-admin) for
  details.
</Tip>

#### GUI Stop

1. Log in to [GAdmin](/content/admin/gadmin)
2. Click **Admin** on the left menu
3. Click **Stop**
4. On the **Stop Service?** pop-up, click **Stop**
5. Click **Continue** when the database has stopped

#### Command-Line Stop

Run the following as the <Badge>root</Badge> user:

```
systemctl stop gpudb
```

<a />

## Managing System Processes

* [Start System Management Processes](/content/admin/services#start-sys)
* [Stop System Management Processes](/content/admin/services#stop-sys)

<a />

### Start System Management Processes

If the cluster was installed via *KAgent*, the statistics/metrics process and
optional high-availability queues need to be started first.

Run the following as the <Badge>root</Badge> user.

1. Start the statistics/metrics manager on the *KAgent* node (usually head
   node):

   ```
   systemctl start kinetica_stats
   ```
2. If this is a cluster in a High-Availability ring, start *RabbitMQ* on every
   node running it:

   ```
   systemctl start gpudb-mq
   ```
3. Start all system management processes (*Host Manager*, *GAdmin*) on every
   node:

   ```
   systemctl start gpudb_host_manager
   ```

<a />

### Stop System Management Processes

If the cluster was installed via *KAgent*, the statistics/metrics process and
optional high-availability queues need to be stopped last.

Run the following as the <Badge>root</Badge> user.

1. Stop all system management processes (*Host Manager*, *GAdmin*) on every
   node:

   ```
   systemctl stop gpudb_host_manager
   ```

   <Info>
     This will, in turn,
     [stop database services](/content/admin/services#stop-db), as well
   </Info>

2. If this is a cluster in a High-Availability ring, stop *RabbitMQ* on every node
   running it:

   ```
   systemctl stop gpudb-mq
   ```

3. Stop the statistics/metrics manager on the *KAgent* node (usually head node):

   ```
   systemctl stop kinetica_stats
   ```

<a />

## Managing All Services

For [KAgent](/content/admin/kagent/kagent) installations, the following
sections detail how to manage system processes via CLI.

* [Start All Processes](/content/admin/services#start-all)
* [Stop All Processes](/content/admin/services#stop-all)

<a />

### Start All Processes

Run the following commands as the <Badge>root</Badge> user.

Start the statistics/metrics manager on the *KAgent* node (usually head node):

```
systemctl start kinetica_stats
```

If this is a cluster in a High-Availability ring, start *RabbitMQ* on every node
running it:

```
systemctl start gpudb-mq
```

Start the *Host Manager* on every node:

```
systemctl start gpudb_host_manager
```

Start the database services on the head node:

```
systemctl start gpudb
```

<a />

### Stop All Processes

Run the following commands as the <Badge>root</Badge> user.

Stop the database services on the head node:

```
systemctl stop gpudb
```

Stop the *Host Manager* on every node:

```
systemctl stop gpudb_host_manager
```

If this is a cluster in a High-Availability ring, stop *RabbitMQ* on every node
running it:

```
systemctl stop gpudb-mq
```

Stop the statistics/metrics manager on the *KAgent* node (usually head node):

```
systemctl stop kinetica_stats
```

<a />

## Managing Individual Components

The `/opt/gpudb/core/bin/gpudb` script has several directives available to
assist in managing the individual *Kinetica* components.

<Note>
  The `/opt/gpudb/core/bin/gpudb` script should always be run
  as the `gpudb` user
</Note>

### Directives

| Directive               | Description                                                                                      |
| ----------------------- | ------------------------------------------------------------------------------------------------ |
| `<component>-start`     | Starts the given component if it's not currently running                                         |
| `<component>-stop`      | Stop the given component if it's not stopped                                                     |
| `<component>-restart`   | Stop the given component if it's not stopped then start it                                       |
| `<component>-status`    | Prints status information, including the process IDs it is using                                 |
| `<component>-pids`      | Prints the process IDs the component is using                                                    |
| `<component>-enabled`   | Returns `1` is the component is enabled and `0` otherwise. Used internally by the `gpudb` script |
| `<component>-installed` | Returns `1` is the component is enabled and `0` otherwise. Used internally by the `gpudb` script |

### Components

| Component       | Description                                                              |
| --------------- | ------------------------------------------------------------------------ |
| `host-manager`  | [Host Management Services](/content/admin/host_manager)                  |
| `gpudb`         | Database Service                                                         |
| `graph`         | [Graph Service](/content/graph_solver/network_graph_solver)              |
| `httpd`         | Web Server                                                               |
| `query-planner` | SQL Service                                                              |
| `reveal`        | [Reveal Analytic Desktop](/content/bi/reveal)                            |
| `stats`         | Statistics Services, available via [GAdmin](/content/admin/gadmin/stats) |
| `text-search`   | [Full Text Search](/content/concepts/full_text_search) Services          |
| `tomcat`        | [GAdmin](/content/admin/gadmin) Web Application                          |

### Examples

To restart the stats server:

```
/opt/gpudb/core/bin/gpudb stats-restart
```

<Info>
  * If `external_text_search = true` in the `/opt/gpudb/core/etc/gpudb.conf`
    file, then the text search server can be managed using the directives
    above. If `external_text_search = false`, then the text search server
    will not be able to be managed individually.

  * The *Host Manager* service manages the *HTTPD* and *ODBC* components. It's
    possible to stop these components, but *Host Manager* will restart them
    immediately. Stopping *Host Manager* and attempting to start these components
    individually will not work.
</Info>

<a />

## System Status Checks

There are several means to check the status of system components:

* [Processes](#processes)
* [GAdmin](#gadmin)
* [API](#api)

<a />

### Processes

To check the status of the database processes:

* *Host Manager*

* *GAdmin*

* Stats Services

* Database

  * *httpd*
  * *Query Service*
  * *Text Search*

* *Reveal*

* *Graph Service*

Run the following as the <Badge>root</Badge> or <Badge>gpudb</Badge> user:

```
service gpudb status
```

<a />

### GAdmin

The [Kinetica Administration Application (GAdmin)](/content/admin/gadmin) provides a GUI for monitoring various aspects of
the system:

* [Cluster Health ](/content/admin/gadmin/cluster)
* [Running Jobs ](/content/admin/job_manager)
* [Information & Diagnostics](/content/admin/gadmin/info)

<a />

### API

To determine whether the *REST* endpoint services are operating, the *Python*
API can be invoked, as follows:

```
$ /opt/gpudb/bin/gpudb_python /opt/gpudb/kitools/gadmin_sim.py -u <username> -p <password> --table --summary
+-----------------+--------------------------------+----------------------+----------------------+-------+
|     Schema      |           Table/View           |       Records        |       Type ID        |  TTL  |
+=================+================================+======================+======================+=======+
| SYSTEM          | <ALL TABLES/VIEWS>             |                    1 |                      |       |
| SYSTEM          | ITER                           |                    1 |        UNSET_TYPE_ID |    -1 |
+-----------------+--------------------------------+----------------------+----------------------+-------+

+---------------------------+----------------------+
|        Object Type        |        Count         |
+===========================+======================+
| Schemas                   |                    1 |
| Tables & Views            |                    1 |
| Records                   |                    1 |
| Records + Track Elements  |                    1 |
+---------------------------+----------------------+
```

<a />

## Statuses

The tables below list the various statuses you could experience in GAdmin or in
logs for the system itself, the nodes and ranks employed by the system, or all
three.

<Note>
  It's likely you won't see many of the node and rank statuses in
  GAdmin as they are transient and only last for a few seconds
  during start up or shut down.
</Note>

### System

| Status           | Description                                                                          |
| ---------------- | ------------------------------------------------------------------------------------ |
| `init`           | The `INIT` signal has been received and the system is initializing                   |
| `rebalancing`    | The system is rebalancing data due to the addition/subtraction of ranks              |
| `running`        | The system is up and available for requests                                          |
| `shutdown`       | The system has shut down and is not available                                        |
| `starting`       | The system is in the process of starting up                                          |
| `stopped`        | The system has stopped all requests and is preparing for shutdown                    |
| `system_limited` | Something is interfering with the systems's ability to communicate between all ranks |

### Node

| Status                 | Description                                                                          |
| ---------------------- | ------------------------------------------------------------------------------------ |
| `enum_hardware`        | The node is processing the hardware being used and checking the license              |
| `establishing_cluster` | The node is ensuring its connection to the system and the other hosts in the cluster |
| `fatal_init_error`     | An error occurred while validating the `gpudb.conf` configuration file               |
| `init`                 | The `INIT` signal has been received and the node is initializing                     |
| `parsed_conf`          | The node has parsed configuration files for any changes                              |
| `post`                 | The node has started and informed the system                                         |
| `ready`                | The node has successfully shutdown and is ready to be started                        |
| `running`              | The node is up and available for requests                                            |
| `shutdown`             | The node has shut down and is not available                                          |
| `shutting_down`        | The node is in the process of shutting down and will not take requests               |
| `started`              | The node has been started and is nearly ready for requests                           |
| `starting`             | The node is in the process of starting up                                            |
| `stopping`             | The node is stopping all requests and preparing for shutdown                         |
| `validating_cluster`   | The node and any other nodes in the cluster are being validated by the system        |

### Rank

| Status             | Description                                                                                   |
| ------------------ | --------------------------------------------------------------------------------------------- |
| `enum_hardware`    | The rank is processing the hardware being used and checking the license                       |
| `fatal_init_error` | An error occurred while validating the `gpudb.conf` configuration file                        |
| `init`             | The `INIT` signal has been received and the rank is initializing                              |
| `initialized`      | The rank has been primed for start-up                                                         |
| `loaded_data`      | The rank has successfully loaded data from the persist directory(ies)                         |
| `loading_data`     | The rank is in the process of loading data from the persist directory(ies)                    |
| `not_responding`   | The rank is currently not responding to requests                                              |
| `parsed_conf`      | The rank has parsed configuration files for any changes                                       |
| `post`             | The rank has started and informed the system                                                  |
| `running`          | The rank is up and available for requests                                                     |
| `shutdown`         | The rank has shut down and is not available                                                   |
| `shutting_down`    | The rank is in the process of shutting down and will not take requests                        |
| `start`            | The rank has received a start signal                                                          |
| `started`          | The rank has been started and is nearly ready for requests                                    |
| `starting`         | The rank is in the process of starting up                                                     |
| `syncing`          | The rank is in the process of syncing types, tables, records, etc.                            |
| `terminated`       | The rank has encountered an error and was terminated; the rank will often restart if possible |


# Database Backup
Source: https://docs.kinetica.com/content/admin/shared/database_backup



## Database Backup

[SQL commands](/content/sql/backup_restore) can be used to initiate hot
*backups*, with *full*, *incremental*, & *differential snapshots*, and
restorations of schema objects & data within the database.

| Objects Backed Up                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | Objects Not Backed Up                                                                                                                                                                 |
| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| \* [Credentials](/content/sql/ddl/create-credential#sql-create-credential) <br /> \* [Data Sinks](/content/sql/ddl/create-data-sink#sql-create-data-sink) <br /> \* [Data Sources](/content/sql/ddl/create-data-source#sql-create-data-source) <br /> \* [Resource Groups](/content/sql/resource_group) <br /> \* [Roles](/content/sql/security#sql-security-role-mgmt) <br /> \* [SQL Procedures](/content/sql/procedure#sql-procedures) <br /> \* [SQL-GPT Contexts](/content/sql/sqlgpt#sql-gpt-create-context) <br /> \* [Streams](/content/sql/ddl/create-stream#sql-create-stream) <br /> \* [Tables](/content/sql/ddl/create-table#sql-create-table) <br /> \* [UDFs](/content/sql/udf) <br /> \* [UDF Environments](/content/sql/udf#sql-create-function-environment) <br /> \* [Users](/content/sql/security#sql-security-user-mgmt) <br /> \* [Views](/content/sql/ddl/create-view#sql-create-view) | \* [Graphs](/content/sql/graph) <br /> \* [KiFS Files](/content/sql/kifs) <br /> \* [ML Models/Containers](/content/sql/ml) <br /> \* [Symbols](/content/api/rest/insert_symbol_rest) |

<Info>
  * For the set of SQL commands for database *backup*, see
    [Database Backup/Restore](/content/sql/backup_restore).
  * For a full system backup, see [System Backup](/content/admin/backup_restore#system-backup).
</Info>

### Snapshot Types

Three types of *snapshots* are supported for database objects & data:

* **full** - *snapshot* of the given database objects & data
* **incremental** - *snapshot* of the changes in the database objects & data
  since the last *snapshot* of any kind
* **differential** - *snapshot* of the changes in the database objects & data
  since the last *full snapshot*

### Backup Storage

Database *backup* files will be transferred to the target specified in the given
[data sink](/content/sql/ddl/create-data-sink#sql-create-data-sink).  There, they will be stored
under two levels of directories:  the top-level directory will be the name of
the database *backup* and the subdirectory will be the timestamp the *snapshot*
was taken; e.g.:

```
/<backup_name>/ki_backup_info.json
/<backup_name>/<backup_name>.mdb
/<backup_name>/<snapshot_timestamp>/<snapshot_timestamp>.mdb
/<backup_name>/<snapshot_timestamp>/rank-<rank_number>/tom-<TOM_number>/*
```

A new *backup* will result in the creation of a directory with the corresponding
*backup* name, as well as a *snapshot* timestamp directory with the
*full snapshot* files.  An *incremental* or *differential snapshot* for a given
*backup* will result in the creation of another *snapshot* timestamp directory,
under the *backup* directory, containing all the files for that *snapshot*.

A [data source](/content/sql/ddl/create-data-source#sql-create-data-source) is required to retrieve
detail about *backups* and restore database objects & data from them.  The
*data source* must point to the same remote store as the *data sink* through
which a *backup* was created in order to access and restore from it.

### Backup Use Case

A typical usage of the backup feature is:

* create a *backup*, taking an initial *full snapshot*
* schedule iterative *incremental* or *differential snapshots*
* restore a *backup*

#### Initial Backup

To create the initial *backup*, run a [CREATE BACKUP](/content/sql/backup_restore#sql-backup-create)
statement, in SQL, that specifies:

* the name to use for the *backup*--the backed-up database object set
* the [data sink](/content/sql/ddl/create-data-sink#sql-create-data-sink) that will be used to
  transfer the backed-up files to the remote store (e.g., s3)
* the set of database objects to back up

For example, to create an initial *backup* with the following parameters:

* `daily_backup` - name of the *backup*
* `backup_ds` - *data sink* targeting the remote file service
* `example_backup` - name of the [schema](/content/sql/ddl/create-schema#sql-create-schema)
  to back up

```sql Create Initial Backup Example theme={null}
CREATE BACKUP daily_backup
DATA SINK = backup_ds
OBJECTS (ALL = example_backup)
```

#### Schedule Iterative Snapshots

To schedule iterative *snapshots* after the initial *backup* is done, create a
[SQL procedure](/content/sql/procedure) that specifies:

* the name of the backed-up database object set (same as the initial *backup*)
* the [data sink](/content/sql/ddl/create-data-sink#sql-create-data-sink) that will be used to
  transfer the *snapshots* to the remote store (same as the initial *backup*)
* the schedule for running the incremental *snapshots*

For example, to schedule incremental *snapshots* with the following parameters:

* `daily_backup` - name of the *backup* to which *snapshots* will be added
* `backup_ds` - *data sink* targeting the remote file service
* `1 DAY` - daily *snapshot* interval
* `STARTING AT...2025-01-01` - starting at a date in the past causes the
  first *snapshot* to be taken at the next possible time interval
* `STARTING AT...00:00:00` - schedule the *snapshot* to be taken at midnight

```sql Schedule Iterative Snapshots Example theme={null}
CREATE PROCEDURE scheduled_backup
BEGIN
	BACKUP daily_backup
	DATA SINK = backup_ds
END
EXECUTE FOR EVERY 1 DAY STARTING AT '2025-01-01 00:00:00';
```

#### Restore Backup

To restore database objects and table data from the latest *snapshot* in a
*backup*, using the following parameters:

* `daily_backup` - name of the *backup* to restore
* `restore_ds` - *data source* targeting the remote file service
* `example_backup` - name of the [schema](/content/sql/ddl/create-schema#sql-create-schema)
  to restore
* `replace` - any exising database object will be overwritten by its
  counterpart from the *backup*

```sql Restore Backup Example theme={null}
RESTORE BACKUP daily_backup
DATA SOURCE = restore_ds
OBJECTS (ALL = example_backup)
WITH OPTIONS (RESTORE_POLICY = 'replace')
```


# Upgrade
Source: https://docs.kinetica.com/content/admin/upgrade



Upgrading to *Kinetica* **7.2** is facilitated through the use of
[KAgent](/content/admin/kagent/kagent).  *KAgent* **7.2** provides the
ability to upgrade existing *Kinetica* clusters managed by *KAgent* **7.1** or
clusters that are not managed at all.

Upgrading requires the system be *Kinetica* **7.1** or newer.  If running a
*Kinetica* version prior to that, refer to the
[Kinetica 7.1 Upgrade instructions](https://legacydocs.kinetica.com/7.1/admin/upgrade/)
for details on upgrading to **7.1** first, and then refer back to this guide to
complete the upgrade to version **7.2**.

## Migration Guide

See [Migrating To Kinetica 7.2](/content/install/migration_guide) for considerations that should be made
before deciding to upgrade.

## Pre-Upgrade Actions

Before upgrading to *Kinetica* **7.2** perform the following checks & tasks to
ensure the system is ready to be upgraded.

### Checks

* Ensure that the system being upgraded is *Kinetica* **7.1**.
* Ensure that 8GB of disk space is available on the directory mount used for
  installation on each node.
* If performing an offline upgrade, ensure that all installation packages are
  available to the machine initiating the upgrade (the one that will log into
  *KAgent* and kick off the installation).

<a />

### Tasks

* [Back up](/content/admin/backup_restore#backrest-backup) data & configuration files.
* If [AAW](https://legacydocs.kinetica.com/7.1/aaw/overview/) is being used, terminate all [ingests](https://legacydocs.kinetica.com/7.1/aaw/data/) and [deployed models](https://legacydocs.kinetica.com/7.1/aaw/deployments/).

<a />

## Upgrade Actions

If upgrading an on-premise *Kinetica* ring or one hosted in the cloud, the ring
can be upgraded in place.

The upgrade path is dependent upon whether the *Kinetica 7.1* cluster is
currently being managed by *KAgent*.

* [Managed Cluster Upgrade](#managed-cluster-upgrade)
* [Unmanaged Cluster Upgrade](#unmanaged-cluster-upgrade)

<a />

### Managed Cluster Upgrade

If the cluster to upgrade is already managed by *KAgent* **7.1**, upgrade
*KAgent* to version **7.2**, and then upgrade the cluster.

1. Upgrade KAgent.

   *KAgent* can be upgraded in place, whether it resides on a server inside or
   outside the cluster.  After copying the *KAgent* package to the server hosting
   *KAgent*, upgrade the package using the standard procedures for a local package:

   1. Stop the current *KAgent* process:

      ```
      service kagent stop
      ```
   2. Upgrade the *KAgent* application based on host operating system:

      * On RHEL:

        ```
        sudo yum upgrade ./kagent-<version>.<architecture>.rpm
        ```
      * On Debian/Ubuntu:

        ```
        sudo apt upgrade ./kagent-<version>.<architecture>.deb
        ```

   This upgrades the package in the directory <Badge>/opt/gpudb/kagent</Badge> and
   starts the `kagent_ui` service.

2. Start *KAgent*.

   <img alt="../../install/img/kagent_start.png" />

   To access the [KAgent UI](/content/admin/kagent/kagent):

   1. Ensure the *KAgent* service is started:

      ```
      service kagent_ui status
      ```
   2. Browse to the *KAgent* application using IP or host name:

      ```
      http://<kagent-host>:8081/kagent
      ```
   3. If *KAgent* is associated with one or more *Kinetica* clusters, log in using
      the credentials for that cluster.  If *KAgent* has not been associated with
      any clusters yet, the application will load without prompting.

3. Click **Upgrade Ring**.

4. For each ring to upgrade, click **Upgrade** on that ring, and follow
   these steps to upgrade the ring:

   1. Confirm that all tasks under **Tasks** have been performed, then
      check the checkboxes and click **Start**.
   2. If performing an offline upgrade, upload all the *Kinetica* **7.2**
      install packages.  When done, or if performing an online upgrade, click
      **Next**.
   3. Click **Upgrade** and then click **Yes** to begin the
      *Kinetica* **7.2** upgrade process.
   4. Click **Close** when the upgrade is complete.

<a />

### Unmanaged Cluster Upgrade

If the cluster to upgrade is **not** managed by *KAgent* **7.1**, install
*KAgent* **7.2**, add the cluster, and upgrade it to **7.2**.

1. Install *KAgent*.

   *KAgent* can be deployed as a RHEL, Ubuntu, or SUSE installation package on any
   server inside or outside the cluster.

   Automatically download & install the latest *KAgent* version using these
   commands:

   <CodeGroup>
     ```bash RHEL 8 theme={null}
     KAGENT_REPO=https://repo.kinetica.com/yum/7.2/CentOS/8/x86_64
     KAGENT_PKG=$(wget -q -O - ${KAGENT_REPO} | sed 's/<[^>]*>//g' | grep -o "kagent.*ga.*rpm " | sort -V | tail -1)
     wget ${KAGENT_REPO}/${KAGENT_PKG}
     sudo yum install ./${KAGENT_PKG}
     ```

     ```bash Ubuntu 20 theme={null}
     KAGENT_REPO=https://repo.kinetica.com/debian/7.2/Ubuntu/focal/binary-amd64
     KAGENT_PKG=$(wget -q -O - ${KAGENT_REPO} | sed 's/<[^>]*>//g' | grep -o "kagent.*ga.*deb " | sort -V | tail -1)
     wget ${KAGENT_REPO}/${KAGENT_PKG}
     sudo apt install ./${KAGENT_PKG}
     ```

     ```bash Ubuntu 22 theme={null}
     KAGENT_REPO=https://repo.kinetica.com/debian/7.2/Ubuntu/jammy/binary-amd64
     KAGENT_PKG=$(wget -q -O - ${KAGENT_REPO} | sed 's/<[^>]*>//g' | grep -o "kagent.*ga.*deb " | sort -V | tail -1)
     wget ${KAGENT_REPO}/${KAGENT_PKG}
     sudo apt install ./${KAGENT_PKG}
     ```

     ```bash SUSE 15 theme={null}
     KAGENT_REPO=https://repo.kinetica.com/yum/7.2/SUSE/15.3/x86_64
     KAGENT_PKG=$(wget -q -O - ${KAGENT_REPO} | sed 's/<[^>]*>//g' | grep -o "kagent.*ga.*rpm " | sort -V | tail -1)
     wget ${KAGENT_REPO}/${KAGENT_PKG}
     sudo zypper install ./${KAGENT_PKG}
     ```
   </CodeGroup>

   Alternatively, visit the `KAGENT_REPO` link below to search for a specific
   version of *KAgent*, change `KAGENT_PKG` to that version on **line 2**, and
   then run the modified commands to download & install that version:

   <CodeGroup>
     ```bash RHEL 8 theme={null}
     KAGENT_REPO=https://repo.kinetica.com/yum/7.2/CentOS/8/x86_64
     KAGENT_PKG=kagent-7.2.0.4.20240326024429.ga-0.x86_64.el8.rpm
     wget ${KAGENT_REPO}/${KAGENT_PKG}
     sudo yum install ./${KAGENT_PKG}
     ```

     ```bash Ubuntu 20 theme={null}
     KAGENT_REPO=https://repo.kinetica.com/debian/7.2/Ubuntu/focal/binary-amd64
     KAGENT_PKG=kagent_7.2.0.4.20240326024429.ga-0_amd64.ubuntu20.04.deb
     wget ${KAGENT_REPO}/${KAGENT_PKG}
     sudo apt install ./${KAGENT_PKG}
     ```

     ```bash Ubuntu 22 theme={null}
     KAGENT_REPO=https://repo.kinetica.com/debian/7.2/Ubuntu/jammy/binary-amd64
     KAGENT_PKG=kagent_7.2.0.4.20240326024429.ga-0_amd64.ubuntu22.04.deb
     wget ${KAGENT_REPO}/${KAGENT_PKG}
     sudo apt install ./${KAGENT_PKG}
     ```

     ```bash SUSE 15 theme={null}
     KAGENT_REPO=https://repo.kinetica.com/yum/7.2/SUSE/15.3/x86_64
     KAGENT_PKG=kagent-7.2.0.4.20240326024429.ga-0.x86_64.sles15.3.rpm
     wget ${KAGENT_REPO}/${KAGENT_PKG}
     sudo zypper install ./${KAGENT_PKG}
     ```
   </CodeGroup>

   This installs the package to the directory <Badge>/opt/gpudb/kagent</Badge> and
   registers and starts the `kagent_ui` service. *KAgent* will open port `8081`
   on the local firewall (if enabled).

2. Start *KAgent*.

   <img alt="../../install/img/kagent_start.png" />

   To access the [KAgent UI](/content/admin/kagent/kagent):

   1. Ensure the *KAgent* service is started:

      ```
      service kagent_ui status
      ```
   2. Browse to the *KAgent* application using IP or host name:

      ```
      http://<kagent-host>:8081/kagent
      ```
   3. If *KAgent* is associated with one or more *Kinetica* clusters, log in using
      the credentials for that cluster.  If *KAgent* has not been associated with
      any clusters yet, the application will load without prompting.

3. [Add the cluster to upgrade to KAgent](/content/admin/adding_cluster_kagent),
   choosing the *on-premise* deployment method, regardless of the way in which
   the cluster is actually provisioned.

4. For each additional cluster to upgrade:

   1. Click **+ Cluster**
   2. [Add the cluster to upgrade to KAgent](/content/admin/adding_cluster_kagent#admin-add-cluster), choosing
      the *on-premise* deployment method

5. Click **Rings** at the top of the page.

6. Click **Upgrade** on the ring to upgrade to *Kinetica* **7.2**

7. If performing an offline upgrade, upload all the *Kinetica* **7.2** install
   packages.  When done, or if performing an online upgrade, click
   **Upgrade** and then click **Yes** to begin the
   *Kinetica* **7.2** upgrade process.

## Post-Upgrade Actions

* If [AAW](https://legacydocs.kinetica.com/7.1/aaw/overview/) was being used in the *ring* that was upgraded:

  * recreate all [ingests](/content/ml/concepts#ml-data) that were previously active
  * redeploy all [models](/content/sql/ml#sql-ml-import-model) that were
    previously active

* [Upgrade database clients](/content/admin/upgrade#upgrade-database-clients), if needed.

<a />

### Upgrading Database Clients

Any native API clients or ODBC/JDBC drivers can be updated to take advantage of
new features in *Kinetica* **7.2**.

<a />

#### Native APIs

The instructions for upgrading to the latest APIs can be found in their
respective manuals:

* [C++ Developer Guide](/content/guides/cpp_guide)
* [Java Developer Guide](/content/guides/java_guide)
* [JavaScript Developer Guide](/content/guides/js_guide)
* [Node.js Developer Guide](/content/guides/nodejs_guide)
* [Python Developer Guide](/content/guides/python_guide)

<a />

#### JDBC

See [JDBC](/content/connectors/sql_guide#jdbc) for the latest JDBC clients and related
configuration.

#### ODBC

Be sure to remove older versions of the driver before installing new ones.

<p><strong>Remove Previous Windows ODBC Drivers</strong></p>

To remove the old drivers:

1. Launch **ODBC Data Source Administrator**
   *(64-bit or 32-bit, as needed)*.
2. Select any entry with a **Driver** name of `Kinetica ODBC Driver`.
3. Optionally, click the **Configure** button to open up the driver
   properties window and record any settings that could be reused with the new
   driver (username, SSL Certificate path, etc.).
4. Click the **Remove** button.
5. Click the **Yes** button to confirm the removal.
6. Repeat this process until all older drivers have been removed.

<p><strong>Install New ODBC/JDBC Drivers</strong></p>

See [ODBC](/content/connectors/sql_guide#odbc) for the latest ODBC clients and related
configuration.


# Kinetica Workbench
Source: https://docs.kinetica.com/content/admin/workbench/index



The *Kinetica Workbench* is the primary interface for interacting with the
*Kinetica* database.  Here, you will find:

* The *Data Object Explorer*, which shows you all of the database objects in
  your database
* *SQL Workbooks*, which organize and store your SQL code and visualizations
* An *Import/Export Wizard*, which helps you import data into the system in a
  guided workflow

<img alt="images/wb.workbench.png" />

## Workbench Components

* [Workbench UI](/content/admin/workbench/ui)
* [Using Workbooks in Workbench](/content/admin/workbench/workbooks)

<a />

## Connecting to the Kinetica Workbench

You can connect to the *Workbench* by opening up the hostname in a browser on
its default port; for example:

```
http://localhost:8000
```


# Explore
Source: https://docs.kinetica.com/content/admin/workbench/ui/explore/index



The *Explore* interface is situated in the right-hand pane of *Kinetica's*
[Workbench](/content/admin/workbench) administration application.  It can
be used to import data into the database from a variety of sources.

<img alt="../../images/wb.explore.png" />

To access the *Explore* page, in *Workbench*, click the
**Explore** menu item.  This will open the list of your
*workbooks* in the right-hand pane, as well as a button for creating a new
*workbook*.  Additionally, at the top, are several action buttons:

| Action                        | Description                                                                |
| ----------------------------- | -------------------------------------------------------------------------- |
| **Refresh Examples**          | Update the sample workbooks to their latest versions                       |
| **Import**                    | Import a *workbook* from a JSON file                                       |
| **Export All**                | Export all *workbooks* listed under **My Workbooks** to a single JSON file |
| <img alt="wb_icon_refresh" /> | Update the list of displayed *workbook* panels                             |
| **+ Create**                  | Create a new *workbook*                                                    |

Clicking on any *workbook* panel will open that *workbook* in the right-hand
pane.

<a />

## Workbooks

When a *workbook* is selected, its first *worksheet* is displayed, along with a
corresponding tab for each of its other *worksheets*.  Click the tabs to switch
between *worksheets*, and click the **+** to create a new
*worksheet*.

<Frame>
  <img alt="../../images/wb.workbook.png" />
</Frame>

There is also a set of *workbook*-level actions at the top:

| Action                        | Description                                                                                                                                                                                                                                                                                                                                                                                    |
| ----------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Share**                     | Toggle sharing of this *workbook* with all other users in the cluster                                                                                                                                                                                                                                                                                                                          |
| <img alt="wb_icon_copy" />    | Make a duplicate of this *workbook*, appending *Copy* to the end of the *workbook's* name                                                                                                                                                                                                                                                                                                      |
| <img alt="wb_icon_embed" />   | Display two means of referencing this *workbook*: <br /> <br /> \* **URL** - a URL that can be used to link directly to this *workbook*, opening it in *Workbench* <br /> \* **HTML** - an HTML snippet that can be used to embed this *workbook* as an *iFrame* within another web page; note that this will require logging into *Workbench* in that frame to access the embedded *workbook* |
| <img alt="wb_icon_export" />  | Export this *workbook* in either JSON format or as a series of SQL statements in a text file                                                                                                                                                                                                                                                                                                   |
| <img alt="wb_icon_refresh" /> | Refresh the displayed blocks of this *workbook*                                                                                                                                                                                                                                                                                                                                                |
| <img alt="wb_icon_edit" />    | Modify the name or description of this *workbook*                                                                                                                                                                                                                                                                                                                                              |
| <img alt="wb_icon_delete" />  | Delete this *workbook*                                                                                                                                                                                                                                                                                                                                                                         |
| <img alt="wb_icon_close" />   | Close this *workbook* and return to the *Explore* landing page                                                                                                                                                                                                                                                                                                                                 |

## Worksheets

The active *worksheet* displays the [SQL-GPT](#sql-gpt) interface at the top, followed by
its contained blocks in the order they are defined within the *worksheet*.
Block types include:

* [SQL Blocks](#sql-blocks)
* [Text Blocks](#text-blocks)
* [Image Blocks](#image-blocks)
* [HTML Blocks](#html-blocks)
* [Map Blocks](#map-blocks)
* [Graph Blocks](#graph-blocks)

<Frame>
  <img alt="../../images/wb.worksheet.png" />
</Frame>

At the top of the *worksheet* are a set of applicable action buttons:

| Action                       | Description                                                                                                                                       |
| ---------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------- |
| <img alt="ws_icon_left" />   | Move this *worksheet* closer to the front of the *workbook*                                                                                       |
| <img alt="ws_icon_right" />  | Move this *worksheet* closer to the back of the *workbook*                                                                                        |
| <img alt="ws_icon_edit" />   | Modify the name or description of this *worksheet*                                                                                                |
| <img alt="ws_icon_copy" />   | Make a duplicate of this *worksheet* in either the current *workbook* or another *workbook*, appending *Copy* to the end of the *workbook's* name |
| <img alt="ws_icon_block" />  | Add a new block of the selected type to the end of this *worksheet*                                                                               |
| <img alt="ws_icon_report" /> | Download a performance report of all queries run within the *worksheet*                                                                           |
| <img alt="ws_icon_print" />  | Display a printable version of the *worksheet*                                                                                                    |
| <img alt="ws_icon_clear" />  | Clear all query results in *SQL Blocks* on this *worksheet*                                                                                       |
| <img alt="ws_icon_run" />    | Run all *SQL Blocks* on this *worksheet* in the sequence in which they appear on the *worksheet*                                                  |

To the right of the blocks is a column of numbers corresponding to each of the
numbered blocks.  Click any one of the numbers to jump to that block.

<a />

<a />

### SQL-GPT

Each *worksheet* within *Workbench* has an interface for interacting with
SQL-GPT at the top.

<Frame>
  <img alt="../../images/wb.explore_ws_sqlgpt.png" />
</Frame>

A natural-language question can be entered into the SQL-GPT text box in order to
generate an equivalent SQL query that can be run to get an answer.  The result
will be added as a new *SQL Block* at the bottom of the *worksheet*.

Available SQL-GPT actions include:

| Action                        | Description                                                                                                                                                              |
| ----------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| <img alt="wsg_icon_gen" />    | Generate a corresponding SQL query for the natural language question entered into the SQL-GPT text box, and add it to a *SQL Block* as the last block on the *worksheet* |
| <img alt="wsg_icon_config" /> | Open the SQL-GPT configuration page                                                                                                                                      |
| <img alt="wsg_icon_info" />   | Learn more about how to configure & use SQL-GPT                                                                                                                          |

#### SQL-GPT Configuration

The *SQL-GPT Configuration* page allows one or more
[SQL-GPT contexts](/content/sql-gpt/concepts#sql-gpt-overview-context) to be assigned to
this *worksheet*.

<Frame>
  <img alt="../../images/wb.explore_ws_sqlgpt_config.png" />
</Frame>

Click on a *SQL-GPT context* on the left and then click the right arrow to
assign the *context* to the current *worksheet*.  Click a *context* on the right
and click the left arrow to unassign the *context* from the current *worksheet*.

Available SQL-GPT configuration actions include:

| Action            | Description                                                                      |
| ----------------- | -------------------------------------------------------------------------------- |
| **Clear History** | Delete the question history, which is shown when the SQL-GPT text box is clicked |
| **Update**        | Save the configuration                                                           |
| **Cancel**        | Don't update the configuration                                                   |

<a />

<a />

### SQL Blocks

Each *SQL Block* allows one or more SQL statements to be added or modified
within it.

<Frame>
  <img alt="../../images/wb.explore_wsb_sql.png" />
</Frame>

The block-specific actions are as follows:

| Action                         | Description                                                                                                                                                                                                                                                         |
| ------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| <img alt="wsb_icon_run" />     | Run the SQL statement(s) in this *SQL Block*, and output the result set of the final query (if one exists) at the bottom of this block, in either data grid or chart form                                                                                           |
| <img alt="wsb_icon_job" />     | View the job status for the query executing in this *SQL Block*; the status will be displayed at the bottom of the block                                                                                                                                            |
| <img alt="wsb_icon_expand" />  | Expand or collapse this block when the enclosing *workbook* is embedded in another web page                                                                                                                                                                         |
| <img alt="wsb_icon_eye" />     | Hide or show this block when the enclosing *workbook* is embedded in another web page                                                                                                                                                                               |
| <img alt="wsb_icon_sqlgpt" />  | Insert a SQL-GPT text box for generating SQL into this *SQL Block*                                                                                                                                                                                                  |
| <img alt="wsb_icon_explain" /> | Display the explain plan of the final query in this *SQL Block*, if one exists: <br /> <br /> \* **Explain Plan** - display the basic execution plan <br /> \* **Run and Analyze** - run the final query and display the execution plan with a statistical analysis |
| <img alt="wsb_icon_runall" />  | Run all *SQL Blocks* from this one onwards, until the end of the *worksheet*                                                                                                                                                                                        |
| <img alt="wsb_icon_add" />     | Add a new block of the selected type below this one                                                                                                                                                                                                                 |
| <img alt="wsb_icon_shrink" />  | Collapse this block, showing only one line of it configuration; click again to expand the block                                                                                                                                                                     |
| <img alt="wsb_icon_up" />      | Move this block one block above its current position on this *worksheet*                                                                                                                                                                                            |
| <img alt="wsb_icon_down" />    | Move this block one block below its current position on this *worksheet*                                                                                                                                                                                            |
| <img alt="wsb_icon_delete" />  | Remove this block from this *worksheet*                                                                                                                                                                                                                             |

If the *SQL Block* contains any queries, the result set of the final one can be
displayed at the bottom of the *SQL Block* in either a grid view (on the
**Data** tab) or as a chart (on the
**Visualization** tab).

#### Data Tab

The **Data** tab displays a grid view of the result set of the
final query in a *SQL Block*, when run.

<Frame>
  <img alt="../../images/wb.explore_wsb_sql_data.png" />
</Frame>

**Data** tab actions include:

* **Export CSV** - export the result set to a comma-separated
  values (CSV) file and download the file
* **Clear** - remove the result set portion of the *SQL Block*

#### Visualization Tab

The **Visualization** tab allows the result set of the final
query in a *SQL Block* to be displayed as a visualization, when run.

<Frame>
  <img alt="../../images/wb.explore_wsb_sql_vis.png" />
</Frame>

Several visualization types are available:

* Bar Chart
* Line Chart
* Pie Chart
* Scatter Plot
* Big Number
* Graph
* Map

After selecting a visualization type, two actions are available:

| Action       | Description                                                                                                                             |
| ------------ | --------------------------------------------------------------------------------------------------------------------------------------- |
| **Save PNG** | For most visualizations, save the visualization to a PNG file                                                                           |
| **Config**   | Configure the selected visualization with options that are specific to the type selected; click **Update** to display the visualization |
| **X**        | Delete the current visualization and select from the available types again                                                              |

<a />

<a />

### Text Blocks

A *Text Block* can be used to document the surrounding blocks.

<Frame>
  <img alt="../../images/wb.explore_wsb_text.png" />
</Frame>

Some formatting and other actions are available:

| Action                        | Description                                                                                     |
| ----------------------------- | ----------------------------------------------------------------------------------------------- |
| <img alt="wsb_icon_bold" />   | Apply bold styling to the highlighted text                                                      |
| <img alt="wsb_icon_ital" />   | Apply italics styling to the highlighted text                                                   |
| <img alt="wsb_icon_ul" />     | Underline the highlighted text                                                                  |
| <img alt="wsb_icon_eye" />    | Hide or show this block when the enclosing *workbook* is embedded in another web page           |
| <img alt="wsb_icon_add" />    | Add a new block of the selected type below this one                                             |
| <img alt="wsb_icon_shrink" /> | Collapse this block, showing only one line of it configuration; click again to expand the block |
| <img alt="wsb_icon_up" />     | Move this block one block above its current position on this *worksheet*                        |
| <img alt="wsb_icon_down" />   | Move this block one block below its current position on this *worksheet*                        |
| <img alt="wsb_icon_delete" /> | Remove this block from this *worksheet*                                                         |

<a />

<a />

### Image Blocks

An *Image Block* can be used to display a static or animated URL-accessible
image.

<Frame>
  <img alt="../../images/wb.explore_wsb_image.png" />
</Frame>

Available actions include:

| Action                        | Description                                                                                     |
| ----------------------------- | ----------------------------------------------------------------------------------------------- |
| <img alt="wsb_icon_cfg" />    | Open the image configuration page                                                               |
| <img alt="wsb_icon_eye" />    | Hide or show this block when the enclosing *workbook* is embedded in another web page           |
| <img alt="wsb_icon_add" />    | Add a new block of the selected type below this one                                             |
| <img alt="wsb_icon_shrink" /> | Collapse this block, showing only one line of it configuration; click again to expand the block |
| <img alt="wsb_icon_up" />     | Move this block one block above its current position on this *worksheet*                        |
| <img alt="wsb_icon_down" />   | Move this block one block below its current position on this *worksheet*                        |
| <img alt="wsb_icon_delete" /> | Remove this block from this *worksheet*                                                         |

#### Image Configuration

The *Image Configuration* page allows the associated image to be configured.

The image needs to be specified with an accessible URL and alignment within the
block.  It can optionally be given a title and a scaling height & width.

<a />

<a />

### HTML Blocks

An *HTML Block* can be used to display user-entered HTML.

<Frame>
  <img alt="../../images/wb.explore_wsb_html.png" />
</Frame>

Available actions include:

| Action                        | Description                                                                                     |
| ----------------------------- | ----------------------------------------------------------------------------------------------- |
| <img alt="wsb_icon_cfg" />    | Open the HTML configuration page                                                                |
| <img alt="wsb_icon_eye" />    | Hide or show this block when the enclosing *workbook* is embedded in another web page           |
| <img alt="wsb_icon_add" />    | Add a new block of the selected type below this one                                             |
| <img alt="wsb_icon_shrink" /> | Collapse this block, showing only one line of it configuration; click again to expand the block |
| <img alt="wsb_icon_up" />     | Move this block one block above its current position on this *worksheet*                        |
| <img alt="wsb_icon_down" />   | Move this block one block below its current position on this *worksheet*                        |
| <img alt="wsb_icon_delete" /> | Remove this block from this *worksheet*                                                         |

#### HTML Configuration

The *HTML Configuration* page allows the HTML source and title to be modified.

HTML tags that may pose security risks will remain in the user-entered source,
but not be displayed in the *HTML Block*.

HTML tags are not supported for the title.

<a />

<a />

### Map Blocks

A *Map Block* is an empty zoomable & pannable world map, upon creation, that can
be configured to display geospatial data from any table or view.

<Frame>
  <img alt="../../images/wb.explore_wsb_map.png" />
</Frame>

Available actions include:

| Action                        | Description                                                                                     |
| ----------------------------- | ----------------------------------------------------------------------------------------------- |
| <img alt="wsb_icon_ref" />    | Refresh the map, reloading any data from the source, if configured                              |
| <img alt="wsb_icon_dl" />     | Download a copy of this map at its current zoom level and pan position                          |
| <img alt="wsb_icon_cfg" />    | Configure a source table to plot on this map, as well as other map-related settings             |
| <img alt="wsb_icon_eye" />    | Hide or show this block when the enclosing *workbook* is embedded in another web page           |
| <img alt="wsb_icon_full" />   | Pop up a near full-screen configurable view of this map                                         |
| <img alt="wsb_icon_add" />    | Add a new block of the selected type below this one                                             |
| <img alt="wsb_icon_shrink" /> | Collapse this block, showing only one line of it configuration; click again to expand the block |
| <img alt="wsb_icon_up" />     | Move this block one block above its current position on this *worksheet*                        |
| <img alt="wsb_icon_down" />   | Move this block one block below its current position on this *worksheet*                        |
| <img alt="wsb_icon_delete" /> | Remove this block from this *worksheet*                                                         |

#### Rendering Modes

*Kinetica* supports two different geospatial rendering modes:

* [Heatmap](/content/api/rest/wms_rest#wms-heatmap):  A gradient of color that represents the
  density of features/shapes
* [Raster](/content/api/rest/wms_rest#wms-raster):  Discrete colorization of each
  feature/shape
* [Class Break](/content/api/rest/wms_rest#wms-cbraster):  A class (range) based
  colorization of each feature/shape
* [Track](/content/api/rest/wms_rest#wms-raster):  A rasterization of features/shapes
  containing track information
* [Contour](/content/api/rest/wms_rest#wms-contour):  A 3-dimensional planar graph, where
  each plane is bounded by isolines and contains data with the same *z* value

There are several categories of options to configure for each map:

* *Table Options* - Source table & columns, along with the rendering mode
* *Map-Specific Options* - Options that are specific to each map type
* *Viewport Options* - Latitude, longitude, & altitude upon which the map is
  centered
* *Advanced Options* - WMS key/value pairs that can be set to override or extend
  the map configuration.
  See [Web Map Service](/content/api/rest/wms_rest) for details.

Here is an example of some of the map configuration options that you have to
style the output of geospatial data on a map, followed by a sample map.

<Frame>
  <img alt="../../images/wb.workbook_vis_map_config.png" />
</Frame>

<Frame>
  <img alt="../../images/wb.workbook_vis_map.png" />
</Frame>

<a />

<a />

### Graph Blocks

A *Graph Block* is a visual
[graph](/content/graph_solver/network_graph_solver) of a given
graph-oriented data set.

<Frame>
  <img alt="../../images/wb.explore_wsb_graph.png" />
</Frame>

Available actions include:

| Action                        | Description                                                                                     |
| ----------------------------- | ----------------------------------------------------------------------------------------------- |
| <img alt="wsb_icon_ref" />    | Refresh the graph, reloading any data from the source                                           |
| <img alt="wsb_icon_cfg" />    | Open the graph configuration page                                                               |
| <img alt="wsb_icon_eye" />    | Hide or show this block when the enclosing *workbook* is embedded in another web page           |
| <img alt="wsb_icon_add" />    | Add a new block of the selected type below this one                                             |
| <img alt="wsb_icon_shrink" /> | Collapse this block, showing only one line of it configuration; click again to expand the block |
| <img alt="wsb_icon_up" />     | Move this block one block above its current position on this *worksheet*                        |
| <img alt="wsb_icon_down" />   | Move this block one block below its current position on this *worksheet*                        |
| <img alt="wsb_icon_delete" /> | Remove this block from this *worksheet*                                                         |

#### Graph Configuration

The *Graph Configuration* page allows the graph source data set to be specified
and modified.

<Frame>
  <img alt="../../images/wb.explore_wsb_graph_config.png" />
</Frame>

The most straightforward way to configure a graph is to create a graph via SQL,
and then configure the graph to use the output table of the graph creation.

For an example of configuring a *Graph Block*, see [Graph Blocks](/content/admin/workbench/workbooks#wb-graph-block).


# Data Explorer
Source: https://docs.kinetica.com/content/admin/workbench/ui/explorer/data



The *Data Explorer* can be used to manage most object types.

<Frame>
  <img alt="../../../images/wb.explorer_data.png" />
</Frame>

To access the *Data Explorer*, in [Workbench](/content/admin/workbench),
click the **Data** tab of the left-hand navigation pane.

## General Features

At the top of the *Data Explorer* tab are actions not tied to a specific object
type:

* Search box - filters displayed objects across all three domains, by keyword
* Refresh icon - refreshes the list of displayed objects
* **+** icon - adds a new data object

<a />

## Tables & Views

This section of the *Data Explorer* shows the list of accessible
[schemas](/content/sql/ddl/create-schema#sql-create-schema) at the top level, and beneath each,
the set of accessible [tables](/content/sql/ddl/create-table#sql-create-table) and
[views](/content/sql/ddl/create-view#sql-create-view).

Clicking the **+** next to this section's header will open the
context menu, allowing any of the following objects to be created, via wizard:

* [Schema](/content/sql/ddl/create-schema#sql-create-schema)
* [Table](/content/sql/ddl/create-table#sql-create-table)
* [External Table](/content/sql/ddl/create-external-table#sql-create-ext-table)

### Schema Services

Clicking on a schema will open a context menu with the following options:

* **Add New Table** - create a table under this schema
* **Rename** - rename this schema
* **Delete** - delete this schema and all tables & views within

### Table/View Services

Clicking on a table or view will open up a menu with these options:

* **Info** - display general information about this object and
  its composition

* **Data Preview** - display a grid-style view of this object's
  data

* **WMS Preview** - display a map-style view of this object, if
  it contains geospatial data

  * Click **Config** to modify the settings of the map
  * Click **Update** to view the map
  * Click **Save PNG** to save a local copy of the rendered
    map
  * Click the refresh icon to update the data on the map

* **Configure** -
  [modify](/content/admin/workbench/ui/explorer/data#wb-explorer-data-tv-config) the structure of and access
  to this object

* **Add Record** - add a single record to this table

* **Export File** - exports the table to
  [KiFS](/content/admin/workbench/ui/explorer/files)

* **SQL DDL** - display the SQL `CREATE` statement used to
  construct this object

* **Statistics** - generate a per-column statistical analysis of
  this object

* **Refresh** - refresh the data in a
  [materialized view](/content/sql/ddl/create-materialized-view#sql-create-materialized-view) or
  [external table](/content/sql/ddl/create-external-table#sql-create-ext-table)

* **Rename** - rename this object

* **Move** - move this object to a different schema

* **Delete** - delete this object permanently

* **Multi-Select** - turn on multi-select mode, which allows
  multiple objects to be selected (by checking the boxes in front of them) and
  then deleted by clicking **Delete Selected**; click
  **Cancel** to turn off multi-select mode

<a />

#### Configuring a Table/View

A table can be configured upon creation and subsequently modified, from the
[Data Explorer](/content/admin/workbench/ui/explorer/data) in [Workbench](/content/admin/workbench), including
setting
[column-level security](/content/security/sec_concepts#sec-concepts-perm-table-col) on the table.

Both creating and modifying a table go through the same two steps.  In the first
step the following can be modified:

* **Schema** - name of the schema to put this table in (only
  available for new tables)
* **Name** - new name for the table (must meet
  [table naming criteria](/content/concepts/tables#table-naming-criteria))
* Via the **Advanced** button, the following can be viewed:

  * **Chunk Size** - the designated number of records per block
    of allocated memory for this table
  * **Dimension Table** - whether or not this table is
    [replicated](/content/concepts/tables#replicated), as dimension tables in a star or
    snowflake schema will usually be
  * **Temporary Table** - whether or not this table will be
    removed upon cluster restart
  * **Time To Live** - the [TTL](/content/concepts/ttl)
    (expiration time, in minutes) for the table; leave blank for permanent table
  * **Foreign Keys** - one or more
    [foreign key](/content/concepts/tables#foreign-key) definitions, of the form:
    ```sql theme={null}
    (<column list>) REFERENCES <foreign table name>(<foreign column list>) [AS <foreign key name>] [,...]
    ```
  * **Foreign Shard Key** - one or more *foreign shard key*
    definitions
  * **Partitioning** - optional
    [partition](/content/concepts/tables#partitioning) definition:

    * **Type** - type of *partitioning* scheme to use
    * **Keys** - column(s) and/or column expression(s) that will
      be used to determine the designated *partition* for each record
    * **Definitions** - type-specific definitions for the set of
      *partitions* or the *partition* creation scheme

Clicking **Next** will bring up the second step, where the table
structure and
column
security are defined.

* **+ Add Column** - add a new column to the end of the table,
  where the following are specified:

  * **Name** - name of this column (must meet
    [column naming criteria](/content/concepts/tables#table-naming-criteria))
  * **Type** - [data type](/content/concepts/types#types-chart) of this
    column
  * **Nullable** - whether this column can accept null values
  * **Primary Key** - optionally designate this column as a
    [primary key](/content/concepts/tables#primary-key) or a member of a
    *composite primary key*
  * **Shard Key** - optionally designate this column as a
    [shard key](/content/concepts/tables#shard-key) or a member of a
    *composite shard key*
  * **Dictionary Encode** - whether to apply
    [dictionary encoding](/content/concepts/dictionary_encoding) to this
    column
    [full-text searchable](/content/concepts/full_text_search)
  * **Init with Now** - whether this column's value should be
    initialized to the current date/time if blank when inserted
  * **Init with UUID** - whether this column's value should be
    initialized to a *universally unique identifier* (UUID) if blank when
    inserted
  * **Text Search** - whether this column should be
  * <img alt="tv_icon_colsec" /> - set
    [column-level security](/content/admin/workbench/ui/explorer/data#wb-explorer-data-tv-config-cls) on
    this column for users/roles
  * <img alt="tv_icon_delete" /> - remove this column from the table

<a />

<p><strong>Column-Level Security</strong></p>

When the *Column Permissions* <img alt="tv_icon_colsec" /> is clicked for a column on the
table create/edit *Column Definitions* page, the
**Column Permissions** pop-up will appear.

Click the name of a user or role on the left pane to show the corresponding
*column-level permissions* that user/role has on this table in the right pane,
and configure them:

* **Enabled** - toggle whether *column-level permissions* on this
  table's column are active for the selected user/role; this will grant the
  selected user access to this column's data
* **Filter** - enter the filter expression that should be used to
  define the records in this column the selected user **can** access;
  effectively adding *row-level security* to this column
* **Transform Type** - optionally, character-based column values
  can have one of two transform functions applied in order to conceal the true
  values from the user/role to whom the access is granted:

  * **Obfuscate** - conceal text values by converting them to
    "random" whole numbers, where all occurrences of a given text value will
    convert to the same number
  * **Mask** - conceal text values by replacing one or more
    sequential characters in the text value with a single "masking" character:

    * **Start Position** - the 1-based position of the first
      character to mask
    * **# of Masked Characters** - the number of characters after
      (and including) the first one to replace with the masking character
    * **Mask Character** - the character used to replace column
      value characters

Click **OK** once all *column-level security* modifications have
been made.

See [Column-Level Security](/content/security/sec_concepts#sec-concepts-perm-table-col) for details.

<a />

## Data Sources

This section of the *Data Explorer* shows the list of accessible
[data sources](/content/sql/ddl/create-data-source#sql-create-data-source).

Clicking the **+** next to this section's header will open the
**Create Data Source** wizard.  Provide a name, source
provider/service, and the relevant connection information, and then click
**Create** to create the data source.

Clicking on a data source will open a context menu with the following options:

* **Configure** - modify this data source's reference to its
  external source
* **Import** - opens the [Import](/content/admin/workbench/ui/import) tool
  specific to this data source
* **History** - displays the history of load commands issued
  through this data source
* **Delete** - delete this data source, provided it is unused by
  any other objects
* **Multi-Select** - turn on multi-select mode, which allows
  multiple objects to be selected (by checking the boxes in front of them) and
  then deleted by clicking **Delete Selected**; click
  **Cancel** to turn off multi-select mode

<a />

## Data Sinks

This section of the *Data Explorer* shows the list of accessible
[data sinks](/content/sql/ddl/create-data-sink#sql-create-data-sink).

Clicking the **+** next to this section's header will open the
**Create Data Sink** wizard.  Provide a name, target
provider/service, and the relevant connection information, and then click
**Create** to create the data sink.

Clicking on a data sink will open a context menu with the following options:

* **Configure** - modify this data sink's reference to its
  external target
* **Stream** - opens the **Create Stream** wizard
  using this data sink as its target
* **Delete** - delete this data sink, provided it is unused by
  any other objects
* **Multi-Select** - turn on multi-select mode, which allows
  multiple objects to be selected (by checking the boxes in front of them) and
  then deleted by clicking **Delete Selected**; click
  **Cancel** to turn off multi-select mode

<a />

## Streams

This section of the *Data Explorer* shows the list of accessible
[streams](/content/sql/ddl/create-stream#sql-create-stream).

Clicking the **+** next to this section's header will open the
**Create Stream** wizard.  Provide a name, target data sink,
source object and streaming configuration, and then click
**Create** to create the stream.

Clicking on a stream will open a context menu with the following options:

* **Info** - view this stream's configuration
* **Delete** - delete this stream
* **Multi-Select** - turn on multi-select mode, which allows
  multiple objects to be selected (by checking the boxes in front of them) and
  then deleted by clicking **Delete Selected**; click
  **Cancel** to turn off multi-select mode

<a />

## Graphs

This section of the *Data Explorer* shows the list of accessible
[graphs](/content/sql/graph#sql-graph-create).

Clicking the **+** next to this section's header will open the
**Create Graph** wizard.

Select whether to create a graph manually from an existing table or to create a
graph as an extract from the *OpenStreetMap (OSM)* dataset.

* For a manual graph:

  * On the **Configure** page, provide a name, directedness, and
    graph structure options.  Click the drop-down next to
    **Nodes**, **Edges**,
    **Weights**, and/or **Restrictions** to select
    the [identifier combination](/content/graph_solver/network_graph_solver#id-combos) to use for this
    component of the graph and click **+ Add** to use it.  Then
    enter the source database columns (or constants) to use for each
    [identifier](/content/graph_solver/network_graph_solver#identifiers) listed.  Click the trash can icon to
    remove the selected identifier combination.

    To proceed, click:

    * **Next** to continue to the **Options** page
    * **Change Mode** to return to the mode selection page
    * **Cancel** to not create the graph

  * On the **Options** page, specify any additional parameters that
    will define the graph.

    To proceed, click:

    * **Create Graph** to finish and create the graph
    * **Back** to return to the **Configure** page
    * **Change Mode** to return to the mode selection page
    * **Cancel** to not create the graph

* For an OSM extract:

  * Provide a name for the graph and select a region on the map from which the
    graph will be created.  Use the controls within the map widget to zoom and
    pan to the region of interest.  Note that the default data set provided is
    the United States road network.

    To proceed, click:

    * **Create Graph** to finish and create the graph
    * **Change Mode** to return to the mode selection page
    * **Cancel** to not create the graph

Clicking on a graph will open up a menu with these options:

* **Info** - display general information about this graph and its
  composition
* **Preview** - display a map-style view of this graph, if it
  contains geospatial data
* **Delete** - delete this graph
* **Multi-Select** - turn on multi-select mode, which allows
  multiple objects to be selected (by checking the boxes in front of them) and
  then deleted by clicking **Delete Selected**; click
  **Cancel** to turn off multi-select mode

<a />

## Context

This section of the *Data Explorer* shows the list of accessible
[contexts](/content/sql/sqlgpt#sql-gpt-create-context).

Clicking on a *context* will open a context menu with the following options:

* **Info** - view this *context's* configuration
* **Delete** - delete this *context*
* **Multi-Select** - turn on multi-select mode, which allows
  multiple objects to be selected (by checking the boxes in front of them) and
  then deleted by clicking **Delete Selected**; click
  **Cancel** to turn off multi-select mode

<a />

## Function Environments

This section of the *Data Explorer* shows the list of accessible
[Python UDF function environments](/content/udf/python/writing#udf-python-func-env).

Clicking the **+** next to this section's header will open the
**Create Function Environment** wizard, allowing an environment
to be created containing user-specified Python packages & versions.

Clicking on a *function environment* will open a context menu with the
following options:

* **Configure** - modify this *function environment*

  On the **Configure Function Environment** pop-up:

  * In the text input, enter one or more names & versions of packages to install
    and click **Install Package(s)** to install them
  * Click the delete icon to the right of any non-default package to uninstall

* **Delete** - delete this *context*

* **Multi-Select** - turn on multi-select mode, which allows
  multiple objects to be selected (by checking the boxes in front of them) and
  then deleted by clicking **Delete Selected**; click
  **Cancel** to turn off multi-select mode


# File Explorer
Source: https://docs.kinetica.com/content/admin/workbench/ui/explorer/files



The *File Explorer* can be used to manage
[directories](/content/tools/kifs_api#kifs-directory) & [files](/content/tools/kifs_api#kifs-file)
in [Kinetica File System (KiFS)](/content/tools/kifs).

<Frame>
  <img alt="../../../images/wb.explorer_files.png" />
</Frame>

To access the *File Explorer*, in [Workbench](/content/admin/workbench),
click the **Files** tab of the left-hand navigation pane.

## General Features

At the top of the *File Explorer* tab are several file/directory actions:

* Search box - filter displayed files & directories, by name; directory matches
  will result in all files in that directory being displayed
* Refresh icon - refresh the list of displayed files & directories
* **+** icon - create a new directory or upload a file

## File List

The *File Explorer* displays a list of top-level directories and the set of
files contained within them.  Each file is shown with its relative path to its
containing directory and its total size on disk.  Each directory shows the
cumulative size of all files contained within it.

Clicking on a directory will open a context menu with the following options:

* **Upload New File** - upload a file into this directory
* **Import** - open up the import wizard for this directory
* **Delete** - delete this directory and any files contained
  within it

Clicking on a file will open a context menu with the following options:

* **Download** - download a local copy of this file
* **Import** - open up the file import wizard for this file
* **Delete** - delete this file from *KiFS*
* **Multi-Select** - turn on multi-select mode and select this
  file, allowing for the deletion of multiple files at once


# Workbench Explorer
Source: https://docs.kinetica.com/content/admin/workbench/ui/explorer/index



The *Workbench Explorer* is situated in the left-hand pane of *Kinetica's*
[Workbench](/content/admin/workbench) administration application.  It
provides the following object-centric explorer views:

* [Data Explorer](/content/admin/workbench/ui/explorer/data)
* [Workbook Explorer](/content/admin/workbench/ui/explorer/workbooks)
* [File Explorer](/content/admin/workbench/ui/explorer/files)

<Frame>
  <img alt="../../images/wb.explorer_data.png" />
</Frame>

The *Workbench Explorer* is always available in the left-hand pane, though it
can be collapsed by clicking the left-facing arrow at the top of the pane.


# Workbook Explorer
Source: https://docs.kinetica.com/content/admin/workbench/ui/explorer/workbooks



The *Workbook Explorer* can be used to manage *Workbooks*.

<Frame>
  <img alt="../../../images/wb.explorer_workbooks.png" />
</Frame>

To access the *Workbook Explorer*, in
[Workbench](/content/admin/workbench), click the
**Workbooks** tab of the left-hand navigation pane.

## General Features

At the top of the *Workbook Explorer* tab are several workbook actions:

* Search box - filters displayed workbooks, by name
* Refresh icon - refreshes the list of displayed workbooks
* **+** icon - adds a new workbook

## Workbook Lists

The *Workbook Explorer* has two lists of workbooks:

* **My Workbooks** - workbooks created by the current user
* **Examples** - workbooks that are provided with *Workbench* for
  exploring the various features of *Kinetica*
* **Shared With Me** - workbooks shared with the current user

Clicking on the name of any workbook will open it in the right-hand pane.  If a
workbook is open in the right-hand pane, is will be marked
**Open** in the *Workbook Explorer*.


# Home
Source: https://docs.kinetica.com/content/admin/workbench/ui/home



*Home* serves as the landing page for
[Workbench](/content/admin/workbench).

<Frame>
  <img alt="../../images/wb.home.png" />
</Frame>

This landing page can be reached at any time by clicking on the
**Home** menu item at the top.  This will open several options in
the right-hand pane, including:

* **Getting Started** - links to various tutorials
  native API reference, and native API downloads
* **Import** - links to the import & external table
  wizards, as well as to the various data source specific import wizards
* **Connect** - sample code blocks for connecting to
  *Kinetica* with the various native API languages and JDBC
* **Resources** - links to video tutorials


# Azure Blob Storage Import
Source: https://docs.kinetica.com/content/admin/workbench/ui/import/azure



Using the *Azure Blob Storage Import* wizard, files located in
*Azure Blob Storage* can be imported into *Kinetica*.

To import a file from *Azure Blob Storage* into *Kinetica*, click on the
**Azure Blob Storage** panel on the [Import](/content/admin/workbench/ui/import)
landing page in [Workbench](/content/admin/workbench).

The **Azure Blob Storage Import** wizard appears in the
right-hand pane.

<img alt="../../../images/wb.import_azure.png" />

The wizard has two tabs:

* **Import** - contains the 5-step process for importing files
  from *Azure Blob Storage*
* **History** - lists all of your previous *Azure Blob Storage*
  import attempts

## Import Overview

When importing, the following five steps will need to be completed:

* [Setup](#setup)
* [Source](#source)
* [Destination](#destination)
* [Configure](#configure)
* [Summary](#summary)

At any step, the following actions are available at the bottom of the screen:

* **Next** - proceed to the next step
* **Back** - return to the previous step
* **Cancel** - exit the import process
* **Import** - once enough information has been specified to
  begin importing data, the **Import** button will become active

<a />

## Setup

In this step, the [data source](/content/sql/ddl/create-data-source#sql-create-data-source) used to
connect to *Azure Blob Storage* is selected.

* **Create New Data Source** - click to create a new
  *data source* that connects to *Azure Blob Storage*, then enter its
  configuration and click **Create** to create the *data source*
  and proceed to the **Source** selection page:

  * **Name** - enter a unique name for the *data source*
  * **Container Name** - enter the name of the
    *Azure Blob Storage* container to use
  * **Auth Type** - select an authorization scheme; this will
    prompt with the appropriate fields for the scheme selected

* **Select Existing Data Source** - click to select an existing
  *data source* that connects to *Azure Blob Storage* and then click
  **Next** to proceed to the **Source** selection
  page:

  * **Data Source** - click to open a drop-down of available
    *data sources* that connect to *Azure Blob Storage* and select one

<a />

## Source

In this step, the source file is selected and the parser configured for the
file, if necessary.

* **Source** - pre-selected as the name of the *data source*
  chosen in the previous step
* **File Path** - enter the path to the file located within
  *Azure Blob Storage*; click **Browse Files** to pop up the
  remote file browsing interface and make a selection from the available files,
  and click the `X` in the top corner when done selecting files
* **Format** - select the format of the file from the drop-down

If the source data is in a delimited text file, options for parsing the file can
be specified (see [Delimited Text Options](/content/sql/load#sql-load-file-server-delim-opt) for details):

* **Delimiter** - select the character that delimits field values
  in the source file:

  * `|` - default delimiter for <Badge>.psv</Badge> (pipe-separated value)
    files
  * `\t` - (tab) default delimiter for <Badge>.tsv</Badge>
    (tab-separated value) files
  * `,` - default delimiter for <Badge>.csv</Badge> (comma-separated value)
    files and all other types of text files

* **Escape Character** - select the character used to escape
  special characters (like the field delimiter) found within field values; e.g.,
  a `\` might be used to escape commas within field values in a
  <Badge>.csv</Badge> file

* **Comment Identifier** - select the character(s) with which
  comment lines within the source file begin

* **Quote Character** - select the character used to quote field
  values; e.g., a `"` might be used to quote field values containing commas in
  a <Badge>.csv</Badge> file

* **Null Identifier** - select the character(s) used to identify
  *null* field values

* **Has Header** - check the box if the source file contains a
  header row at the top

Once the source file and parameters have been selected, click
**Next** to proceed to the **Destination**
selection page.

<a />

## Destination

In this step, the target table to import into is selected.

* **Schema** - name of the schema containing the target table;
  if blank, the user's [default schema](/content/concepts/schemas#schema-default) will be
  used
* **Table** - name of the target table, which must meet
  [table naming criteria](/content/concepts/tables#table-naming-criteria); *Workbench* will
  suggest a table name here, if possible
* **Batch Size** - number of records from the source to
  insert into the database at a time; this can be used to tune the ingest speed
  for source data with many records or wide columns
* **Abort on Error** - check, to have the import stop at the
  first record import failure; any records imported by this point will remain in
  the target table
* **Bad Records Table** - when **Abort on Error**
  is unchecked, the errant records will be written to the specified table

  * **Schema** - schema in which the bad records table should
    reside
  * **Table** - name for the bad records table

Once the destination has been specified, click **Next** to
proceed to the **Configure** page.

<a />

## Configure

In this step, the target table's structure can be specified, if the table does
not exist.  Not specifying any structure will cause the import process to infer
the table's structure from the source data.

To specify a table structure, click **+ Add Column** once for
each field in the source data, then enter the specification for each column,
including:

* **Name** - name of the column, which must meet the standard
  [naming criteria](/content/concepts/tables#table-naming-criteria)
* **Type** - type of the column, and sub-type, if applicable
* **Nullable** - check the box if the column should allow *null*
  values
* **Properties** - check any properties that should apply to this
  column:

  * **Primary Key** - make this column the
    [primary key](/content/concepts/tables#primary-key) or part of a
    *composite primary key*
  * **Shard Key** - make this column the
    [shard key](/content/concepts/tables#shard-key) or part of a
    *composite shard key*
  * **Dict. Encoded** - apply
    [dictionary encoding](/content/concepts/dictionary_encoding) to the
    column's values, reducing storage used for columns with more often repeated
    data
  * **Init. with Now** - replace empty or invalid values inserted
    into this column with the current date/time
  * **Init. with UUID** - replace empty values inserted into this
    column with a universally unique identifier (UUID)
  * **Text Search** - make this column
    [full-text searchable](/content/concepts/full_text_search), using
    [FILTER\_BY\_STRING](/content/sql/query/string-functions#sql-string-functions-fts) in *search* mode

To remove a column from the proposed target table, click the trash can icon at
the far right of the column's definition.

Once the table configuration has been established, click **Next**
to proceed to the **Summary** page.

<a />

## Summary

In this step, the import configuration will be displayed.

All **Source**, **Destination**, &
**Error Handling** configuration will be displayed in their
respective sections.

The **Generated SQL** section will contain the SQL
[LOAD INTO](/content/sql/load#sql-load-into) command corresponding to the import
operation that will take place.  The copy-to-clipboard icon can be used to copy
the SQL statement for subsequent use, to re-import data from the same file into
the same table.

Once the import configuration has been confirmed, click
**Import** to import the file's data.


# HDFS Import
Source: https://docs.kinetica.com/content/admin/workbench/ui/import/hdfs



Using the *HDFS Import* wizard, files located in *HDFS* can be imported into
*Kinetica*.

To import a file from *HDFS* into *Kinetica*, click on the
**HDFS** panel on the [Import](/content/admin/workbench/ui/import) landing page in
[Workbench](/content/admin/workbench).

The **HDFS Import** wizard appears in the right-hand pane.

<img alt="../../../images/wb.import_hdfs.png" />

The wizard has two tabs:

* **Import** - contains the 5-step process for importing files
  from *HDFS*
* **History** - lists all of your previous *HDFS* import attempts

## Import Overview

When importing, the following five steps will need to be completed:

* [Setup](#setup)
* [Source](#source)
* [Destination](#destination)
* [Configure](#configure)
* [Summary](#summary)

At any step, the following actions are available at the bottom of the screen:

* **Next** - proceed to the next step
* **Back** - return to the previous step
* **Cancel** - exit the import process
* **Import** - once enough information has been specified to
  begin importing data, the **Import** button will become active

<a />

## Setup

In this step, the [data source](/content/sql/ddl/create-data-source#sql-create-data-source) used to
connect to *HDFS* is selected.

* **Create New Data Source** - click to create a new
  *data source* that connects to *HDFS*, then enter its configuration and click
  **Create** to create the *data source* and proceed to the
  **Source** selection page:

  * **Name** - enter a unique name for the *data source*
  * **URL** - enter the host & port of the *HDFS* service
    to use
  * **Auth Type** - select an authorization scheme; this will
    prompt with the appropriate fields for the scheme selected

* **Select Existing Data Source** - click to select an existing
  *data source* that connects to *HDFS* and then click
  **Next** to proceed to the **Source** selection
  page:

  * **Data Source** - click to open a drop-down of available
    *data sources* that connect to *HDFS* and select one

<a />

## Source

In this step, the source file is selected and the parser configured for the
file, if necessary.

* **Source** - pre-selected as the name of the *data source*
  chosen in the previous step
* **File Path** - enter the path to the file located within
  *HDFS*
* **Format** - select the format of the file from the drop-down

If the source data is in a delimited text file, options for parsing the file can
be specified (see [Delimited Text Options](/content/sql/load#sql-load-file-server-delim-opt) for details):

* **Delimiter** - select the character that delimits field values
  in the source file:

  * `|` - default delimiter for <Badge>.psv</Badge> (pipe-separated value)
    files
  * `\t` - (tab) default delimiter for <Badge>.tsv</Badge>
    (tab-separated value) files
  * `,` - default delimiter for <Badge>.csv</Badge> (comma-separated value)
    files and all other types of text files

* **Escape Character** - select the character used to escape
  special characters (like the field delimiter) found within field values; e.g.,
  a `\` might be used to escape commas within field values in a
  <Badge>.csv</Badge> file

* **Comment Identifier** - select the character(s) with which
  comment lines within the source file begin

* **Quote Character** - select the character used to quote field
  values; e.g., a `"` might be used to quote field values containing commas in
  a <Badge>.csv</Badge> file

* **Null Identifier** - select the character(s) used to identify
  *null* field values

* **Has Header** - check the box if the source file contains a
  header row at the top

Once the source file and parameters have been selected, click
**Next** to proceed to the **Destination**
selection page.

<a />

## Destination

In this step, the target table to import into is selected.

* **Schema** - name of the schema containing the target table;
  if blank, the user's [default schema](/content/concepts/schemas#schema-default) will be
  used
* **Table** - name of the target table, which must meet
  [table naming criteria](/content/concepts/tables#table-naming-criteria); *Workbench* will
  suggest a table name here, if possible
* **Batch Size** - number of records from the source to
  insert into the database at a time; this can be used to tune the ingest speed
  for source data with many records or wide columns
* **Abort on Error** - check, to have the import stop at the
  first record import failure; any records imported by this point will remain in
  the target table
* **Bad Records Table** - when **Abort on Error**
  is unchecked, the errant records will be written to the specified table

  * **Schema** - schema in which the bad records table should
    reside
  * **Table** - name for the bad records table

Once the destination has been specified, click **Next** to
proceed to the **Configure** page.

<a />

## Configure

In this step, the target table's structure can be specified, if the table does
not exist.  Not specifying any structure will cause the import process to infer
the table's structure from the source data.

To specify a table structure, click **+ Add Column** once for
each field in the source data, then enter the specification for each column,
including:

* **Name** - name of the column, which must meet the standard
  [naming criteria](/content/concepts/tables#table-naming-criteria)
* **Type** - type of the column, and sub-type, if applicable
* **Nullable** - check the box if the column should allow *null*
  values
* **Properties** - check any properties that should apply to this
  column:

  * **Primary Key** - make this column the
    [primary key](/content/concepts/tables#primary-key) or part of a
    *composite primary key*
  * **Shard Key** - make this column the
    [shard key](/content/concepts/tables#shard-key) or part of a
    *composite shard key*
  * **Dict. Encoded** - apply
    [dictionary encoding](/content/concepts/dictionary_encoding) to the
    column's values, reducing storage used for columns with more often repeated
    data
  * **Init. with Now** - replace empty or invalid values inserted
    into this column with the current date/time
  * **Init. with UUID** - replace empty values inserted into this
    column with a universally unique identifier (UUID)
  * **Text Search** - make this column
    [full-text searchable](/content/concepts/full_text_search), using
    [FILTER\_BY\_STRING](/content/sql/query/string-functions#sql-string-functions-fts) in *search* mode

To remove a column from the proposed target table, click the trash can icon at
the far right of the column's definition.

Once the table configuration has been established, click **Next**
to proceed to the **Summary** page.

<a />

## Summary

In this step, the import configuration will be displayed.

All **Source**, **Destination**, &
**Error Handling** configuration will be displayed in their
respective sections.

The **Generated SQL** section will contain the SQL
[LOAD INTO](/content/sql/load#sql-load-into) command corresponding to the import
operation that will take place.  The copy-to-clipboard icon can be used to copy
the SQL statement for subsequent use, to re-import data from the same file into
the same table.

Once the import configuration has been confirmed, click
**Import** to import the file's data.


# Import
Source: https://docs.kinetica.com/content/admin/workbench/ui/import/index



The *Import* interface is situated in the right-hand pane of *Kinetica's*
[Workbench](/content/admin/workbench) administration application.  It can
be used to import data into the database from a variety of sources.

<Frame>
  <img alt="../../images/wb.import.png" />
</Frame>

To access the *Import* page, in *Workbench*, click the **Import**
menu item.

There are several mechanisms for importing data into *Kinetica*:

* [File Upload Import](/content/admin/workbench/ui/import/upload)
* [Kinetica FileSystem Import](/content/admin/workbench/ui/import/kifs)
* [Azure Blob Storage Import](/content/admin/workbench/ui/import/azure)
* [Amazon S3 Import](/content/admin/workbench/ui/import/s3)
* [Kafka Stream Import](/content/admin/workbench/ui/import/kafka)
* [HDFS Import](/content/admin/workbench/ui/import/hdfs)
* [JDBC Import](/content/admin/workbench/ui/import/jdbc)
* [Kinetica Import](/content/admin/workbench/ui/import/kinetica)
* [JDBC Data Source Import](/content/admin/workbench/ui/import/jdbc_prov)

Clicking on **History** in the top right corner of the *Import*
page will open a dialog box displaying all of your previous imports.


# JDBC Import
Source: https://docs.kinetica.com/content/admin/workbench/ui/import/jdbc



Using the *JDBC Import* wizard, tables located in another database can be
imported into *Kinetica* via *JDBC*.

To import a table from a remote database into *Kinetica*, click on the
**Generic JDBC** panel on the [Import](/content/admin/workbench/ui/import)
landing page in [Workbench](/content/admin/workbench).

The **JDBC Import** wizard appears in the right-hand pane.

<img alt="../../../images/wb.import_jdbc.png" />

The wizard has two tabs:

* **Import** - contains the 5-step process for importing files
  from remote databases using *JDBC*
* **History** - lists all of your previous *JDBC*
  import attempts

## Import Overview

When importing, the following five steps will need to be completed:

* [Setup](#setup)
* [Source](#source)
* [Destination](#destination)
* [Configure](#configure)
* [Summary](#summary)

At any step, the following actions are available at the bottom of the screen:

* **Next** - proceed to the next step
* **Back** - return to the previous step
* **Cancel** - exit the import process
* **Import** - once enough information has been specified to
  begin importing data, the **Import** button will become active

<a />

## Setup

In this step, the [data source](/content/sql/ddl/create-data-source#sql-create-data-source) used to
connect to the remote database is selected.

* **Create New Data Source** - click to create a new
  *data source* that connects to the remote database, then enter its
  configuration and click **Create** to create the *data source*
  and proceed to the **Source** selection page:

  * **Name** - enter a unique name for the *data source*
  * **URL** - enter the JDBC connection string to connect to the
    remote database
  * **Username** - username for logging into the remote database
  * **Password** - password for logging into the remote database
  * **Driver Class** - name of the JDBC driver class to use in
    the specified JDBC driver JAR
  * **JAR Path Type** - select a JAR path specification type to
    use when specifying the **Driver JAR Path**
  * **Driver JAR Path** - specify the file path to the JDBC
    driver JAR file, based on the selected **JAR Path Type**:

    * **Manual** - specify a directory path manually
    * **KiFS** - click the control to open the *KiFS* file
      selector, which shows a list of the *KiFS* directories, and as each is
      clicked, the files contained within that directory; click the JAR
      containing the JDBC driver to use for the connection

* **Select Existing Data Source** - click to select an existing
  *data source* that connects to the remote database and then click
  **Next** to proceed to the **Source** selection
  page:

  * **Data Source** - click to open a drop-down of available
    *data sources* that connect to the remote database and select one

<a />

## Source

In this step, the source table is selected or the source query entered.

* **Source** - pre-selected as the name of the *data source*
  chosen in the previous step
* **Remote Table** - enter the name of the table located within
  the remote database; click **Browse Tables** to pop up the
  remote table browsing interface and make a selection from the available
  tables, and click **Select** next to the table to import
* **Remote Query** - enter a query to run on the remote database;
  click **Verify Remote Query** to ensure the query is able to be
  executed on the remote database
* **Subscription Options** - check the **Enable**
  box to activate a subscription to the remote data

  * **Poll Interval** - the time (in seconds) between successive
    requests to the remote cluster for more data
  * **Increasing Column** - remote table/query column to use to
    determine whether a remote record is new and should be imported; only
    records with a higher value than the highest value from the last poll will
    be imported

<a />

## Destination

In this step, the target table to import into is selected.

* **Schema** - name of the schema containing the target table;
  if blank, the user's [default schema](/content/concepts/schemas#schema-default) will be
  used
* **Table** - name of the target table, which must meet
  [table naming criteria](/content/concepts/tables#table-naming-criteria); *Workbench* will
  suggest a table name here, if possible
* **Batch Size** - number of records from the source to
  insert into the database at a time; this can be used to tune the ingest speed
  for source data with many records or wide columns
* **Abort on Error** - check, to have the import stop at the
  first record import failure; any records imported by this point will remain in
  the target table
* **Bad Records Table** - when **Abort on Error**
  is unchecked, the errant records will be written to the specified table

  * **Schema** - schema in which the bad records table should
    reside
  * **Table** - name for the bad records table

Once the destination has been specified, click **Next** to
proceed to the **Configure** page.

<a />

## Configure

In this step, the target table's structure can be specified, if the table does
not exist.  Not specifying any structure will cause the import process to infer
the table's structure from the source data.

To specify a table structure, click **+ Add Column** once for
each field in the source data, then enter the specification for each column,
including:

* **Name** - name of the column, which must meet the standard
  [naming criteria](/content/concepts/tables#table-naming-criteria)
* **Type** - type of the column, and sub-type, if applicable
* **Nullable** - check the box if the column should allow *null*
  values
* **Properties** - check any properties that should apply to this
  column:

  * **Primary Key** - make this column the
    [primary key](/content/concepts/tables#primary-key) or part of a
    *composite primary key*
  * **Shard Key** - make this column the
    [shard key](/content/concepts/tables#shard-key) or part of a
    *composite shard key*
  * **Dict. Encoded** - apply
    [dictionary encoding](/content/concepts/dictionary_encoding) to the
    column's values, reducing storage used for columns with more often repeated
    data
  * **Init. with Now** - replace empty or invalid values inserted
    into this column with the current date/time
  * **Init. with UUID** - replace empty values inserted into this
    column with a universally unique identifier (UUID)
  * **Text Search** - make this column
    [full-text searchable](/content/concepts/full_text_search), using
    [FILTER\_BY\_STRING](/content/sql/query/string-functions#sql-string-functions-fts) in *search* mode

To remove a column from the proposed target table, click the trash can icon at
the far right of the column's definition.

Once the table configuration has been established, click **Next**
to proceed to the **Summary** page.

<a />

## Summary

In this step, the import configuration will be displayed.

All **Source**, **Destination**, &
**Error Handling** configuration will be displayed in their
respective sections.

The **Generated SQL** section will contain the SQL
[LOAD INTO](/content/sql/load#sql-load-into) command corresponding to the import
operation that will take place.  The copy-to-clipboard icon can be used to copy
the SQL statement for subsequent use, to re-import data from the same file into
the same table.

Once the import configuration has been confirmed, click
**Import** to import the table's data.


# JDBC Data Source Import
Source: https://docs.kinetica.com/content/admin/workbench/ui/import/jdbc_prov



Using the *JDBC Data Source Import* wizard, tables located in another database
can be imported into *Kinetica* via *JDBC*.

To import a table from a remote database into *Kinetica*, click on any of the
data source panels listed under **JDBC Data Sources** on the
[Import](/content/admin/workbench/ui/import) landing page in
[Workbench](/content/admin/workbench).

The **JDBC Data Source Import** wizard appears in the right-hand
pane, noting the specific source selected.

<img alt="../../../images/wb.import_jdbc_prov.png" />

The wizard has two tabs:

* **Import** - contains the 5-step process for importing files
  from remote data sources using *JDBC*
* **History** - lists all of your previous *JDBC Data Source*
  import attempts

## Import Overview

When importing, the following five steps will need to be completed:

* [Setup](#setup)
* [Source](#source)
* [Destination](#destination)
* [Configure](#configure)
* [Summary](#summary)

At any step, the following actions are available at the bottom of the screen:

* **Next** - proceed to the next step
* **Back** - return to the previous step
* **Cancel** - exit the import process
* **Import** - once enough information has been specified to
  begin importing data, the **Import** button will become active

<a />

## Setup

In this step, the [data source](/content/sql/ddl/create-data-source#sql-create-data-source) used to
connect to the remote database is selected.

* **Create New Data Source** - click to create a new
  *data source* that connects to the remote data source, then enter its
  configuration and click **Create** to create the *data source*
  and proceed to the **Source** selection page:

  * **Name** - enter a unique name for the *data source*
  * **Connection String** - JDBC connection string used in
    connecting to the remote service; see
    [supported list](/content/concepts/jdbc_drivers) for provider detail
  * **Username** - username to use in connecting to the remote
    service; can be specified here or in the connection string
  * **Password** - password to use in connecting to the remote
    service; can be specified here or in the connection string

* **Select Existing Data Source** - click to select an existing
  *data source* that connects to the remote data source and then click
  **Next** to proceed to the **Source** selection
  page:

  * **Data Source** - click to open a drop-down of available
    *data sources* that connect to the remote data source and select one

<a />

## Source

In this step, the source table is selected or the source query entered.

* **Source** - pre-selected as the name of the *data source*
  chosen in the previous step
* **Remote Table** - enter the name of the table located within
  the remote data source; click **Browse Tables** to pop up the
  remote table browsing interface and make a selection from the available
  tables, and click **Select** next to the table to import
* **Remote Query** - enter a query to run on the remote data
  source; click **Verify Remote Query** to ensure the query is
  able to be executed on the remote data source
* **Subscription Options** - check the **Enable**
  box to activate a subscription to the remote data

  * **Poll Interval** - the time (in seconds) between successive
    requests to the remote cluster for more data
  * **Increasing Column** - remote table/query column to use to
    determine whether a remote record is new and should be imported; only
    records with a higher value than the highest value from the last poll will
    be imported

<a />

## Destination

In this step, the target table to import into is selected.

* **Schema** - name of the schema containing the target table;
  if blank, the user's [default schema](/content/concepts/schemas#schema-default) will be
  used
* **Table** - name of the target table, which must meet
  [table naming criteria](/content/concepts/tables#table-naming-criteria); *Workbench* will
  suggest a table name here, if possible
* **Batch Size** - number of records from the source to
  insert into the database at a time; this can be used to tune the ingest speed
  for source data with many records or wide columns
* **Abort on Error** - check, to have the import stop at the
  first record import failure; any records imported by this point will remain in
  the target table
* **Bad Records Table** - when **Abort on Error**
  is unchecked, the errant records will be written to the specified table

  * **Schema** - schema in which the bad records table should
    reside
  * **Table** - name for the bad records table

Once the destination has been specified, click **Next** to
proceed to the **Configure** page.

<a />

## Configure

In this step, the target table's structure can be specified, if the table does
not exist.  Not specifying any structure will cause the import process to infer
the table's structure from the source data.

To specify a table structure, click **+ Add Column** once for
each field in the source data, then enter the specification for each column,
including:

* **Name** - name of the column, which must meet the standard
  [naming criteria](/content/concepts/tables#table-naming-criteria)
* **Type** - type of the column, and sub-type, if applicable
* **Nullable** - check the box if the column should allow *null*
  values
* **Properties** - check any properties that should apply to this
  column:

  * **Primary Key** - make this column the
    [primary key](/content/concepts/tables#primary-key) or part of a
    *composite primary key*
  * **Shard Key** - make this column the
    [shard key](/content/concepts/tables#shard-key) or part of a
    *composite shard key*
  * **Dict. Encoded** - apply
    [dictionary encoding](/content/concepts/dictionary_encoding) to the
    column's values, reducing storage used for columns with more often repeated
    data
  * **Init. with Now** - replace empty or invalid values inserted
    into this column with the current date/time
  * **Init. with UUID** - replace empty values inserted into this
    column with a universally unique identifier (UUID)
  * **Text Search** - make this column
    [full-text searchable](/content/concepts/full_text_search), using
    [FILTER\_BY\_STRING](/content/sql/query/string-functions#sql-string-functions-fts) in *search* mode

To remove a column from the proposed target table, click the trash can icon at
the far right of the column's definition.

Once the table configuration has been established, click **Next**
to proceed to the **Summary** page.

<a />

## Summary

In this step, the import configuration will be displayed.

All **Source**, **Destination**, &
**Error Handling** configuration will be displayed in their
respective sections.

The **Generated SQL** section will contain the SQL
[LOAD INTO](/content/sql/load#sql-load-into) command corresponding to the import
operation that will take place.  The copy-to-clipboard icon can be used to copy
the SQL statement for subsequent use, to re-import data from the same file into
the same table.

Once the import configuration has been confirmed, click
**Import** to import the table's data.


# Kafka Stream Import
Source: https://docs.kinetica.com/content/admin/workbench/ui/import/kafka



Using the *Kafka Stream Import* wizard, data from a *Kafka* topic can be
streamed into *Kinetica*.

To stream data from *Kafka* into *Kinetica*, click on the
**Kafka Stream** panel on the [Import](/content/admin/workbench/ui/import) landing
page in [Workbench](/content/admin/workbench).

The **Kafka Stream Import** wizard appears in the right-hand
pane.

<img alt="../../../images/wb.import_kafka.png" />

The wizard has two tabs:

* **Import** - contains the 5-step process for streaming data
  from *Kafka*
* **History** - lists all of your previous *Kafka* stream
  attempts

## Import Overview

When importing, the following five steps will need to be completed:

* [Setup](#setup)
* [Source](#source)
* [Destination](#destination)
* [Configure](#configure)
* [Summary](#summary)

At any step, the following actions are available at the bottom of the screen:

* **Next** - proceed to the next step
* **Back** - return to the previous step
* **Cancel** - exit the import process
* **Import** - once enough information has been specified to
  begin importing data, the **Import** button will become active

<a />

## Setup

In this step, the [data source](/content/sql/ddl/create-data-source#sql-create-data-source) used to
connect to *Kafka* is selected.

* **Create New Data Source** - click to create a new
  *data source* that connects to *Kafka*, then enter its configuration and click
  **Create** to create the *data source* and proceed to the
  **Source** selection page:

  * **Name** - enter a unique name for the *data source*
  * **URL** - enter the host & port of the *Kafka* service
    to use
  * **Topic Name** - enter the name of the *Kafka* topic from
    which data will be streamed
  * **Auth Type** - select an authorization scheme; this will
    prompt with the appropriate fields for the scheme selected

    <Info>
      To authenticate to *Kafka* services via other authentication
      schemes, create a [Kafka Credential](/content/sql/ddl/create-credential#sql-create-credential)
      via SQL (in a [Workbook](/content/admin/workbench/workbooks), for
      example) and then create a
      [Kafka Data Source](/content/sql/ddl/create-data-source#sql-create-data-source) that uses the
      credential
    </Info>

* **Select Existing Data Source** - click to select an existing
  *data source* that connects to *Kafka* and then click
  **Next** to proceed to the **Source** selection
  page:

  * **Data Source** - click to open a drop-down of available
    *data sources* that connect to *Kafka* and select one

<a />

## Source

In this step, the source data options are configured, if necessary.

* **Source** - pre-selected as the name of the *data source*
  chosen in the previous step
* **Format** - pre-selected as JSON
* **Poll Interval** - the time (in seconds) between successive
  requests to *Kafka* for more data
* **Store Points As X/Y** - check the box to store GeoJSON
  data as separate X, Y, & Z columns, instead of a WKT-based format

Once the source configuration is complete, click **Next** to
proceed to the **Destination** selection page.

<a />

## Destination

In this step, the target table to import into is selected.

* **Schema** - name of the schema containing the target table;
  if blank, the user's [default schema](/content/concepts/schemas#schema-default) will be
  used
* **Table** - name of the target table, which must meet
  [table naming criteria](/content/concepts/tables#table-naming-criteria); *Workbench* will
  suggest a table name here, if possible
* **Abort on Error** - check, to have the import stop at the
  first record import failure; any records imported by this point will remain in
  the target table
* **Bad Records Table** - when **Abort on Error**
  is unchecked the errant records will be written to the specified table

  * **Schema** - schema in which the bad records table should
    reside
  * **Table** - name for the bad records table

Once the destination has been specified, click **Next** to
proceed to the **Configure** page.

<a />

## Configure

In this step, the target table's structure can be specified, if the table does
not exist.  Not specifying any structure will cause the import process to infer
the table's structure from the source data.

To specify a table structure, click **+ Add Column** once for
each field in the source data, then enter the specification for each column,
including:

* **Name** - name of the column, which must meet the standard
  [naming criteria](/content/concepts/tables#table-naming-criteria)
* **Type** - type of the column, and sub-type, if applicable
* **Nullable** - check the box if the column should allow *null*
  values
* **Properties** - check any properties that should apply to this
  column:

  * **Primary Key** - make this column the
    [primary key](/content/concepts/tables#primary-key) or part of a
    *composite primary key*
  * **Shard Key** - make this column the
    [shard key](/content/concepts/tables#shard-key) or part of a
    *composite shard key*
  * **Dict. Encoded** - apply
    [dictionary encoding](/content/concepts/dictionary_encoding) to the
    column's values, reducing storage used for columns with more often repeated
    data
  * **Init. with Now** - replace empty or invalid values inserted
    into this column with the current date/time
  * **Init. with UUID** - replace empty values inserted into this
    column with a universally unique identifier (UUID)
  * **Text Search** - make this column
    [full-text searchable](/content/concepts/full_text_search), using
    [FILTER\_BY\_STRING](/content/sql/query/string-functions#sql-string-functions-fts) in *search* mode

To remove a column from the proposed target table, click the trash can icon at
the far right of the column's definition.

Once the table configuration has been established, click **Next**
to proceed to the **Summary** page.

<a />

## Summary

In this step, the import configuration will be displayed.

All **Source**, **Destination**, &
**Error Handling** configuration will be displayed in their
respective sections.

The **Generated SQL** section will contain the SQL
[LOAD INTO](/content/sql/load#sql-load-into) command corresponding to the import
operation that will take place.  The copy-to-clipboard icon can be used to copy
the SQL statement for subsequent use, to re-import data from the same file into
the same table.

Once the data stream configuration has been confirmed, click
**Import** to begin streaming data.


# Kinetica FileSystem Import
Source: https://docs.kinetica.com/content/admin/workbench/ui/import/kifs



Using the *Kinetica FileSystem (KiFS) Import* wizard, files staged in
[KiFS](/content/tools/kifs) can be imported into *Kinetica*.

To import a file from *KiFS* into *Kinetica*, click on the
**Kinetica FileSystem** panel on the [Import](/content/admin/workbench/ui/import)
landing page in [Workbench](/content/admin/workbench).

The **Kinetica FileSystem Import** wizard appears in the
right-hand pane.

<img alt="../../../images/wb.import_kifs.png" />

The wizard has two tabs:

* **Import** - contains the 5-step process for importing files
  from *KiFS*
* **History** - lists all of your previous *KiFS* import attempts

## Import Overview

When importing, the following five steps will need to be completed:

* [Setup](#setup)
* [Source](#source)
* [Destination](#destination)
* [Configure](#configure)
* [Summary](#summary)

At any step, the following actions are available at the bottom of the screen:

* **Next** - proceed to the next step
* **Back** - return to the previous step
* **Cancel** - exit the import process
* **Import** - once enough information has been specified to
  begin importing data, the **Import** button will become active

<a />

## Setup

In this step, the file to import from *KiFS* is selected.

* **File** - click the control to open the *KiFS* file selector,
  which shows a list of the *KiFS* directories, and as each is clicked, the
  files contained within that directory; click any file to select for import

Once the file to upload has been specified, click **Next** to
proceed to the **Source** selection page to configure the file
parser for the file selected.

<a />

## Source

In this step, the parser is configured for the selected *KiFS* file.

* **Source** - pre-selected as *Kinetica Filesystem*
* **File Path** - pre-selected as a *KiFS* reference to the file
  chosen in the previous step
* **Format** - select the format of the *KiFS* file from the
  drop-down

If the source data is in a delimited text file, options for parsing the file can
be specified (see [Delimited Text Options](/content/sql/load#sql-load-file-server-delim-opt) for details):

* **Delimiter** - select the character that delimits field values
  in the source file:

  * `|` - default delimiter for <Badge>.psv</Badge> (pipe-separated value)
    files
  * `\t` - (tab) default delimiter for <Badge>.tsv</Badge>
    (tab-separated value) files
  * `,` - default delimiter for <Badge>.csv</Badge> (comma-separated value)
    files and all other types of text files

* **Escape Character** - select the character used to escape
  special characters (like the field delimiter) found within field values; e.g.,
  a `\` might be used to escape commas within field values in a
  <Badge>.csv</Badge> file

* **Comment Identifier** - select the character(s) with which
  comment lines within the source file begin

* **Quote Character** - select the character used to quote field
  values; e.g., a `"` might be used to quote field values containing commas in
  a <Badge>.csv</Badge> file

* **Null Identifier** - select the character(s) used to identify
  *null* field values

* **Has Header** - check the box if the source file contains a
  header row at the top

Once the source file and parameters have been selected, click
**Next** to proceed to the **Destination**
selection page.

<a />

## Destination

In this step, the target table to import into is selected.

* **Schema** - name of the schema containing the target table;
  if blank, the user's [default schema](/content/concepts/schemas#schema-default) will be
  used
* **Table** - name of the target table, which must meet
  [table naming criteria](/content/concepts/tables#table-naming-criteria); *Workbench* will
  suggest a table name here, if possible
* **Batch Size** - number of records from the source to
  insert into the database at a time; this can be used to tune the ingest speed
  for source data with many records or wide columns
* **Abort on Error** - check, to have the import stop at the
  first record import failure; any records imported by this point will remain in
  the target table
* **Bad Records Table** - when **Abort on Error**
  is unchecked, the errant records will be written to the specified table

  * **Schema** - schema in which the bad records table should
    reside
  * **Table** - name for the bad records table

Once the destination has been specified, click **Next** to
proceed to the **Configure** page.

<a />

## Configure

In this step, the target table's structure can be specified, if the table does
not exist.  Not specifying any structure will cause the import process to infer
the table's structure from the source data.

To specify a table structure, click **+ Add Column** once for
each field in the source data, then enter the specification for each column,
including:

* **Name** - name of the column, which must meet the standard
  [naming criteria](/content/concepts/tables#table-naming-criteria)
* **Type** - type of the column, and sub-type, if applicable
* **Nullable** - check the box if the column should allow *null*
  values
* **Properties** - check any properties that should apply to this
  column:

  * **Primary Key** - make this column the
    [primary key](/content/concepts/tables#primary-key) or part of a
    *composite primary key*
  * **Shard Key** - make this column the
    [shard key](/content/concepts/tables#shard-key) or part of a
    *composite shard key*
  * **Dict. Encoded** - apply
    [dictionary encoding](/content/concepts/dictionary_encoding) to the
    column's values, reducing storage used for columns with more often repeated
    data
  * **Init. with Now** - replace empty or invalid values inserted
    into this column with the current date/time
  * **Init. with UUID** - replace empty values inserted into this
    column with a universally unique identifier (UUID)
  * **Text Search** - make this column
    [full-text searchable](/content/concepts/full_text_search), using
    [FILTER\_BY\_STRING](/content/sql/query/string-functions#sql-string-functions-fts) in *search* mode

To remove a column from the proposed target table, click the trash can icon at
the far right of the column's definition.

Once the table configuration has been established, click **Next**
to proceed to the **Summary** page.

<a />

## Summary

In this step, the import configuration will be displayed.

All **Source**, **Destination**, &
**Error Handling** configuration will be displayed in their
respective sections.

The **Generated SQL** section will contain the SQL
[LOAD INTO](/content/sql/load#sql-load-into) command corresponding to the import
operation that will take place.  The copy-to-clipboard icon can be used to copy
the SQL statement for subsequent use, to re-import data from the same file into
the same table.

Once the import configuration has been confirmed, click
**Import** to import the file's data.


# Kinetica Import
Source: https://docs.kinetica.com/content/admin/workbench/ui/import/kinetica



Using the *Kinetica Import* wizard, tables located in another *Kinetica* cluster
can be imported into *Kinetica*.

To import a table from a remote *Kinetica* into a local one, click on the
**Kinetica** panel on the [Import](/content/admin/workbench/ui/import)
landing page in [Workbench](/content/admin/workbench).

The **Kinetica Import** wizard appears in the right-hand pane.

<img alt="../../../images/wb.import_kinetica.png" />

The wizard has two tabs:

* **Import** - contains the 5-step process for importing files
  from *Kinetica*
* **History** - lists all of your previous *Kinetica*
  import attempts

## Import Overview

When importing, the following five steps will need to be completed:

* [Setup](#setup)
* [Source](#source)
* [Destination](#destination)
* [Configure](#configure)
* [Summary](#summary)

At any step, the following actions are available at the bottom of the screen:

* **Next** - proceed to the next step
* **Back** - return to the previous step
* **Cancel** - exit the import process
* **Import** - once enough information has been specified to
  begin importing data, the **Import** button will become active

<a />

## Setup

In this step, the [data source](/content/sql/ddl/create-data-source#sql-create-data-source) used to
connect to *Kinetica* is selected.

* **Create New Data Source** - click to create a new
  *data source* that connects to *Kinetica*, then enter its configuration and
  click **Create** to create the *data source* and proceed to the
  **Source** selection page:

  * **Name** - enter a unique name for the *data source*
  * **URL** - select either an assisted or manual scheme for
    entering connection information

    * **Assisted** - enter the parameters for connecting to the
      remote *Kinetica* cluster; the JDBC connection string will be built
      automatically and displayed in the preview box
    * **Manual** - enter the JDBC connection string to connect to
      the remote *Kinetica* cluster

* **Select Existing Data Source** - click to select an existing
  *data source* that connects to *Kinetica* and then click
  **Next** to proceed to the **Source** selection
  page:

  * **Data Source** - click to open a drop-down of available
    *data sources* that connect to *Kinetica* and select one

<a />

## Source

In this step, the source table is selected or the source query entered.

* **Source** - pre-selected as the name of the *data source*
  chosen in the previous step
* **Remote Table** - enter the name of the table located within
  the remote *Kinetica* cluster; click **Browse Tables** to pop
  up the remote table browsing interface and make a selection from the available
  tables, and click **Select** next to the table to import
* **Remote Query** - enter a query to run on the remote
  *Kinetica* cluster; click **Verify Remote Query** to ensure the
  query is able to be executed on the remote cluster
* **Subscription Options** - check the **Enable**
  box to activate a subscription to the remote data

  * **Poll Interval** - the time (in seconds) between successive
    requests to the remote cluster for more data
  * **Increasing Column** - remote table/query column to use to
    determine whether a remote record is new and should be imported; only
    records with a higher value than the highest value from the last poll will
    be imported

<a />

## Destination

In this step, the target table to import into is selected.

* **Schema** - name of the schema containing the target table;
  if blank, the user's [default schema](/content/concepts/schemas#schema-default) will be
  used
* **Table** - name of the target table, which must meet
  [table naming criteria](/content/concepts/tables#table-naming-criteria); *Workbench* will
  suggest a table name here, if possible
* **Batch Size** - number of records from the source to
  insert into the database at a time; this can be used to tune the ingest speed
  for source data with many records or wide columns
* **Abort on Error** - check, to have the import stop at the
  first record import failure; any records imported by this point will remain in
  the target table
* **Bad Records Table** - when **Abort on Error**
  is unchecked, the errant records will be written to the specified table

  * **Schema** - schema in which the bad records table should
    reside
  * **Table** - name for the bad records table

Once the destination has been specified, click **Next** to
proceed to the **Configure** page.

<a />

## Configure

In this step, the target table's structure can be specified, if the table does
not exist.  Not specifying any structure will cause the import process to infer
the table's structure from the source data.

To specify a table structure, click **+ Add Column** once for
each field in the source data, then enter the specification for each column,
including:

* **Name** - name of the column, which must meet the standard
  [naming criteria](/content/concepts/tables#table-naming-criteria)
* **Type** - type of the column, and sub-type, if applicable
* **Nullable** - check the box if the column should allow *null*
  values
* **Properties** - check any properties that should apply to this
  column:

  * **Primary Key** - make this column the
    [primary key](/content/concepts/tables#primary-key) or part of a
    *composite primary key*
  * **Shard Key** - make this column the
    [shard key](/content/concepts/tables#shard-key) or part of a
    *composite shard key*
  * **Dict. Encoded** - apply
    [dictionary encoding](/content/concepts/dictionary_encoding) to the
    column's values, reducing storage used for columns with more often repeated
    data
  * **Init. with Now** - replace empty or invalid values inserted
    into this column with the current date/time
  * **Init. with UUID** - replace empty values inserted into this
    column with a universally unique identifier (UUID)
  * **Text Search** - make this column
    [full-text searchable](/content/concepts/full_text_search), using
    [FILTER\_BY\_STRING](/content/sql/query/string-functions#sql-string-functions-fts) in *search* mode

To remove a column from the proposed target table, click the trash can icon at
the far right of the column's definition.

Once the table configuration has been established, click **Next**
to proceed to the **Summary** page.

<a />

## Summary

In this step, the import configuration will be displayed.

All **Source**, **Destination**, &
**Error Handling** configuration will be displayed in their
respective sections.

The **Generated SQL** section will contain the SQL
[LOAD INTO](/content/sql/load#sql-load-into) command corresponding to the import
operation that will take place.  The copy-to-clipboard icon can be used to copy
the SQL statement for subsequent use, to re-import data from the same file into
the same table.

Once the import configuration has been confirmed, click
**Import** to import the table's data.


# Amazon S3 Import
Source: https://docs.kinetica.com/content/admin/workbench/ui/import/s3



Using the *Amazon S3 Import* wizard, files located in *Amazon S3* can be
imported into *Kinetica*.

To import a file from *Amazon S3* into *Kinetica*, click on the
**Amazon S3** panel on the [Import](/content/admin/workbench/ui/import)
landing page in [Workbench](/content/admin/workbench).

The **Amazon S3 Import** wizard appears in the right-hand pane.

<img alt="../../../images/wb.import_s3.png" />

The wizard has two tabs:

* **Import** - contains the 5-step process for importing files
  from *Amazon S3*
* **History** - lists all of your previous *Amazon S3*
  import attempts

## Import Overview

When importing, the following five steps will need to be completed:

* [Setup](#setup)
* [Source](#source)
* [Destination](#destination)
* [Configure](#configure)
* [Summary](#summary)

At any step, the following actions are available at the bottom of the screen:

* **Next** - proceed to the next step
* **Back** - return to the previous step
* **Cancel** - exit the import process
* **Import** - once enough information has been specified to
  begin importing data, the **Import** button will become active

<a />

## Setup

In this step, the [data source](/content/sql/ddl/create-data-source#sql-create-data-source) used to
connect to *Amazon S3* is selected.

* **Create New Data Source** - click to create a new
  *data source* that connects to *Amazon S3*, then enter its configuration and
  click **Create** to create the *data source* and proceed to the
  **Source** selection page:

  * **Name** - enter a unique name for the *data source*
  * **Bucket Name** - enter the name of the *Amazon S3* bucket to
    use
  * **Region** - enter the region in which the *Amazon S3* bucket
    exists
  * **Auth Type** - select an authorization scheme; this will
    prompt with the appropriate fields for the scheme selected

* **Select Existing Data Source** - click to select an existing
  *data source* that connects to *Amazon S3* and then click
  **Next** to proceed to the **Source** selection
  page:

  * **Data Source** - click to open a drop-down of available
    *data sources* that connect to *Amazon S3* and select one

<a />

## Source

In this step, the source file is selected and the parser configured for the
file, if necessary.

* **Source** - pre-selected as the name of the *data source*
  chosen in the previous step
* **File Path** - enter the path to the file located within
  *Amazon S3*; click **Browse Files** to pop up the
  remote file browsing interface and make a selection from the available files,
  and click the `X` in the top corner when done selecting files
* **Format** - select the format of the file from the drop-down

If the source data is in a delimited text file, options for parsing the file can
be specified (see [Delimited Text Options](/content/sql/load#sql-load-file-server-delim-opt) for details):

* **Delimiter** - select the character that delimits field values
  in the source file:

  * `|` - default delimiter for <Badge>.psv</Badge> (pipe-separated value)
    files
  * `\t` - (tab) default delimiter for <Badge>.tsv</Badge>
    (tab-separated value) files
  * `,` - default delimiter for <Badge>.csv</Badge> (comma-separated value)
    files and all other types of text files

* **Escape Character** - select the character used to escape
  special characters (like the field delimiter) found within field values; e.g.,
  a `\` might be used to escape commas within field values in a
  <Badge>.csv</Badge> file

* **Comment Identifier** - select the character(s) with which
  comment lines within the source file begin

* **Quote Character** - select the character used to quote field
  values; e.g., a `"` might be used to quote field values containing commas in
  a <Badge>.csv</Badge> file

* **Null Identifier** - select the character(s) used to identify
  *null* field values

* **Has Header** - check the box if the source file contains a
  header row at the top

Once the source file and parameters have been selected, click
**Next** to proceed to the **Destination**
selection page.

<a />

## Destination

In this step, the target table to import into is selected.

* **Schema** - name of the schema containing the target table;
  if blank, the user's [default schema](/content/concepts/schemas#schema-default) will be
  used
* **Table** - name of the target table, which must meet
  [table naming criteria](/content/concepts/tables#table-naming-criteria); *Workbench* will
  suggest a table name here, if possible
* **Batch Size** - number of records from the source to
  insert into the database at a time; this can be used to tune the ingest speed
  for source data with many records or wide columns
* **Abort on Error** - check, to have the import stop at the
  first record import failure; any records imported by this point will remain in
  the target table
* **Bad Records Table** - when **Abort on Error**
  is unchecked, the errant records will be written to the specified table

  * **Schema** - schema in which the bad records table should
    reside
  * **Table** - name for the bad records table

Once the destination has been specified, click **Next** to
proceed to the **Configure** page.

<a />

## Configure

In this step, the target table's structure can be specified, if the table does
not exist.  Not specifying any structure will cause the import process to infer
the table's structure from the source data.

To specify a table structure, click **+ Add Column** once for
each field in the source data, then enter the specification for each column,
including:

* **Name** - name of the column, which must meet the standard
  [naming criteria](/content/concepts/tables#table-naming-criteria)
* **Type** - type of the column, and sub-type, if applicable
* **Nullable** - check the box if the column should allow *null*
  values
* **Properties** - check any properties that should apply to this
  column:

  * **Primary Key** - make this column the
    [primary key](/content/concepts/tables#primary-key) or part of a
    *composite primary key*
  * **Shard Key** - make this column the
    [shard key](/content/concepts/tables#shard-key) or part of a
    *composite shard key*
  * **Dict. Encoded** - apply
    [dictionary encoding](/content/concepts/dictionary_encoding) to the
    column's values, reducing storage used for columns with more often repeated
    data
  * **Init. with Now** - replace empty or invalid values inserted
    into this column with the current date/time
  * **Init. with UUID** - replace empty values inserted into this
    column with a universally unique identifier (UUID)
  * **Text Search** - make this column
    [full-text searchable](/content/concepts/full_text_search), using
    [FILTER\_BY\_STRING](/content/sql/query/string-functions#sql-string-functions-fts) in *search* mode

To remove a column from the proposed target table, click the trash can icon at
the far right of the column's definition.

Once the table configuration has been established, click **Next**
to proceed to the **Summary** page.

<a />

## Summary

In this step, the import configuration will be displayed.

All **Source**, **Destination**, &
**Error Handling** configuration will be displayed in their
respective sections.

The **Generated SQL** section will contain the SQL
[LOAD INTO](/content/sql/load#sql-load-into) command corresponding to the import
operation that will take place.  The copy-to-clipboard icon can be used to copy
the SQL statement for subsequent use, to re-import data from the same file into
the same table.

Once the import configuration has been confirmed, click
**Import** to import the file's data.


# Import Configure
Source: https://docs.kinetica.com/content/admin/workbench/ui/import/shared/configure



In this step, the target table's structure can be specified, if the table does
not exist.  Not specifying any structure will cause the import process to infer
the table's structure from the source data.

To specify a table structure, click **+ Add Column** once for
each field in the source data, then enter the specification for each column,
including:

* **Name** - name of the column, which must meet the standard
  [naming criteria](/content/concepts/tables#table-naming-criteria)
* **Type** - type of the column, and sub-type, if applicable
* **Nullable** - check the box if the column should allow *null*
  values
* **Properties** - check any properties that should apply to this
  column:

  * **Primary Key** - make this column the
    [primary key](/content/concepts/tables#primary-key) or part of a
    *composite primary key*
  * **Shard Key** - make this column the
    [shard key](/content/concepts/tables#shard-key) or part of a
    *composite shard key*
  * **Dict. Encoded** - apply
    [dictionary encoding](/content/concepts/dictionary_encoding) to the
    column's values, reducing storage used for columns with more often repeated
    data
  * **Init. with Now** - replace empty or invalid values inserted
    into this column with the current date/time
  * **Init. with UUID** - replace empty values inserted into this
    column with a universally unique identifier (UUID)
  * **Text Search** - make this column
    [full-text searchable](/content/concepts/full_text_search), using
    [FILTER\_BY\_STRING](/content/sql/query/string-functions#sql-string-functions-fts) in *search* mode

To remove a column from the proposed target table, click the trash can icon at
the far right of the column's definition.

Once the table configuration has been established, click **Next**
to proceed to the **Summary** page.


# Import Destination
Source: https://docs.kinetica.com/content/admin/workbench/ui/import/shared/destination



In this step, the target table to import into is selected.

* **Schema** - name of the schema containing the target table;
  if blank, the user's [default schema](/content/concepts/schemas#schema-default) will be
  used
* **Table** - name of the target table, which must meet
  [table naming criteria](/content/concepts/tables#table-naming-criteria); *Workbench* will
  suggest a table name here, if possible
* **Batch Size** - number of records from the source to
  insert into the database at a time; this can be used to tune the ingest speed
  for source data with many records or wide columns
* **Abort on Error** - check, to have the import stop at the
  first record import failure; any records imported by this point will remain in
  the target table
* **Bad Records Table** - when **Abort on Error**
  is unchecked, the errant records will be written to the specified table

  * **Schema** - schema in which the bad records table should
    reside
  * **Table** - name for the bad records table

Once the destination has been specified, click **Next** to
proceed to the **Configure** page.


# Import Overview
Source: https://docs.kinetica.com/content/admin/workbench/ui/import/shared/overview



When importing, the following five steps will need to be completed:

* Setup\_
* Source\_
* Destination\_
* Configure\_
* Summary\_

At any step, the following actions are available at the bottom of the screen:

* **Next** - proceed to the next step
* **Back** - return to the previous step
* **Cancel** - exit the import process
* **Import** - once enough information has been specified to
  begin importing data, the **Import** button will become active


# Import Source
Source: https://docs.kinetica.com/content/admin/workbench/ui/import/shared/source



If the source data is in a delimited text file, options for parsing the file can
be specified (see [Delimited Text Options](/content/sql/load#sql-load-file-server-delim-opt) for details):

* **Delimiter** - select the character that delimits field values
  in the source file:

  * `|` - default delimiter for <Badge>.psv</Badge> (pipe-separated value)
    files
  * `\t` - (tab) default delimiter for <Badge>.tsv</Badge>
    (tab-separated value) files
  * `,` - default delimiter for <Badge>.csv</Badge> (comma-separated value)
    files and all other types of text files

* **Escape Character** - select the character used to escape
  special characters (like the field delimiter) found within field values; e.g.,
  a `\` might be used to escape commas within field values in a
  <Badge>.csv</Badge> file

* **Comment Identifier** - select the character(s) with which
  comment lines within the source file begin

* **Quote Character** - select the character used to quote field
  values; e.g., a `"` might be used to quote field values containing commas in
  a <Badge>.csv</Badge> file

* **Null Identifier** - select the character(s) used to identify
  *null* field values

* **Has Header** - check the box if the source file contains a
  header row at the top

Once the source file and parameters have been selected, click
**Next** to proceed to the **Destination**
selection page.


# Import Summary
Source: https://docs.kinetica.com/content/admin/workbench/ui/import/shared/summary



In this step, the import configuration will be displayed.

All **Source**, **Destination**, &
**Error Handling** configuration will be displayed in their
respective sections.

The **Generated SQL** section will contain the SQL
[LOAD INTO](/content/sql/load#sql-load-into) command corresponding to the import
operation that will take place.  The copy-to-clipboard icon can be used to copy
the SQL statement for subsequent use, to re-import data from the same file into
the same table.


# File Upload Import
Source: https://docs.kinetica.com/content/admin/workbench/ui/import/upload



Using the *File Upload Import* wizard, local files can be staged in
[KiFS](/content/tools/kifs) and imported into *Kinetica*.  Once in
*KiFS*, they can subsequently be imported via the
[Kinetica Filesystem import wizard](/content/admin/workbench/ui/import/kifs) or via SQL's
[LOAD INTO](/content/sql/load#sql-load-into) command, or be made the source of data
for an [external table](/content/sql/ddl/create-external-table#sql-create-ext-table), among other uses.

To upload a local file to *KiFS* and import the data into *Kinetica*, click on
the **File Upload** panel on the [Import](/content/admin/workbench/ui/import) landing
page in [Workbench](/content/admin/workbench).

The **File Upload Import** wizard appears in the right-hand pane.

<img alt="../../../images/wb.import_file_upload.png" />

The wizard has two tabs:

* **Import** - contains the 5-step process for uploading &
  importing files
* **History** - lists all of your previous file upload import
  attempts

## Import Overview

When importing, the following five steps will need to be completed:

* [Setup](#setup)
* [Source](#source)
* [Destination](#destination)
* [Configure](#configure)
* [Summary](#summary)

At any step, the following actions are available at the bottom of the screen:

* **Next** - proceed to the next step
* **Back** - return to the previous step
* **Cancel** - exit the import process
* **Import** - once enough information has been specified to
  begin importing data, the **Import** button will become active

<a />

## Setup

In this step, the local file is uploaded to *KiFS*.

* **Folder** - enter the name of a top-level directory within
  *KiFS* to store the uploaded file
* **File** - drag & drop a file onto this control, or click
  **Browse** to browse your local file system for the file
* Optionally, enter a **File name override** that will be the new
  name of the file within *KiFS*

Once the file to upload has been specified, click the **Upload**
button that appears.  When the upload completes, click **Next** to
proceed to the **Source** selection page to identify the uploaded
file as the import source.

<a />

## Source

In this step, the local file uploaded to *KiFS* is selected for import.

* **Source** - pre-selected as *Kinetica Filesystem*
* **File Path** - pre-selected as a *KiFS* reference to the file
  just uploaded
* **Format** - select the format of the uploaded file from the
  drop-down

If the source data is in a delimited text file, options for parsing the file can
be specified (see [Delimited Text Options](/content/sql/load#sql-load-file-server-delim-opt) for details):

* **Delimiter** - select the character that delimits field values
  in the source file:

  * `|` - default delimiter for <Badge>.psv</Badge> (pipe-separated value)
    files
  * `\t` - (tab) default delimiter for <Badge>.tsv</Badge>
    (tab-separated value) files
  * `,` - default delimiter for <Badge>.csv</Badge> (comma-separated value)
    files and all other types of text files

* **Escape Character** - select the character used to escape
  special characters (like the field delimiter) found within field values; e.g.,
  a `\` might be used to escape commas within field values in a
  <Badge>.csv</Badge> file

* **Comment Identifier** - select the character(s) with which
  comment lines within the source file begin

* **Quote Character** - select the character used to quote field
  values; e.g., a `"` might be used to quote field values containing commas in
  a <Badge>.csv</Badge> file

* **Null Identifier** - select the character(s) used to identify
  *null* field values

* **Has Header** - check the box if the source file contains a
  header row at the top

Once the source file and parameters have been selected, click
**Next** to proceed to the **Destination**
selection page.

<a />

## Destination

In this step, the target table to import into is selected.

* **Schema** - name of the schema containing the target table;
  if blank, the user's [default schema](/content/concepts/schemas#schema-default) will be
  used
* **Table** - name of the target table, which must meet
  [table naming criteria](/content/concepts/tables#table-naming-criteria); *Workbench* will
  suggest a table name here, if possible
* **Batch Size** - number of records from the source to
  insert into the database at a time; this can be used to tune the ingest speed
  for source data with many records or wide columns
* **Abort on Error** - check, to have the import stop at the
  first record import failure; any records imported by this point will remain in
  the target table
* **Bad Records Table** - when **Abort on Error**
  is unchecked, the errant records will be written to the specified table

  * **Schema** - schema in which the bad records table should
    reside
  * **Table** - name for the bad records table

Once the destination has been specified, click **Next** to
proceed to the **Configure** page.

<a />

## Configure

In this step, the target table's structure can be specified, if the table does
not exist.  Not specifying any structure will cause the import process to infer
the table's structure from the source data.

To specify a table structure, click **+ Add Column** once for
each field in the source data, then enter the specification for each column,
including:

* **Name** - name of the column, which must meet the standard
  [naming criteria](/content/concepts/tables#table-naming-criteria)
* **Type** - type of the column, and sub-type, if applicable
* **Nullable** - check the box if the column should allow *null*
  values
* **Properties** - check any properties that should apply to this
  column:

  * **Primary Key** - make this column the
    [primary key](/content/concepts/tables#primary-key) or part of a
    *composite primary key*
  * **Shard Key** - make this column the
    [shard key](/content/concepts/tables#shard-key) or part of a
    *composite shard key*
  * **Dict. Encoded** - apply
    [dictionary encoding](/content/concepts/dictionary_encoding) to the
    column's values, reducing storage used for columns with more often repeated
    data
  * **Init. with Now** - replace empty or invalid values inserted
    into this column with the current date/time
  * **Init. with UUID** - replace empty values inserted into this
    column with a universally unique identifier (UUID)
  * **Text Search** - make this column
    [full-text searchable](/content/concepts/full_text_search), using
    [FILTER\_BY\_STRING](/content/sql/query/string-functions#sql-string-functions-fts) in *search* mode

To remove a column from the proposed target table, click the trash can icon at
the far right of the column's definition.

Once the table configuration has been established, click **Next**
to proceed to the **Summary** page.

<a />

## Summary

In this step, the import configuration will be displayed.

All **Source**, **Destination**, &
**Error Handling** configuration will be displayed in their
respective sections.

The **Generated SQL** section will contain the SQL
[LOAD INTO](/content/sql/load#sql-load-into) command corresponding to the import
operation that will take place.  The copy-to-clipboard icon can be used to copy
the SQL statement for subsequent use, to re-import data from the same file into
the same table.

Once the import configuration has been confirmed, click
**Import** to import the file's data.


# Workbench UI
Source: https://docs.kinetica.com/content/admin/workbench/ui/index



The *Kinetica Workbench* provides a rich user interface for accessing data.

<Frame>
  <img alt="../images/wb.workbench.png" />
</Frame>

*Workbench* consists of two panes:

* *left pane* - contains [Workbench Explorer](/content/admin/workbench/ui/explorer)
* *right pane* - contains content associated primarily with top-level menu items

The top-level menu items are as follows:

* [Home](/content/admin/workbench/ui/home)

* [Explore](/content/admin/workbench/ui/explore)

* [Import](/content/admin/workbench/ui/import)

* [Jobs](/content/admin/workbench/ui/jobs)

* **Manage**

  * **Workbench** - opens a dialog to change various settings
    within *Workbench*

* **Running** - the current status of the system

* <img alt="wb_icon_help" /> - displays the database version number as well as links to
  various help sources

* *\<Profile>* (displays username)

  * **Usage** - displays database resource usage metrics

  * **Preferences** - allows switching between light & dark mode
    themes

  * **Logout** - ends the current session with *Workbench*

The left & right panes act independently from each other, allowing for the
exploration of data across domains (tables, workbooks, files, etc.) from any
part of the application (*Home*, *Import*, etc.).


# Jobs
Source: https://docs.kinetica.com/content/admin/workbench/ui/jobs



The *Jobs* interface is situated in the right-hand pane of *Kinetica's*
[Workbench](/content/admin/workbench) administration application.  It can
be used to view the status of the user-initiated and system-level jobs running
within the database.

<Frame>
  <img alt="../../images/wb.jobs.png" />
</Frame>

To access the *Jobs* page, in *Workbench*, click the
**Jobs** menu item.  This will open the list of running jobs in
the right-hand pane.  Additionally, there are several action buttons:

* **Cancel Selected** - stop any selected jobs from running
* <img alt="wb_icon_refresh" /> - refresh the displayed list of jobs

Three tabs allow separate viewing of the different job types:

* **Running** -
  jobs currently being executed within the database
* **Perpetual** -
  subscriptions made via
  [Kafka data sources](/content/load_data/by_source/kafka).
* **UDFs** -
  both user-defined and system-level [UDFs](/content/sql/udf); click
  **View** to display detail about the corresponding UDF, as well
  as its execution history


# Using Workbooks in Workbench
Source: https://docs.kinetica.com/content/admin/workbench/workbooks



## Explorer Panel

On the left side of the screen, you will see a tabbed panel, which we call the
*Explorer*. The *Explorer* has three main views: *Data*, *Workbooks*, & *Files*.

The [Data Explorer UI](/content/admin/workbench/ui/explorer/data) displays all of the data
you have in *Kinetica*, like tables, views, graphs, and data sources. The data
objects are sorted by type, allowing you to minimize or expand each section, and
filter through the object names using a text input.

The [Workbook Explorer UI](/content/admin/workbench/ui/explorer/workbooks) provides a means
to organize a SQL-based set of commands or workflows for development or
presentation purposes.

The [File Explorer UI](/content/admin/workbench/ui/explorer/files) allows browsing of the
[Kinetica FileSystem (KiFS)](/content/tools/kifs), where data files
uploaded to *Kinetica* reside.

### Data Explorer

When a data object is created using the UI-based wizard, it will appear in the
*Data Explorer* automatically. When creating an object using a *SQL Block*, the
*Data Explorer* will refresh automatically after the statement has been
executed. Any queries executed in a worksheet that do not return rows will
trigger a refresh of the *Data Explorer* to ensure you have the latest
information about the system. The *Data Explorer* will show newly
created objects, but if you do not see one listed, use the
**Refresh** button at the top right of the *Data Explorer* to
retrieve the latest information manually.

<Frame>
  <img alt="../images/wb.explorer_data.png" />
</Frame>

#### Creating and Modifying Data Objects

Create new data objects, like tables, data sources, or graphs, by clicking the
plus **+** button at the top of the *Data Explorer*, or next to
any of the data object type headings. You will be walked through options in a
wizard. To modify an existing object, click the object and select
**Configure**.

<Frame>
  <img alt="../images/wb.explorer_data_popup.png" />
</Frame>

<Frame>
  <img alt="../images/wb.create_table.png" />
</Frame>

#### Previewing Objects

You can preview an object’s data by clicking and selecting
**Data Preview**. For tabular data, you will be shown a table
view of the data.

<Frame>
  <img alt="../images/wb.data_preview_grid.png" />
</Frame>

You can also preview geospatial tabular data on a map by selecting
**WMS Preview**. Abstract graphs, like social graphs cannot be
previewed in the *Workbench*. Previewing a geospatial graph will display a map
of the graph.

<Frame>
  <img alt="../images/wb.data_preview_wms.png" />
</Frame>

#### Deleting Objects

To delete an object, click the object and select **Delete**.

<a />

### Workbook Explorer

The *Workbook Explorer* contains two lists of *workbooks*:

* **My Workbooks** - a list of *workbooks* you've created,
  and the *Quick Start Guide*, which comes with each *Kinetica* deployment
* **Examples** - workbooks that are provided with *Workbench* for
  exploring the various features of *Kinetica*
* **Shared With Me** - a list of *workbooks* others have created
  and made available to you

<Frame>
  <img alt="../images/wb.explorer_workbooks.png" />
</Frame>

#### Creating a New Workbook

To create a new *workbook*, select the **Workbook** tab in the
*Explorer*, then click the plus **+** button.  Alternatively,
you can create a new *workbook* using the large button on the
**Explore** landing page.

After giving it a name, the new *workbook* will be displayed in the right-hand
pane with a single empty *SQL Block* to start.

<Frame>
  <img alt="../images/wb.workbook_new.png" />
</Frame>

#### Example Workbook

*Kinetica* ships with a *workbook* that showcases an end-to-end analytics
example through SQL. In this *workbook*, you will ingest data from S3, perform
several analytic queries, and finally visualize the output on a map. To open the
example *workbook*, click the **Workbooks** tab in the *Explorer*
and select **Quick Start Guide**.

#### Exporting/Importing Workbooks

You can export and import *workbooks* to share your SQL. Right-click on a
*workbook* in the *Workbook Explorer* and select the **Export**
menu option.  Choose **Workbook JSON** to initiate the download
in JSON format.

<Frame>
  <img alt="../images/wb.workbook_export.png" />
</Frame>

To import a *workbook*, select the plus **+** button at the top
right of the *Workbook Explorer*. This will open a dialog window that allows you
to drag and drop a previously exported *workbook*.

<Frame>
  <img alt="../images/wb.workbook_import.png" />
</Frame>

<a />

### File Explorer

The *File Explorer* can be used to manage
[directories](/content/tools/kifs_api#kifs-directory) & [files](/content/tools/kifs_api#kifs-file)
that reside in [Kinetica File System (KiFS)](/content/tools/kifs).  This feature facilitates uploading
local data files to import their data into *Kinetica*.

<Frame>
  <img alt="../images/wb.explorer_files.png" />
</Frame>

#### Uploading a File

To upload a data file, select the **Files** tab in the
*Explorer* to reach the *File Explorer*.  Then, proceed either one of two ways:

* Click the plus **+** button at the top of the *File Explorer*
  panel and then click **Upload New File**
* Right-click the *directory* to upload the file into, and then click
  **Upload New File**

At this point a modal will open up, prompting the selection of a data file to
upload from the local file system.  Choose a file and then click
**Open**.  Then enter (or confirm) the name of the *directory* to
upload the file to and, optionally, choose a different name for the uploaded
file in *KiFS*.  Click **Upload** to complete the file upload,
and **Close** to close the modal.

<Frame>
  <img alt="../images/wb.explorer_files_upload.png" />
</Frame>

#### Importing a File

To import a *file* from *KiFS*, select the **Files** tab in the
*Explorer* to reach the *File Explorer*.  Then, right-click the name of the
*file* to upload and click **Import**.

The *Kinetica Filesystem Import* wizard will be displayed with the name of the
*file* to import already populated in the **File** field.

<Frame>
  <img alt="../images/wb.explorer_files_import_setup.png" />
</Frame>

Click **Import** at any step of the wizard to import the *file*
with the default options, along with any that have been configured in previous
steps.  See [Import Data Wizard](/content/admin/workbench/workbooks#wb-import-wiz) for the step-by-step walkthrough of the
wizard.

<a />

## SQL Workbooks and Worksheets

*Workbooks* can be accessed via the *Explore* page, using the top navigation.

This page will be used in the future to import *workbooks*
from *Kinetica’s Workbook Repository*.

<Frame>
  <img alt="../images/wb.explore.png" />
</Frame>

### Workbooks

A *workbook* is a container for *worksheets*.

Each *worksheet* begins with the [SQL-GPT interface](/content/admin/workbench/workbooks#wb-sql-gpt),
followed by one or more *data blocks* and *presentation blocks*:

* *Data blocks* - blocks that interact with the database and display the results
  of queries and/or operations; these include:

  * [SQL Blocks](/content/admin/workbench/workbooks#wb-sql-block)
  * [Map Blocks](/content/admin/workbench/workbooks#wb-map-block)
  * [Graph Blocks](/content/admin/workbench/workbooks#wb-graph-block)

* [Presentation blocks](/content/admin/workbench/workbooks#wb-presentation-block) - blocks that
  display static content, usually used when converting a *workbook* to a
  presentation medium, where these *block* types can help explain a workflow and
  provide insight into the results of surrounding *data blocks* that do query
  the database; these include:

  * *Text Blocks*
  * *Image Blocks*
  * *HTML Blocks*

Any type of *block* can be moved up or down in the *block* ordering or removed
using the buttons in the upper right corner of the *block*. You can also add
another *block* directly below an existing one by using the plus
**+** button in the upper right menu.

<Frame>
  <img alt="../images/wb.workbook.png" />
</Frame>

<a />

### SQL-GPT

A [SQL-GPT](/content/sql-gpt/concepts) interface is present at the top of
each *worksheet* within a *workbook* to facilitate natural language queries of
data.

To use *SQL-GPT* to answer a question about your data:

1. Enter a natural-language question into the *SQL-GPT* textbox.
2. Click **Generate SQL**.  A new *SQL Block* will be created at
   the bottom of the *worksheet*, pre-populated with the query *SQL-GPT*
   generated to answer the question posed.
3. Click <img alt="wsb_icon_run" /> in that new *SQL Block* to run the generated query.

*SQL-GPT* will generate more accurate queries when it is given more context for
the data it is querying.  To provide *SQL-GPT* insight into the data and
relationships between the data, see [SQL-GPT Concepts](/content/sql-gpt/concepts) for a
*SQL-GPT* overview and [SQL-GPT Syntax](/content/sql/sqlgpt) for the complete SQL syntax
supporting *SQL-GPT*.

Once a custom *SQL-GPT context* has been created, click
**Configure** to assign the *context* to the current *worksheet*,
and ask the natural-language question again.

<a />

### SQL Blocks

A *SQL Block* should contain a single SQL statement, which can be independently
evaluated.

Each *SQL Block* has a play button on the left side that allows you to run the
SQL contained in the block. Alternatively, you can run all the *SQL Blocks* in a
*worksheet* in sequence by clicking the **Run All** button at the
top of the screen.

If you want to create a visualization for a *SQL Block*, you will first need to
create and run a `SELECT` statement. See [Visualizations](/content/admin/workbench/workbooks#wb-vis) for directions
on how to create visualizations in your *workbook*.

<Frame>
  <img alt="../images/wb.workbook_sql_block.png" />
</Frame>

#### Type-ahead

*SQL Blocks* feature a type-ahead capability that will suggest SQL syntax and
database object names. When you begin typing, keywords will appear, and you will
be able to select one of the items using the arrow keys. Pressing
**Enter** while one of these keywords is highlighted will add it
to your *SQL Block*.

For database objects, simply type a schema name and a dot (.); you should see
all the tables and views in that schema appear in a dropdown list.

#### Running Individual Blocks

To run a *SQL Block*, click the play button next to it. When the job has
finished, you will see an output notifying you of the success or failure. If you
run a `SELECT` statement, you will see the result data presented in a data
grid format, along with other visualization options. The data grid and
visualizations are directly tied to the corresponding `SELECT` statement in
the *SQL Block*.

#### Running All Blocks

You may also run the entire *workbook* from start to finish, in sequence, by
clicking the **Run All** button in the upper right of the
*worksheet*. As each *SQL Block* completes, the next will run until an error or
the end of the *workbook* is reached.

#### Canceling Jobs

If you want to stop a long-running query or a long sequence of *SQL Blocks*, you
can easily cancel the running jobs associated with each query. Use the
**Queries** button at the top of the screen. This will open a
modal with a list of all the running jobs in the system, any of which can be
stopped by checking the box next to the job and pressing the
**Cancel Selected** button.

<Frame>
  <img alt="../images/wb.jobs.png" />
</Frame>

<a />

#### Visual Explain Plan

The explain plan visualizer is a graphical complement to using the `EXPLAIN`
keyword in a given query, providing visual detail to the SQL query's execution
plan, execution time, and native API translation(s).

In a given *SQL Block*, use the hierarchy icon to select
**Explain Plan**.  This will not execute the query but allow the
database to walk through the native actions necessary to execute the query and
show the plan.

Use the hierarchy icon to select **Run and Analyze** to execute
the query and display the execution time for each step in the plan.

<Frame>
  <img alt="../images/wb.workbook_sql_explain.png" />
</Frame>

<a />

### Map Blocks

A *Map Block* starts out as an empty map but can be configured to display
geospatial data from a table.

Click on **Configure** to pick a source table and longitude &
latitude columns.  Then click **Update** to display the data on
the map.

<Frame>
  <img alt="../images/wb.workbook_vis_map.png" />
</Frame>

<a />

### Graph Blocks

A *Graph Block* starts out as a blank page but can be configured to display
graph data from a graph output table.

Click on **Configure** to pick a source graph table and specify
the relevant node & edge columns.  Then, click **Update** to
display the graph within the block.

<Frame>
  <img alt="../images/wb.explore_wsb_graph.png" />
</Frame>

#### Graph Example

Given a `person` table of names & roles of people and a `connection` table
linking those people together, a social graph of those people and their
relations can be created by entering the following SQL into a *SQL Block* and
clicking <img alt="wsb_icon_run" />:

```sql CREATE GRAPH Example theme={null}
CREATE or REPLACE directed GRAPH kgraph
(
    NODES => INPUT_TABLE
    (
        SELECT name AS NAME, CONCAT(CONCAT(role,':'),locale) AS LABEL
        FROM person
    ),
    EDGES => INPUT_TABLE
    (
        SELECT person_a AS NODE1_NAME, person_b AS NODE2_NAME
        FROM connection
    ),
    OPTIONS => KV_PAIRS(graph_table = 'kgraph_table')
)
```

This will generate two output tables, which can be used to generate the graph:

* `kgraph_table` - the set of all edges (connections between people) in the
  data set
* `kgraph_table_nodes` - the set of all nodes (people) in the data set

<p><strong>Graph Example - Edges Only</strong></p>

To create the graph with just the names of people related to each other, define:

| Field                  | Value             | Description                                        |
| ---------------------- | ----------------- | -------------------------------------------------- |
| **Edge Table Name**    | `kgraph_table`    | Name of the edge table                             |
| **Edge Source Column** | `EDGE_NODE1_NAME` | Name of the person on one side of a relation       |
| **Edge Target Column** | `EDGE_NODE2_NAME` | Name of the person on the other side of a relation |

<p><strong>Graph Example - Edges & Nodes</strong></p>

To create the graph with the names of people related to each other and
additional information about the people, both the edge & node table will need to
be referenced in the configuration.  The data in the two tables will be linked
together using their respective `ID` columns:

* `kgraph_table.EDGE_NODE1_ID`
* `kgraph_table.EDGE_NODE2_ID`
* `kgraph_table_nodes.NODE_ID`

| Field                  | Value                | Description                                       |
| ---------------------- | -------------------- | ------------------------------------------------- |
| **Edge Table Name**    | `kgraph_table`       | name of the edge table                            |
| **Edge Source Column** | `EDGE_NODE1_ID`      | ID of the person on one side of a relation        |
| **Edge Target Column** | `EDGE_NODE2_ID`      | ID of the person on the other side of a relation  |
| **Node Table Name**    | `kgraph_table_nodes` | name of the nodes table                           |
| **Node ID Column**     | `NODE_ID`            | ID of a person                                    |
| **Node Name Column**   | `NODE_NAME`          | Name of a person                                  |
| **Node Label Column**  | `NODE_LABEL`         | Label containing extra information about a person |

<Note>
  When using both the edge & node tables, the column values for
  the **Node ID Column** must match those for the
  **Edge Source Column** & **Edge Target Column**
  in that they should all be referencing either their respective `ID` or
  respective `NAME` columns.
</Note>

<a />

### Presentation Blocks

*Presentation blocks* help you annotate, elaborate on, and provide insight into
the *data blocks* on your *worksheet*.  These blocks can be moved up and down,
independently of other *blocks* and provide rich flexibility in presenting your
results.  For more information on interacting with these blocks, see:

* [Text Blocks](/content/admin/workbench/ui/explore#wb-explore-ws-tb)
* [Image Blocks](/content/admin/workbench/ui/explore#wb-explore-ws-ib)
* [HTML Blocks](/content/admin/workbench/ui/explore#wb-explore-ws-hb)

<a />

## Visualizations

Once you have run a *SQL Block* that contains a `SELECT` statement, you have
the option to visualize the result data. By default, the data will be displayed
as a grid in the **Data** tab below the *SQL Block*. If you
select the **Visualization** tab, you can visualize the data
using one of the following modes:

* [Bar Chart](/content/admin/workbench/workbooks#wb-vis-bar)
* [Line Chart](/content/admin/workbench/workbooks#wb-vis-line)
* [Pie Chart](/content/admin/workbench/workbooks#wb-vis-pie)
* [Scatter Plot](/content/admin/workbench/workbooks#wb-vis-scatter)
* [Big Number](/content/admin/workbench/workbooks#wb-vis-bignum)
* [Graph](/content/admin/workbench/workbooks#wb-vis-graph)
* [Map](/content/admin/workbench/workbooks#wb-vis-map)

<Frame>
  <img alt="../images/wb.workbook_vis.png" />
</Frame>

Choose a visualization style, click **Configure** to set up the
graph, and then click **Update** to display the graph.

<a />

### Bar Chart

The *Bar Chart Visualization* allows you to view volumes of data by group.

<Frame>
  <img alt="../images/wb.workbook_vis_bar.png" />
</Frame>

<a />

### Line Chart

The *Line Chart Visualization* shows you trends across a dimension.

<Frame>
  <img alt="../images/wb.workbook_vis_line.png" />
</Frame>

<a />

### Pie Chart

The *Pie Chart Visualization* shows you the numeric proportion of values across
several groups.

<Frame>
  <img alt="../images/wb.workbook_vis_pie.png" />
</Frame>

<a />

### Scatter Plot

The *Scatter Plot Visualization* shows you two dimensions compared against each
other or two values compared to (or categorized by) a third value, plotted on a
coordinate system.

<Frame>
  <img alt="../images/wb.workbook_vis_scatter.png" />
</Frame>

<a />

### Big Number

The *Big Number Visualization* simply shows the result of a query in a large
font.  Multiple records are shown as a comma-delimited list of values.

<Frame>
  <img alt="../images/wb.workbook_vis_bignum.png" />
</Frame>

<a />

### Graph

The *Graph Visualization* is equivalent in interface to the
[graph block](/content/admin/workbench/workbooks#wb-graph-block).

<a />

### Map

The *Map Visualization* is equivalent in interface to the
[map block](/content/admin/workbench/workbooks#wb-map-block).

<a />

## Importing Data

Whether you’re importing directly via SQL, or using the import wizard, loading
data into *Kinetica* is easy. Several data sources are supported when ingesting
data through either mechanism. See [Data Sources](/content/concepts/data_sources) for more
information on *data sources* or [CREATE DATA SOURCE](/content/sql/ddl/create-data-source#sql-create-data-source) for
managing them in SQL.

<a />

### Import Data Wizard

Importing data via the wizard can be done in several easy steps.

1. Click **Import** on the top menu to reach the
   *Importing Your Data* page.

2. Choose the import mechanism to use:

   * **File Upload** - Import data from a file on your local file
     system
   * **Kinetica Filesystem** - Import data from a file that has
     already been uploaded to *KiFS*
   * **Azure Blob Storage**, **Amazon S3**,
     **Kafka Stream**, **HDFS** - Import data from
     one of these external providers.
   * **Generic JDBC** - Import data from a remote database using
     a generic JDBC driver
   * **Kinetica** - Import data from another Kinetica cluster
     using the Kinetica JDBC driver
   * **JDBC Data Sources** - Import data from a remote system
     using any of the available data source drivers

3. If ingesting from a external provider like *S3*, you can either select an
   existing [data source](/content/sql/ddl/create-data-source#sql-create-data-source) corresponding to
   that provider or create a new one.

4. Enter the path to the file, and choose the file format.

5. Next, select the [schema](/content/sql/ddl/create-schema#sql-create-schema) in which your new
   table should be created. Then give your new table a name. By default, records
   that fail to be parsed or loaded correctly will be skipped and the import
   process will proceed to the subsequent records.  To stop the import if an
   error occurs on a record, check the appropriate box.
   Optionally, define the structure of the target table if that table does not
   yet exist.  If the table doesn't exist and the structure is not defined here,
   it will be intuited by analyzing the source file headers & data.

6. Once the ingest has been configured, the corresponding SQL statement for
   loading the data will be displayed, which you can copy into a *worksheet* for
   use later. Click **Import** to begin the import immediately,
   and wait for the job to complete. You can see the status of jobs in the
   **History** tab, and you can see error messages to help you
   troubleshoot the import there as well.

For a more detailed look at the configuration options available through the
*Import Wizard*, see [Import](/content/admin/workbench/ui/import).

<Frame>
  <img alt="../images/wb.import.png" />
</Frame>

<Frame>
  <img alt="../images/wb.importing_data_summary.png" />
</Frame>

<a />

### Import via SQL

You can use the SQL generated by the *Import Data Wizard* in your SQL
*Worksheets*, or you can write your own ingest statements. When importing from a
remote location, like *S3*, you will need to create a *data source* first. See
[CREATE DATA SOURCE](/content/sql/ddl/create-data-source#sql-create-data-source) for the syntax used to create one.

For example, to load taxi data from *S3*:

```sql Create an S3 Data Source theme={null}
CREATE OR REPLACE DATA SOURCE quickstart
LOCATION = 'S3'
WITH OPTIONS (
    BUCKET NAME = 'quickstartpublic',
    REGION = 'us-west-1'
)
```

Once you’ve created a data source, you can load data using the
[LOAD INTO](/content/sql/load#sql-load-into) statement.

```sql Load Taxi Data from S3 theme={null}
LOAD DATA INTO taxi_data_historical
FROM FILE PATHS 'taxi_data.parquet'
FORMAT PARQUET
WITH OPTIONS (
    DATA SOURCE = 'quickstart'
)
```


# AAW REST API
Source: https://docs.kinetica.com/content/api/aaw/index





# API Concepts
Source: https://docs.kinetica.com/content/api/concepts



<a />

## Native

* [C++ API Documentation](/content/api/cpp) | [C++ GitHub Repo](https://github.com/kineticadb/kinetica-api-cpp)
* [C# API Documentation](/content/api/cs) | [C# GitHub Repo](https://github.com/kineticadb/kinetica-api-cs)
* [Java API Documentation](/content/api/java) | [Java GitHub Repo](https://github.com/kineticadb/kinetica-api-java)
* [JavaScript API Documentation](/content/api/javascript) | [JavaScript GitHub Repo](https://github.com/kineticadb/kinetica-api-javascript)
* [Node.js API Documentation](/content/api/nodejs) | [Node.js GitHub Repo](https://github.com/kineticadb/kinetica-api-javascript)
* [Python API Documentation](/content/api/python) | [Python GitHub Repo](https://github.com/kineticadb/kinetica-api-python)
* [REST API Documentation](/content/api/rest)

<a />

## Connecting via API

The following shows the means of connecting to *Kinetica* via the various APIs
available.

### HTTP Connections

<CodeGroup>
  ```c++ C++ theme={null}
  #include "gpudb/GPUdb.hpp"

  gpudb::GPUdb::Options options = gpudb::GPUdb::Options();
  options.setUsername("<username>");
  options.setPassword("<password>");

  gpudb::GPUdb kinetica("http://<db.host>:9191", options);
  ```

  ```c# C# theme={null}
  using kinetica;

  Kinetica.Options options = new Kinetica.Options();
  options.Username = "<username>";
  options.Password = "<password>";

  Kinetica kinetica = new Kinetica("http://<db.host>:9191", options );
  ```

  ```java Java theme={null}
  import com.gpudb.GPUdb;

  GPUdb.Options options = new GPUdb.Options()
      .setUsername("<username>")
      .setPassword("<password>");

  GPUdb kinetica = new GPUdb("http://<db.host>:9191", options);
  ```

  ```html JavaScript theme={null}
  <script type="text/javascript" src="GPUdb.js"></script>
  <script type="text/javascript">
  var kinetica = new GPUdb(
      "http://<db.host>:9191",
      {
          username: "<username>",
          password: "<password>"
      }
  );
  </script>
  ```

  ```javascript Node.js theme={null}
  // To install Kinetica, first run this from the CLI: npm i @kinetica/gpudb
  var GPUdb = require("@kinetica/gpudb");
  var kinetica = new GPUdb(
      ["http://<db.host>:9191"],
      {
          username: "<username>",
          password: "<password>"
      }
  );
  ```

  ```python Python theme={null}
  import gpudb

  options = gpudb.GPUdb.Options()
  options.username = "<username>"
  options.password = "<password>"

  kinetica = gpudb.GPUdb(
      host=["http://<db.host>:9191"],
      options = options
  )
  ```

  ```bash REST theme={null}
  # Example call invoking the /show/system/properties endpoint
  #   and requesting the database's version number
  curl --location --request POST \
       'http://<db.host>:9191/show/system/properties' \
       --user <username>:<password> \
       --data '{"options": {"properties": "version.gpudb_core_version"}}' \
       --header 'cache-control: no-cache' \
       --header 'content-type: application/json'
  ```
</CodeGroup>

<a />

### HTTPS Connections with Certificate Validation

<CodeGroup>
  ```c++ C++ theme={null}
  #include "gpudb/GPUdb.hpp"

  gpudb::GPUdb::Options options = gpudb::GPUdb::Options();
  options.setUsername("<username>");
  options.setPassword("<password>");

  gpudb::GPUdb kinetica("https://<db.host>:8082/gpudb-0", options);
  ```

  ```c# C# theme={null}
  using kinetica;

  Kinetica.Options options = new Kinetica.Options();
  options.Username = "<username>";
  options.Password = "<password>";

  Kinetica kinetica = new Kinetica("https://<db.host>:8082/gpudb-0", options );
  ```

  ```java Java theme={null}
  import com.gpudb.GPUdb;

  GPUdb.Options options = new GPUdb.Options()
      .setUsername("<username>")
      .setPassword("<password>");

  // By default, the Java system CA trust store will be used;
  //   to specify a different trust store, use these options:
  options.setTrustStoreFilePath("</path/to/truststore.jks>");
  options.setTrustStorePassword("<trustStorePassword>");

  GPUdb kinetica = new GPUdb("https://<db.host>:8082/gpudb-0", options);
  ```

  ```html JavaScript theme={null}
  <script type="text/javascript" src="GPUdb.js"></script>
  <script type="text/javascript">
  var kinetica = new GPUdb(
      "https://<db.host>:8082/gpudb-0",
      {
          username: "<username>",
          password: "<password>"
      }
  );
  </script>
  ```

  ```javascript Node.js theme={null}
  // To install Kinetica, first run this from the CLI: npm i @kinetica/gpudb
  var GPUdb = require("@kinetica/gpudb");
  var kinetica = new GPUdb(
      ["https://<db.host>:8082/gpudb-0"],
      {
          username: "<username>",
          password: "<password>"
      }
  );
  ```

  ```python Python theme={null}
  import gpudb

  options = gpudb.GPUdb.Options()
  options.username = "<username>"
  options.password = "<password>"

  kinetica = gpudb.GPUdb(
      host=["https://<db.host>:8082/gpudb-0"],
      options = options
  )
  ```

  ```bash REST theme={null}
  # Example call invoking the /show/system/properties endpoint
  #   and requesting the database's version number
  curl --location --request POST \
       'https://<db.host>:8082/gpudb-0/show/system/properties' \
       --user <username>:<password> \
       --data '{"options": {"properties": "version.gpudb_core_version"}}' \
       --header 'cache-control: no-cache' \
       --header 'content-type: application/json'
  ```
</CodeGroup>

<a />

### HTTPS Connections without Certificate Validation

<Info>
  Using these setups, no certificate validation of any kind will be
  performed; not recommended for production deployments.

  To bypass certificate checks in JDBC, see
  [Secure Connections](/content/connectors/sql_guide#jdbc-connecting-secure).  To bypass certificate checks
  in *KiSQL*, see [Parameterized Options](/content/tools/kisql#kisql-conn-opt).
</Info>

<CodeGroup>
  ```java Java theme={null}
  import com.gpudb.GPUdb;

  GPUdb.Options options = new GPUdb.Options()
      .setBypassSslCertCheck(true)
      .setUsername("<username>")
      .setPassword("<password>");

  GPUdb kinetica = new GPUdb("https://<db.host>:8082/gpudb-0", options);
  ```

  ```python Python theme={null}
  import gpudb

  options = gpudb.GPUdb.Options()
  options.username = "<username>"
  options.password = "<password>"
  options.skip_ssl_cert_verification = True

  kinetica = gpudb.GPUdb(
      host=["https://<db.host>:8082/gpudb-0"],
      options = options
  )
  ```

  ```bash REST theme={null}
  # Example call invoking the /show/system/properties endpoint
  #   and requesting the database's version number
  curl --location --request POST \
       'https://<db.host>:8082/gpudb-0/show/system/properties' \
       --user <username>:<password> \
       --data '{"options": {"properties": "version.gpudb_core_version"}}' \
       --insecure \
       --header 'cache-control: no-cache' \
       --header 'content-type: application/json'
  ```
</CodeGroup>

<a />

### HTTPS Connections with OIDC/OAuth Authentication

<CodeGroup>
  ```c++ C++ theme={null}
  #include "gpudb/GPUdb.hpp"

  gpudb::GPUdb::Options options = gpudb::GPUdb::Options();
  options.setOauthToken("<oauthToken>");

  gpudb::GPUdb kinetica("https://<db.host>:8082/gpudb-0", options);
  ```

  ```c# C# theme={null}
  using kinetica;

  Kinetica.Options options = new Kinetica.Options();
  options.OauthToken = "<oauthToken>";

  Kinetica kinetica = new Kinetica("https://<db.host>:8082/gpudb-0", options );
  ```

  ```java Java theme={null}
  import com.gpudb.GPUdb;

  GPUdb.Options options = new GPUdb.Options()
      .setOauthToken("<oauthToken>");

  GPUdb kinetica = new GPUdb("https://<db.host>:8082/gpudb-0", options);
  ```

  ```html JavaScript theme={null}
  <script type="text/javascript" src="GPUdb.js"></script>
  <script type="text/javascript">
  var kinetica = new GPUdb(
      "https://<db.host>:8082/gpudb-0",
      {
          oauth_token: "<oauthToken>"
      }
  );
  </script>
  ```

  ```javascript Node.js theme={null}
  // To install Kinetica, first run this from the CLI: npm i @kinetica/gpudb
  var GPUdb = require("@kinetica/gpudb");
  var kinetica = new GPUdb(
      ["https://<db.host>:8082/gpudb-0"],
      {
          oauth_token: "<oauthToken>"
      }
  );
  ```

  ```python Python theme={null}
  import gpudb

  options = gpudb.GPUdb.Options()
  options.oauth_token = "<oauthToken>"

  kinetica = gpudb.GPUdb(
      host=["https://<db.host>:8082/gpudb-0"],
      options = options
  )
  ```

  ```bash REST theme={null}
  # Example call invoking the /show/system/properties endpoint
  #   and requesting the database's version number
  curl --location --request POST \
       'https://<db.host>:8082/gpudb-0/show/system/properties' \
       --oauth2-bearer "<token>" \
       --data '{"options": {"properties": "version.gpudb_core_version"}}' \
       --header 'cache-control: no-cache' \
       --header 'content-type: application/json'
  ```
</CodeGroup>

<br />

<a />

## Compatibility Matrix

The following chart shows the version compatibilities between the various APIs
and a target database server.  While only the major & minor version numbers
*(6.2, 7.0, 7.1, 7.2)* must match to achieve interoperability, the complete
feature set for a given database version can only be utilized via the
corresponding API version, depicted below.

| Database | C++    | C#     | Java   | Javascript | Node.js | Python |
| -------- | ------ | ------ | ------ | ---------- | ------- | ------ |
| 6.2      | 6.2.\* | 6.2.\* | 6.2.\* | 6.2.\*     | 6.2.\*  | 6.2.\* |
| 7.0.X    | 7.0.X  | 7.0.X  | 7.0.X  | 7.0.X      | 7.0.X   | 7.0.X  |
| 7.1.X    | 7.1.X  | 7.1.X  | 7.1.X  | 7.1.X      | 7.1.X   | 7.1.X  |
| 7.2.X    | 7.2.X  | 7.2.X  | 7.2.X  | 7.2.X      | 7.2.X   | 7.2.X  |

<br />

## Dynamic Schemas

When working with APIs, it is helpful to have an understanding of how data is
returned by the database.  For a detailed breakdown in Java & Python, see
[Dynamic Schemas](/content/api/dynamic_schemas).


# gpudb::BinaryHttpRequest
Source: https://docs.kinetica.com/content/api/cpp/classgpudb_1_1BinaryHttpRequest

gpudb::BinaryHttpRequest — Kinetica C++ API

<div>
  <div>
    <p><code>#include \<<a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/Http.hpp">gpudb/Http.hpp</a>></code></p>

    <table>
      <tr>
        <td>
          <h2> Public Member Functions</h2>
        </td>
      </tr>

      <tr>
        <td> </td>
        <td><a href="#a5b3b194d0c1979e4aa8313c0fb6cddf2">BinaryHttpRequest</a> ()</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td> </td>
        <td><a href="#aac5725f560518832d8d0518fb2ba3f6c">BinaryHttpRequest</a> (const <a href="/content/api/cpp/classgpudb_1_1HttpUrl">HttpUrl</a> \&url)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>const std::vector\< uint8\_t > \* </td>
        <td><a href="#aa9646415f94cec4eee3414b6a07e0a5e">getRequestBody</a> ()</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>void </td>
        <td><a href="#ae486caef6f5052cf479a4519f6e247d3">setRequestBody</a> (const std::vector\< uint8\_t > \*requestBody)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td> Public Member Functions inherited from <a href="/content/api/cpp/classgpudb_1_1HttpRequest">gpudb::HttpRequest</a></td>
      </tr>

      <tr>
        <td> </td>
        <td><a href="/content/api/cpp/classgpudb_1_1HttpRequest#a37734f6f56aea5ca7a955689df127270">HttpRequest</a> ()</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td> </td>
        <td><a href="/content/api/cpp/classgpudb_1_1HttpRequest#ad1752963a9cfd5877274adc614eb7217">HttpRequest</a> (const <a href="/content/api/cpp/classgpudb_1_1HttpUrl">HttpUrl</a> \&url)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>boost::asio::ssl::context \* </td>
        <td><a href="/content/api/cpp/classgpudb_1_1HttpRequest#a78f2c8c9cfd9d8b108e2c80e48fd5bb3">getSslContext</a> ()</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>const <a href="/content/api/cpp/classgpudb_1_1HttpUrl">HttpUrl</a> & </td>
        <td><a href="/content/api/cpp/classgpudb_1_1HttpRequest#a19c14dc41b88a56188234b04f6cfdd1e">getUrl</a> () const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>const std::string & </td>
        <td><a href="/content/api/cpp/classgpudb_1_1HttpRequest#a14b7279c152cccfccb063dde5d48904d">getRequestMethod</a> () const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>const std::string & </td>
        <td><a href="/content/api/cpp/classgpudb_1_1HttpRequest#a68d826c6b3bd5e193ba5fb0ad907b974">getRequestHeader</a> (const std::string \&key) const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>std::map\< std::string, std::string > & </td>
        <td><a href="/content/api/cpp/classgpudb_1_1HttpRequest#a45d5101d77de989d696f6650a3bb149a">getRequestHeaders</a> ()</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>size\_t </td>
        <td><a href="/content/api/cpp/classgpudb_1_1HttpRequest#ac19a060000cdddda0dae91a405e03b4d">getTimeout</a> () const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>void </td>
        <td><a href="/content/api/cpp/classgpudb_1_1HttpRequest#a89ca21b5542978862b824a74bfc1ca91">setSslContext</a> (boost::asio::ssl::context \*sslContext)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>void </td>
        <td><a href="/content/api/cpp/classgpudb_1_1HttpRequest#ab1fcc7e6bcf05b685e2e100922838553">setBypassSslCertCheck</a> (const bool value)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>void </td>
        <td><a href="/content/api/cpp/classgpudb_1_1HttpRequest#a50c26e019fbabf02294fb406aea995fe">setUrl</a> (const <a href="/content/api/cpp/classgpudb_1_1HttpUrl">HttpUrl</a> \&url)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>void </td>
        <td><a href="/content/api/cpp/classgpudb_1_1HttpRequest#a1bb786076bfa996fd0de13a78fe5f29e">setRequestMethod</a> (const std::string \&method)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>void </td>
        <td><a href="/content/api/cpp/classgpudb_1_1HttpRequest#a18b2e464899092c74796ff98546a79f9">addRequestHeader</a> (const std::string \&key, const std::string \&value)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>void </td>
        <td><a href="/content/api/cpp/classgpudb_1_1HttpRequest#ac071226389d433cc9d17cca6b7b45dea">setTimeout</a> (const size\_t timeout)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>void </td>
        <td><a href="/content/api/cpp/classgpudb_1_1HttpRequest#a446ed6ac41b95ba5bf30e680ab127016">send</a> (<a href="/content/api/cpp/classgpudb_1_1HttpResponse">HttpResponse</a> \&response)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>
    </table>

    <table>
      <tr>
        <td>
          <h2> Protected Member Functions</h2>
        </td>
      </tr>

      <tr>
        <td>virtual void </td>
        <td><a href="#ae0d4fa813afd5072260625c2b2e0f3ef">read</a> (const void \*\&data, size\_t \&length) const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>
    </table>

    <table>
      <tr>
        <td>
          <h2> Additional Inherited Members</h2>
        </td>
      </tr>

      <tr>
        <td> Static Public Attributes inherited from <a href="/content/api/cpp/classgpudb_1_1HttpRequest">gpudb::HttpRequest</a></td>
      </tr>

      <tr>
        <td>static const std::string </td>
        <td><a href="/content/api/cpp/classgpudb_1_1HttpRequest#a25d2f7f96614671a0df582ffd7c5a6f7">GET</a></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>static const std::string </td>
        <td><a href="/content/api/cpp/classgpudb_1_1HttpRequest#a8e18a9e646fa90b721df81e4c7ae6bc3">HEAD</a></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>static const std::string </td>
        <td><a href="/content/api/cpp/classgpudb_1_1HttpRequest#a3caf91db515a8b214e52f1f4a8492ada">POST</a></td>
      </tr>

      <tr>
        <td> </td>
      </tr>
    </table>

    <h2>Detailed Description</h2>

    <div>
      <p>Definition at line <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/Http.hpp#L124">124</a> of file <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/Http.hpp">Http.hpp</a>.</p>
    </div>

    <h2>Constructor & Destructor Documentation</h2>
    <h2><span><a href="#a5b3b194d0c1979e4aa8313c0fb6cddf2">◆ </a></span>BinaryHttpRequest() <span>\[1/2]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>gpudb::BinaryHttpRequest::BinaryHttpRequest </td>
            <td>(</td>

            <td>
              <span>
                <span />
              </span>
            </td>

            <td>)</td>

            <td />
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#aac5725f560518832d8d0518fb2ba3f6c">◆ </a></span>BinaryHttpRequest() <span>\[2/2]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>gpudb::BinaryHttpRequest::BinaryHttpRequest </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/classgpudb_1_1HttpUrl">HttpUrl</a> &</td>
            <td><span><span>url</span></span></td>
            <td>)</td>

            <td />
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2>Member Function Documentation</h2>
    <h2><span><a href="#aa9646415f94cec4eee3414b6a07e0a5e">◆ </a></span>getRequestBody()</h2>

    <div>
      <div>
        <table>
          <tr>
            <td>const std::vector\< uint8\_t > \* gpudb::BinaryHttpRequest::getRequestBody </td>
            <td>(</td>

            <td>
              <span>
                <span />
              </span>
            </td>

            <td>)</td>

            <td />
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#ae0d4fa813afd5072260625c2b2e0f3ef">◆ </a></span>read()</h2>

    <div>
      <div>
        <table>
          <tr>
            <td>
              <table>
                <tr>
                  <td>virtual void gpudb::BinaryHttpRequest::read </td>
                  <td>(</td>
                  <td>const void \*&</td>
                  <td><span><span>data</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>size\_t &</td>
                  <td><span><span>length</span></span> ) const</td>
                </tr>
              </table>
            </td>

            <td> <span><span>protected</span><span>virtual</span></span> </td>
          </tr>
        </table>
      </div>

      <div>
        <p>Reimplemented from <a href="/content/api/cpp/classgpudb_1_1HttpRequest#abdb6efcd2036655210fbeb7f52a5755c">gpudb::HttpRequest</a>.</p>
      </div>
    </div>

    <h2><span><a href="#ae486caef6f5052cf479a4519f6e247d3">◆ </a></span>setRequestBody()</h2>

    <div>
      <div>
        <table>
          <tr>
            <td>void gpudb::BinaryHttpRequest::setRequestBody </td>
            <td>(</td>
            <td>const std::vector\< uint8\_t > \*</td>
            <td><span><span>requestBody</span></span></td>
            <td>)</td>

            <td />
          </tr>
        </table>
      </div>

      <div />
    </div>

    <hr />

    The documentation for this class was generated from the following file:

    <ul>
      <li>gpudb/<a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/Http.hpp">Http.hpp</a></li>
    </ul>
  </div>
</div>


# gpudb::BinaryHttpResponse
Source: https://docs.kinetica.com/content/api/cpp/classgpudb_1_1BinaryHttpResponse

gpudb::BinaryHttpResponse — Kinetica C++ API

<div>
  <div>
    <p><code>#include \<<a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/Http.hpp">gpudb/Http.hpp</a>></code></p>

    <table>
      <tr>
        <td>
          <h2> Public Member Functions</h2>
        </td>
      </tr>

      <tr>
        <td>const std::vector\< uint8\_t > & </td>
        <td><a href="#ad1666c70e6543427c1367386a23da0ab">getResponseBody</a> () const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td> Public Member Functions inherited from <a href="/content/api/cpp/classgpudb_1_1HttpResponse">gpudb::HttpResponse</a></td>
      </tr>

      <tr>
        <td> </td>
        <td><a href="/content/api/cpp/classgpudb_1_1HttpResponse#a6c6ee5e25ecae7403caf19431ad38a03">HttpResponse</a> ()</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>virtual </td>
        <td><a href="/content/api/cpp/classgpudb_1_1HttpResponse#aed7883e9757fa8dc0934b68836d7ccbb">\~HttpResponse</a> ()</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>const std::string & </td>
        <td><a href="/content/api/cpp/classgpudb_1_1HttpResponse#a5ce9bc300f9c0d29c4fa1507bb196b95">getResponseVersion</a> () const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>unsigned int </td>
        <td><a href="/content/api/cpp/classgpudb_1_1HttpResponse#a4aebe90dcb0dd84d580d9015d704256f">getResponseCode</a> () const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>const std::string & </td>
        <td><a href="/content/api/cpp/classgpudb_1_1HttpResponse#a66820dd35ecade13d5defc03d20fffd3">getResponseMessage</a> () const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>const std::string & </td>
        <td><a href="/content/api/cpp/classgpudb_1_1HttpResponse#af636df0b0c56f90aa8f3bac8499223e6">getResponseHeader</a> (const std::string \&key) const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>const std::map\< std::string, std::string > & </td>
        <td><a href="/content/api/cpp/classgpudb_1_1HttpResponse#aad019b2509eea8fc830bd4f92fa6de4c">getResponseHeaders</a> () const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>
    </table>

    <table>
      <tr>
        <td>
          <h2> Protected Member Functions</h2>
        </td>
      </tr>

      <tr>
        <td>virtual void </td>
        <td><a href="#a82fcdbbc49b63af14220aabaf8b7bcc3">write</a> (const void \*data, const size\_t length)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>
    </table>

    <h2>Detailed Description</h2>

    <div>
      <p>Definition at line <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/Http.hpp#L183">183</a> of file <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/Http.hpp">Http.hpp</a>.</p>
    </div>

    <h2>Member Function Documentation</h2>
    <h2><span><a href="#ad1666c70e6543427c1367386a23da0ab">◆ </a></span>getResponseBody()</h2>

    <div>
      <div>
        <table>
          <tr>
            <td>const std::vector\< uint8\_t > & gpudb::BinaryHttpResponse::getResponseBody </td>
            <td>(</td>

            <td>
              <span>
                <span />
              </span>
            </td>

            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#a82fcdbbc49b63af14220aabaf8b7bcc3">◆ </a></span>write()</h2>

    <div>
      <div>
        <table>
          <tr>
            <td>
              <table>
                <tr>
                  <td>virtual void gpudb::BinaryHttpResponse::write </td>
                  <td>(</td>
                  <td>const void \*</td>
                  <td><span><span>data</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const size\_t</td>
                  <td><span><span>length</span></span> )</td>
                </tr>
              </table>
            </td>

            <td> <span><span>protected</span><span>virtual</span></span> </td>
          </tr>
        </table>
      </div>

      <div>
        <p>Reimplemented from <a href="/content/api/cpp/classgpudb_1_1HttpResponse#a4c806d9910ed08a2b0d4fb2f2078ecd5">gpudb::HttpResponse</a>.</p>
      </div>
    </div>

    <hr />

    The documentation for this class was generated from the following file:

    <ul>
      <li>gpudb/<a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/Http.hpp">Http.hpp</a></li>
    </ul>
  </div>
</div>


# gpudb::FailbackPollerService
Source: https://docs.kinetica.com/content/api/cpp/classgpudb_1_1FailbackPollerService

gpudb::FailbackPollerService — Kinetica C++ API

<div>
  <div>
    <p><code>#include \<<a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/FailbackPollerService.hpp">gpudb/FailbackPollerService.hpp</a>></code></p>

    <table>
      <tr>
        <td>
          <h2> Public Member Functions</h2>
        </td>
      </tr>

      <tr>
        <td> </td>
        <td><a href="#a40f7cc24d97d6d170a2df9bd74d235fd">FailbackPollerService</a> (const <a href="/content/api/cpp/classgpudb_1_1GPUdb">gpudb::GPUdb</a> \&db, long pollingInterval)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td> </td>
        <td><a href="#ac74e6a0284ce7bf73e411b2707faeb8e">FailbackPollerService</a> (const <a href="/content/api/cpp/classgpudb_1_1FailbackPollerService">FailbackPollerService</a> &)=delete</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/classgpudb_1_1FailbackPollerService">FailbackPollerService</a> & </td>
        <td><a href="#a11e8bc4b546e9049a08780179934a999">operator=</a> (const <a href="/content/api/cpp/classgpudb_1_1FailbackPollerService">FailbackPollerService</a> &)=delete</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>virtual </td>
        <td><a href="#acc289f7500dc02f822692dcd25a8f65a">\~FailbackPollerService</a> ()</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>bool </td>
        <td><a href="#aa091a09a5fdb0c116a5fa9aff47a5f68">isRunning</a> ()</td>
      </tr>

      <tr>
        <td> </td>
        <td>Checks whether the poller is running and returns true or false. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>void </td>
        <td><a href="#ac56bebf172c19ecc6107f239c00fb2c2">start</a> ()</td>
      </tr>

      <tr>
        <td> </td>
        <td>Starts the poller service. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>void </td>
        <td><a href="#a169483d3f8a423a963b17862d0059795">stop</a> ()</td>
      </tr>

      <tr>
        <td> </td>
        <td>Stops the poller service. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>void </td>
        <td><a href="#a0e14bf9a88425de58c09bd71fd0388dd">restart</a> ()</td>
      </tr>

      <tr>
        <td> </td>
      </tr>
    </table>

    <table>
      <tr>
        <td>
          <h2> Static Public Attributes</h2>
        </td>
      </tr>

      <tr>
        <td>static const int </td>
        <td><a href="#ab7ff27496763b049ed486da5cd4e8793">DEFAULT\_START\_DELAY</a></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>static const int </td>
        <td><a href="#a637ff75c5b1af34d09b8888d071d7f01">DEFAULT\_POLLING\_INTERVAL</a></td>
      </tr>

      <tr>
        <td> </td>
      </tr>
    </table>

    <h2>Detailed Description</h2>

    <div>
      <p>Definition at line <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/FailbackPollerService.hpp#L16">16</a> of file <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/FailbackPollerService.hpp">FailbackPollerService.hpp</a>.</p>
    </div>

    <h2>Constructor & Destructor Documentation</h2>
    <h2><span><a href="#a40f7cc24d97d6d170a2df9bd74d235fd">◆ </a></span>FailbackPollerService() <span>\[1/2]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>
              <table>
                <tr>
                  <td>gpudb::FailbackPollerService::FailbackPollerService </td>
                  <td>(</td>
                  <td>const <a href="/content/api/cpp/classgpudb_1_1GPUdb">gpudb::GPUdb</a> &</td>
                  <td><span><span>db</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>long</td>
                  <td><span><span>pollingInterval</span></span> )</td>
                </tr>
              </table>
            </td>

            <td> <span><span>inline</span></span> </td>
          </tr>
        </table>
      </div>

      <div>
        <p>Definition at line <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/FailbackPollerService.hpp#L37">37</a> of file <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/FailbackPollerService.hpp">FailbackPollerService.hpp</a>.</p>
      </div>
    </div>

    <h2><span><a href="#ac74e6a0284ce7bf73e411b2707faeb8e">◆ </a></span>FailbackPollerService() <span>\[2/2]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>
              <table>
                <tr>
                  <td>gpudb::FailbackPollerService::FailbackPollerService </td>
                  <td>(</td>
                  <td>const <a href="/content/api/cpp/classgpudb_1_1FailbackPollerService">FailbackPollerService</a> &</td>

                  <td>
                    <span>
                      <span />
                    </span>
                  </td>

                  <td>)</td>

                  <td />
                </tr>
              </table>
            </td>

            <td> <span><span>delete</span></span> </td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#acc289f7500dc02f822692dcd25a8f65a">◆ </a></span>\~FailbackPollerService()</h2>

    <div>
      <div>
        <table>
          <tr>
            <td>
              <table>
                <tr>
                  <td>virtual gpudb::FailbackPollerService::\~FailbackPollerService </td>
                  <td>(</td>

                  <td>
                    <span>
                      <span />
                    </span>
                  </td>

                  <td>)</td>

                  <td />
                </tr>
              </table>
            </td>

            <td> <span><span>virtual</span></span> </td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2>Member Function Documentation</h2>
    <h2><span><a href="#aa091a09a5fdb0c116a5fa9aff47a5f68">◆ </a></span>isRunning()</h2>

    <div>
      <div>
        <table>
          <tr>
            <td>bool gpudb::FailbackPollerService::isRunning </td>
            <td>(</td>

            <td>
              <span>
                <span />
              </span>
            </td>

            <td>)</td>

            <td />
          </tr>
        </table>
      </div>

      <div>
        <p>Checks whether the poller is running and returns true or false. </p>
      </div>
    </div>

    <h2><span><a href="#a11e8bc4b546e9049a08780179934a999">◆ </a></span>operator=()</h2>

    <div>
      <div>
        <table>
          <tr>
            <td>
              <table>
                <tr>
                  <td><a href="/content/api/cpp/classgpudb_1_1FailbackPollerService">FailbackPollerService</a> & gpudb::FailbackPollerService::operator= </td>
                  <td>(</td>
                  <td>const <a href="/content/api/cpp/classgpudb_1_1FailbackPollerService">FailbackPollerService</a> &</td>

                  <td>
                    <span>
                      <span />
                    </span>
                  </td>

                  <td>)</td>

                  <td />
                </tr>
              </table>
            </td>

            <td> <span><span>delete</span></span> </td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#a0e14bf9a88425de58c09bd71fd0388dd">◆ </a></span>restart()</h2>

    <div>
      <div>
        <table>
          <tr>
            <td>void gpudb::FailbackPollerService::restart </td>
            <td>(</td>

            <td>
              <span>
                <span />
              </span>
            </td>

            <td>)</td>

            <td />
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#ac56bebf172c19ecc6107f239c00fb2c2">◆ </a></span>start()</h2>

    <div>
      <div>
        <table>
          <tr>
            <td>void gpudb::FailbackPollerService::start </td>
            <td>(</td>

            <td>
              <span>
                <span />
              </span>
            </td>

            <td>)</td>

            <td />
          </tr>
        </table>
      </div>

      <div>
        <p>Starts the poller service. </p>
      </div>
    </div>

    <h2><span><a href="#a169483d3f8a423a963b17862d0059795">◆ </a></span>stop()</h2>

    <div>
      <div>
        <table>
          <tr>
            <td>void gpudb::FailbackPollerService::stop </td>
            <td>(</td>

            <td>
              <span>
                <span />
              </span>
            </td>

            <td>)</td>

            <td />
          </tr>
        </table>
      </div>

      <div>
        <p>Stops the poller service. </p>
      </div>
    </div>

    <h2>Member Data Documentation</h2>
    <h2><span><a href="#a637ff75c5b1af34d09b8888d071d7f01">◆ </a></span>DEFAULT\_POLLING\_INTERVAL</h2>

    <div>
      <div>
        <table>
          <tr>
            <td>
              <table>
                <tr>
                  <td>const int gpudb::FailbackPollerService::DEFAULT\_POLLING\_INTERVAL</td>
                </tr>
              </table>
            </td>

            <td> <span><span>static</span></span> </td>
          </tr>
        </table>
      </div>

      <div>
        <p>Definition at line <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/FailbackPollerService.hpp#L19">19</a> of file <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/FailbackPollerService.hpp">FailbackPollerService.hpp</a>.</p>
      </div>
    </div>

    <h2><span><a href="#ab7ff27496763b049ed486da5cd4e8793">◆ </a></span>DEFAULT\_START\_DELAY</h2>

    <div>
      <div>
        <table>
          <tr>
            <td>
              <table>
                <tr>
                  <td>const int gpudb::FailbackPollerService::DEFAULT\_START\_DELAY</td>
                </tr>
              </table>
            </td>

            <td> <span><span>static</span></span> </td>
          </tr>
        </table>
      </div>

      <div>
        <p>Definition at line <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/FailbackPollerService.hpp#L18">18</a> of file <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/FailbackPollerService.hpp">FailbackPollerService.hpp</a>.</p>
      </div>
    </div>

    <hr />

    The documentation for this class was generated from the following file:

    <ul>
      <li>gpudb/<a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/FailbackPollerService.hpp">FailbackPollerService.hpp</a></li>
    </ul>
  </div>
</div>


# gpudb::GPUdb
Source: https://docs.kinetica.com/content/api/cpp/classgpudb_1_1GPUdb

gpudb::GPUdb — Kinetica C++ API

<div>
  <div>
    <p><code>#include \<<a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">gpudb/GPUdb.hpp</a>></code></p>
    <p>Inherits boost::noncopyable.</p>

    <table>
      <tr>
        <td>
          <h2> Classes</h2>
        </td>
      </tr>

      <tr>
        <td>class  </td>
        <td><a href="/content/api/cpp/classgpudb_1_1GPUdb_1_1Options">Options</a></td>
      </tr>

      <tr>
        <td> </td>
      </tr>
    </table>

    <table>
      <tr>
        <td>
          <h2> Public Types</h2>
        </td>
      </tr>

      <tr>
        <td>enum  </td>
        <td><a href="#a37626bfbd9c5e1decfcd08d7851e6719">HASynchronicityMode</a>  <br />   <a href="#a37626bfbd9c5e1decfcd08d7851e6719a218ba93670fd52bcb7e85cb6cdeb0e41">DEFAULT</a> = 0 , <br />   <a href="#a37626bfbd9c5e1decfcd08d7851e6719ab1d6abe65e84db7bbe2700cd5e64e213">NONE</a> , <br />   <a href="#a37626bfbd9c5e1decfcd08d7851e6719a61639ebb6a6b3b23464aee497aebe8c5">SYNCHRONOUS</a> , <br />   <a href="#a37626bfbd9c5e1decfcd08d7851e6719ac2eb38c5e4729805255b17dfb1fe0bb2">SYNCHRONOUS\_PARALLEL</a> , <br />   <a href="#a37626bfbd9c5e1decfcd08d7851e6719a6c599b831053b23576b0a0625322e5f7">ASYNCHRONOUS</a> , <br />   <a href="#a37626bfbd9c5e1decfcd08d7851e6719a9cdf072022e7fa7cec09a7f748a3bc64">ASYNCHRONOUS\_PARALLEL</a> <br /> </td>
      </tr>

      <tr>
        <td> </td>
        <td>A enumeration of high-availability synchronicity override modes. <a href="#a37626bfbd9c5e1decfcd08d7851e6719">More...</a><br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>
    </table>

    <table>
      <tr>
        <td>
          <h2> Public Member Functions</h2>
        </td>
      </tr>

      <tr>
        <td> </td>
        <td><a href="#a4fba86159e87456ae7d24f89d9ad4ac3">GPUdb</a> (const <a href="/content/api/cpp/classgpudb_1_1HttpUrl">HttpUrl</a> \&url, const <a href="/content/api/cpp/classgpudb_1_1GPUdb_1_1Options">Options</a> \&options=<a href="/content/api/cpp/classgpudb_1_1GPUdb_1_1Options">Options</a>())</td>
      </tr>

      <tr>
        <td> </td>
        <td>Pass a single HttpURL and options to instantiate a <a href="/content/api/cpp/classgpudb_1_1GPUdb">GPUdb</a> object. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td> </td>
        <td><a href="#a6b64b5387568345b97a16cbb75355544">GPUdb</a> (const std::string \&url, const <a href="/content/api/cpp/classgpudb_1_1GPUdb_1_1Options">Options</a> \&options=<a href="/content/api/cpp/classgpudb_1_1GPUdb_1_1Options">Options</a>())</td>
      </tr>

      <tr>
        <td> </td>
        <td>Pass a single or multiple, comma-separated URLs as a string and optional options to instantiate a <a href="/content/api/cpp/classgpudb_1_1GPUdb">GPUdb</a> object. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td> </td>
        <td><a href="#a4615d61b10db20286a0a8ebea681a2b8">GPUdb</a> (const std::vector\< <a href="/content/api/cpp/classgpudb_1_1HttpUrl">HttpUrl</a> > \&urls, const <a href="/content/api/cpp/classgpudb_1_1GPUdb_1_1Options">Options</a> \&options=<a href="/content/api/cpp/classgpudb_1_1GPUdb_1_1Options">Options</a>())</td>
      </tr>

      <tr>
        <td> </td>
        <td>Pass multiple HttpURLs and optional options to instantiate a <a href="/content/api/cpp/classgpudb_1_1GPUdb">GPUdb</a> object. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td> </td>
        <td><a href="#af29ae0379d62e6b54e8434631f834f5f">GPUdb</a> (const std::vector\< std::string > \&urls, const <a href="/content/api/cpp/classgpudb_1_1GPUdb_1_1Options">Options</a> \&options=<a href="/content/api/cpp/classgpudb_1_1GPUdb_1_1Options">Options</a>())</td>
      </tr>

      <tr>
        <td> </td>
        <td>Pass multiple strings, each containing a single URL, and optional options to instantiate a <a href="/content/api/cpp/classgpudb_1_1GPUdb">GPUdb</a> object. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td> </td>
        <td><a href="#aefad1360e3a2d96860413a6f3c08a2ce">\~GPUdb</a> ()</td>
      </tr>

      <tr>
        <td> </td>
        <td>Destructor. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>const <a href="/content/api/cpp/classgpudb_1_1HttpUrl">HttpUrl</a> & </td>
        <td><a href="#a98d2ff75f9bb2d749e49547d29bf2cf2">getUrl</a> () const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>const std::vector\< <a href="/content/api/cpp/classgpudb_1_1HttpUrl">HttpUrl</a> > & </td>
        <td><a href="#a3b3644fe3162c0e3402f2dee45f6c074">getUrls</a> () const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>const <a href="/content/api/cpp/classgpudb_1_1HttpUrl">HttpUrl</a> & </td>
        <td><a href="#aedb94510d202af0e406e36048fe226b7">getHmUrl</a> () const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>const std::vector\< <a href="/content/api/cpp/classgpudb_1_1HttpUrl">HttpUrl</a> > & </td>
        <td><a href="#ac9beb72065758f970cfa07103ebda14b">getHmUrls</a> () const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>boost::asio::ssl::context \* </td>
        <td><a href="#af72c1f7f291b623383eea39d46e54ce9">getSslContext</a> () const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>bool </td>
        <td><a href="#a9df18e1554f55b50946316b044780699">getBypassSslCertCheck</a> () const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>const std::string & </td>
        <td><a href="#aa3d79bf540dc5af7a220a2f10a7a3526">getUsername</a> () const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>const std::string & </td>
        <td><a href="#a1408de75febd5b6a75600bdf21dcb40e">getPassword</a> () const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>const std::string & </td>
        <td><a href="#aaf15e54f08d002b4b1dfa570918526d3">getOauthToken</a> () const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>const std::string & </td>
        <td><a href="#a8b68c97b6284dcf9de059343f79feee7">getPrimaryURL</a> () const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Return a string containing the URL for the primary cluster; empty string otherwise. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>bool </td>
        <td><a href="#a89b57fb94c64f86e385d25b6e1763753">getUseSnappy</a> () const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>size\_t </td>
        <td><a href="#ad152315a6dd0ef159997b96f156ab7e7">getThreadCount</a> () const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>avro::ExecutorPtr </td>
        <td><a href="#a42e64c54611ca14b27daa3d1417d982e">getExecutor</a> () const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>const std::map\< std::string, std::string > & </td>
        <td><a href="#a9a05888d893e2ca984609b1a836ae5ba">getHttpHeaders</a> () const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="#a37626bfbd9c5e1decfcd08d7851e6719">HASynchronicityMode</a> </td>
        <td><a href="#ad9006419e63adde29e746b4bbcdbb662">getHASyncMode</a> () const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>size\_t </td>
        <td><a href="#a8346544922a72fcd795c9af457ed0455">getTimeout</a> () const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>long </td>
        <td><a href="#a961a30f3d43a87a41a07457207f8ff76">execute</a> (const std::string \&sql)</td>
      </tr>

      <tr>
        <td> </td>
        <td>This method is used to execute a SQL statement (e.g., DML, DDL). <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>long </td>
        <td><a href="#a7042004951231af914a4abc3b0035beb">execute</a> (const std::string \&sql, const std::string \&parameters)</td>
      </tr>

      <tr>
        <td> </td>
        <td>This method is used to execute a SQL statement (e.g., DML, DDL). <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>long </td>
        <td><a href="#af70fe59fbeb702506f92ea8c60f030f4">execute</a> (const std::string \&sql, const std::string \&parameters, const std::map\< std::string, std::string > \&options)</td>
      </tr>

      <tr>
        <td> </td>
        <td>This method is used to execute a SQL statement (e.g., DML, DDL). <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>template\<typename T> </td>
      </tr>

      <tr>
        <td>long </td>
        <td><a href="#a4b4c16fda3705614a5ea037dff06c7eb">execute</a> (const std::string \&sql, const std::vector\< T > \&parameters)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>template\<typename T> </td>
      </tr>

      <tr>
        <td>long </td>
        <td><a href="#a02bfe576a873f7e8d8d9cacc5dae9da0">execute</a> (const std::string \&sql, const std::vector\< T > \&parameters, const std::map\< std::string, std::string > \&options)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>void </td>
        <td><a href="#a71ebc6d06dede4f22358d47abf91d66f">setHASyncMode</a> (<a href="#a37626bfbd9c5e1decfcd08d7851e6719">HASynchronicityMode</a> mode)</td>
      </tr>

      <tr>
        <td> </td>
        <td>Sets the high-availability synchronization mode which will override the default mode. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>void </td>
        <td><a href="#a949cbb204510e4011233952fb00dc7f3">addHttpHeader</a> (const std::string \&header, const std::string \&value)</td>
      </tr>

      <tr>
        <td> </td>
        <td>Adds an HTTP header to the map of additional HTTP headers to send to <a href="/content/api/cpp/classgpudb_1_1GPUdb">GPUdb</a> with each request. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>void </td>
        <td><a href="#a04da24e61fee753e76aea8519c2ddb0c">removeHttpHeader</a> (const std::string \&header)</td>
      </tr>

      <tr>
        <td> </td>
        <td>Removes the given HTTP header from the map of additional HTTP headers to send to <a href="/content/api/cpp/classgpudb_1_1GPUdb">GPUdb</a> with each request. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>void </td>
        <td><a href="#aab8ecc365dc0afeb16302ff9fdafc206">updateHostManagerPort</a> ()</td>
      </tr>

      <tr>
        <td> </td>
        <td>Update the host manager port by inquiring the server. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>template\<typename TRequest, typename TResponse> </td>
      </tr>

      <tr>
        <td>TResponse & </td>
        <td><a href="#ab5e9179e7d4dd1ef359860bf74fc640c">submitRequest</a> (const <a href="/content/api/cpp/classgpudb_1_1HttpUrl">HttpUrl</a> \&url, const TRequest \&request, TResponse \&response, const bool enableCompression=false) const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>template\<typename TRequest, typename TResponse> </td>
      </tr>

      <tr>
        <td>TResponse & </td>
        <td><a href="#a640c8e86578a9dd9d93e368b934bfd1f">submitRequest</a> (const std::string \&endpoint, const TRequest \&request, TResponse \&response, const bool enableCompression=false) const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>template\<typename TRequest, typename TResponse> </td>
      </tr>

      <tr>
        <td>TResponse & </td>
        <td><a href="#a939b9f5e991775a4929de352c43074ae">submitRequest</a> (const char \*endpoint, const TRequest \&request, TResponse \&response, const bool enableCompression=false) const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>template\<typename TRequest, typename TResponse> </td>
      </tr>

      <tr>
        <td>TResponse & </td>
        <td><a href="#a5ed7d74b744aa18779313910508c582e">submitRequestToHostManager</a> (const std::string \&endpoint, const TRequest \&request, TResponse \&response, const bool enableCompression=false) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Submit an HTTP request to the host manager. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>template\<typename TRequest, typename TResponse> </td>
      </tr>

      <tr>
        <td>TResponse & </td>
        <td><a href="#a8c5649302a6ad92cf21b1023a602965c">submitRequestToHostManager</a> (const char \*endpoint, const TRequest \&request, TResponse \&response, const bool enableCompression=false) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Submit an HTTP request to the host manager. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AdminAddHostResponse">AdminAddHostResponse</a> </td>
        <td><a href="#a9ea80722f2b7f5f7ade6fc07c8b33dc3">adminAddHost</a> (const <a href="/content/api/cpp/structgpudb_1_1AdminAddHostRequest">AdminAddHostRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Adds a host to an existing cluster. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AdminAddHostResponse">AdminAddHostResponse</a> & </td>
        <td><a href="#aca748a594f8d487df215d9154157e4da">adminAddHost</a> (const <a href="/content/api/cpp/structgpudb_1_1AdminAddHostRequest">AdminAddHostRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1AdminAddHostResponse">AdminAddHostResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Adds a host to an existing cluster. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AdminAddHostResponse">AdminAddHostResponse</a> </td>
        <td><a href="#ac9004ae1ab277c012171fc322245ebc6">adminAddHost</a> (const std::string \&hostAddress, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Adds a host to an existing cluster. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AdminAddHostResponse">AdminAddHostResponse</a> & </td>
        <td><a href="#ada6bcf7fc6df22d912b33dba0459dd50">adminAddHost</a> (const std::string \&hostAddress, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1AdminAddHostResponse">AdminAddHostResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Adds a host to an existing cluster. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AdminAddRanksResponse">AdminAddRanksResponse</a> </td>
        <td><a href="#a6278c393c68970163b7af72e4504235b">adminAddRanks</a> (const <a href="/content/api/cpp/structgpudb_1_1AdminAddRanksRequest">AdminAddRanksRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Add one or more ranks to an existing Kinetica cluster. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AdminAddRanksResponse">AdminAddRanksResponse</a> & </td>
        <td><a href="#a3b5ba83013930fff00da5112434edae2">adminAddRanks</a> (const <a href="/content/api/cpp/structgpudb_1_1AdminAddRanksRequest">AdminAddRanksRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1AdminAddRanksResponse">AdminAddRanksResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Add one or more ranks to an existing Kinetica cluster. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AdminAddRanksResponse">AdminAddRanksResponse</a> </td>
        <td><a href="#a4164e525e3c2551fe489a0504dc5e41f">adminAddRanks</a> (const std::vector\< std::string > \&hosts, const std::vector\< std::map\< std::string, std::string > > \&configParams, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Add one or more ranks to an existing Kinetica cluster. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AdminAddRanksResponse">AdminAddRanksResponse</a> & </td>
        <td><a href="#a258d7e96b65d4a7220414f26858d2be3">adminAddRanks</a> (const std::vector\< std::string > \&hosts, const std::vector\< std::map\< std::string, std::string > > \&configParams, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1AdminAddRanksResponse">AdminAddRanksResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Add one or more ranks to an existing Kinetica cluster. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AdminAlterHostResponse">AdminAlterHostResponse</a> </td>
        <td><a href="#ac3888c404412d7e4095a5298fc985533">adminAlterHost</a> (const <a href="/content/api/cpp/structgpudb_1_1AdminAlterHostRequest">AdminAlterHostRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Alter properties on an existing host in the cluster. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AdminAlterHostResponse">AdminAlterHostResponse</a> & </td>
        <td><a href="#abe8d5b26c89c904d69e47d350fbd8a99">adminAlterHost</a> (const <a href="/content/api/cpp/structgpudb_1_1AdminAlterHostRequest">AdminAlterHostRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1AdminAlterHostResponse">AdminAlterHostResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Alter properties on an existing host in the cluster. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AdminAlterHostResponse">AdminAlterHostResponse</a> </td>
        <td><a href="#a2c34940d8cd5b11c42c518cbb7417930">adminAlterHost</a> (const std::string \&host, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Alter properties on an existing host in the cluster. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AdminAlterHostResponse">AdminAlterHostResponse</a> & </td>
        <td><a href="#a45ba2c611f5cdc0089013bcd2193fcfb">adminAlterHost</a> (const std::string \&host, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1AdminAlterHostResponse">AdminAlterHostResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Alter properties on an existing host in the cluster. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AdminAlterJobsResponse">AdminAlterJobsResponse</a> </td>
        <td><a href="#af95f74ccf4ec9a3810077befea1e6e86">adminAlterJobs</a> (const <a href="/content/api/cpp/structgpudb_1_1AdminAlterJobsRequest">AdminAlterJobsRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Perform the requested action on a list of one or more job(s). <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AdminAlterJobsResponse">AdminAlterJobsResponse</a> & </td>
        <td><a href="#ac3b3fd11929c45c6db6ab13204a8631c">adminAlterJobs</a> (const <a href="/content/api/cpp/structgpudb_1_1AdminAlterJobsRequest">AdminAlterJobsRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1AdminAlterJobsResponse">AdminAlterJobsResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Perform the requested action on a list of one or more job(s). <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AdminAlterJobsResponse">AdminAlterJobsResponse</a> </td>
        <td><a href="#a8d37fe50a8c815751abf99299179230d">adminAlterJobs</a> (const std::vector\< int64\_t > \&jobIds, const std::string \&action, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Perform the requested action on a list of one or more job(s). <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AdminAlterJobsResponse">AdminAlterJobsResponse</a> & </td>
        <td><a href="#aabf2b9dd9f3b5c2092f2e81d5c583dd2">adminAlterJobs</a> (const std::vector\< int64\_t > \&jobIds, const std::string \&action, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1AdminAlterJobsResponse">AdminAlterJobsResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Perform the requested action on a list of one or more job(s). <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AdminBackupBeginResponse">AdminBackupBeginResponse</a> </td>
        <td><a href="#a4092aceb8e29ca9f38b123929c3c776f">adminBackupBegin</a> (const <a href="/content/api/cpp/structgpudb_1_1AdminBackupBeginRequest">AdminBackupBeginRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Prepares the system for a backup by closing all open file handles after allowing current active jobs to complete. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AdminBackupBeginResponse">AdminBackupBeginResponse</a> & </td>
        <td><a href="#aac26b7f613238faffeaac9d8e051b432">adminBackupBegin</a> (const <a href="/content/api/cpp/structgpudb_1_1AdminBackupBeginRequest">AdminBackupBeginRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1AdminBackupBeginResponse">AdminBackupBeginResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Prepares the system for a backup by closing all open file handles after allowing current active jobs to complete. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AdminBackupBeginResponse">AdminBackupBeginResponse</a> </td>
        <td><a href="#a16e7e1682f6d135480d1ca3f56338cf9">adminBackupBegin</a> (const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Prepares the system for a backup by closing all open file handles after allowing current active jobs to complete. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AdminBackupBeginResponse">AdminBackupBeginResponse</a> & </td>
        <td><a href="#a076206de88a2924e531a5b275f9336e9">adminBackupBegin</a> (const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1AdminBackupBeginResponse">AdminBackupBeginResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Prepares the system for a backup by closing all open file handles after allowing current active jobs to complete. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AdminBackupEndResponse">AdminBackupEndResponse</a> </td>
        <td><a href="#ad1118f4fdb299a57ee85740f7ee35665">adminBackupEnd</a> (const <a href="/content/api/cpp/structgpudb_1_1AdminBackupEndRequest">AdminBackupEndRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Restores the system to normal operating mode after a backup has completed, allowing any queries that were blocked to complete. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AdminBackupEndResponse">AdminBackupEndResponse</a> & </td>
        <td><a href="#a5b8ab88d3ce73e818cd7808770e5a961">adminBackupEnd</a> (const <a href="/content/api/cpp/structgpudb_1_1AdminBackupEndRequest">AdminBackupEndRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1AdminBackupEndResponse">AdminBackupEndResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Restores the system to normal operating mode after a backup has completed, allowing any queries that were blocked to complete. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AdminBackupEndResponse">AdminBackupEndResponse</a> </td>
        <td><a href="#a775ff2f501c87d680d6b70b7f995b7e4">adminBackupEnd</a> (const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Restores the system to normal operating mode after a backup has completed, allowing any queries that were blocked to complete. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AdminBackupEndResponse">AdminBackupEndResponse</a> & </td>
        <td><a href="#a028b158a620013afe734e98fea607aca">adminBackupEnd</a> (const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1AdminBackupEndResponse">AdminBackupEndResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Restores the system to normal operating mode after a backup has completed, allowing any queries that were blocked to complete. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AdminHaOfflineResponse">AdminHaOfflineResponse</a> </td>
        <td><a href="#abe3d7c0c7fc2acb14bdc22e030dee0b5">adminHaOffline</a> (const <a href="/content/api/cpp/structgpudb_1_1AdminHaOfflineRequest">AdminHaOfflineRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Pauses consumption of messages from other HA clusters to support data repair/recovery scenarios. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AdminHaOfflineResponse">AdminHaOfflineResponse</a> & </td>
        <td><a href="#acfc2a6a92f7019a18768ffe9c91478d1">adminHaOffline</a> (const <a href="/content/api/cpp/structgpudb_1_1AdminHaOfflineRequest">AdminHaOfflineRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1AdminHaOfflineResponse">AdminHaOfflineResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Pauses consumption of messages from other HA clusters to support data repair/recovery scenarios. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AdminHaOfflineResponse">AdminHaOfflineResponse</a> </td>
        <td><a href="#a95662cd408cd6e50c823e6c078b8a345">adminHaOffline</a> (const bool offline, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Pauses consumption of messages from other HA clusters to support data repair/recovery scenarios. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AdminHaOfflineResponse">AdminHaOfflineResponse</a> & </td>
        <td><a href="#a50a1072291f97df14d3d7d42fb2650e2">adminHaOffline</a> (const bool offline, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1AdminHaOfflineResponse">AdminHaOfflineResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Pauses consumption of messages from other HA clusters to support data repair/recovery scenarios. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AdminHaRefreshResponse">AdminHaRefreshResponse</a> </td>
        <td><a href="#ad0294d27d194bc5658f20748db0e8b42">adminHaRefresh</a> (const <a href="/content/api/cpp/structgpudb_1_1AdminHaRefreshRequest">AdminHaRefreshRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Restarts the HA processing on the given cluster as a mechanism of accepting breaking HA conf changes. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AdminHaRefreshResponse">AdminHaRefreshResponse</a> & </td>
        <td><a href="#ae2ad6feac6e17483de4502ecc3114181">adminHaRefresh</a> (const <a href="/content/api/cpp/structgpudb_1_1AdminHaRefreshRequest">AdminHaRefreshRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1AdminHaRefreshResponse">AdminHaRefreshResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Restarts the HA processing on the given cluster as a mechanism of accepting breaking HA conf changes. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AdminHaRefreshResponse">AdminHaRefreshResponse</a> </td>
        <td><a href="#a43b0255297e7c3a6e79d6a5eda88193a">adminHaRefresh</a> (const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Restarts the HA processing on the given cluster as a mechanism of accepting breaking HA conf changes. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AdminHaRefreshResponse">AdminHaRefreshResponse</a> & </td>
        <td><a href="#abb440bd25cb86a5379cbb05ae403c917">adminHaRefresh</a> (const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1AdminHaRefreshResponse">AdminHaRefreshResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Restarts the HA processing on the given cluster as a mechanism of accepting breaking HA conf changes. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AdminOfflineResponse">AdminOfflineResponse</a> </td>
        <td><a href="#a9458238afaafde877e568a92d45abb75">adminOffline</a> (const <a href="/content/api/cpp/structgpudb_1_1AdminOfflineRequest">AdminOfflineRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Take the system offline. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AdminOfflineResponse">AdminOfflineResponse</a> & </td>
        <td><a href="#a57f142409c09c17cf6b6db1018d28a86">adminOffline</a> (const <a href="/content/api/cpp/structgpudb_1_1AdminOfflineRequest">AdminOfflineRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1AdminOfflineResponse">AdminOfflineResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Take the system offline. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AdminOfflineResponse">AdminOfflineResponse</a> </td>
        <td><a href="#a4d36ee318372b12d061552af95a2910c">adminOffline</a> (const bool offline, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Take the system offline. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AdminOfflineResponse">AdminOfflineResponse</a> & </td>
        <td><a href="#a9287388ae6e705b7265529115fa564cb">adminOffline</a> (const bool offline, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1AdminOfflineResponse">AdminOfflineResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Take the system offline. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AdminRebalanceResponse">AdminRebalanceResponse</a> </td>
        <td><a href="#a12ddec404e39c247d808318977c10d6b">adminRebalance</a> (const <a href="/content/api/cpp/structgpudb_1_1AdminRebalanceRequest">AdminRebalanceRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Rebalance the data in the cluster so that all nodes contain an equal number of records approximately and/or rebalance the shards to be equally distributed (as much as possible) across all the ranks. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AdminRebalanceResponse">AdminRebalanceResponse</a> & </td>
        <td><a href="#a225313a061565fba218a4400e32bd6e9">adminRebalance</a> (const <a href="/content/api/cpp/structgpudb_1_1AdminRebalanceRequest">AdminRebalanceRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1AdminRebalanceResponse">AdminRebalanceResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Rebalance the data in the cluster so that all nodes contain an equal number of records approximately and/or rebalance the shards to be equally distributed (as much as possible) across all the ranks. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AdminRebalanceResponse">AdminRebalanceResponse</a> </td>
        <td><a href="#a8abfc8309fa07276967c988d6f316390">adminRebalance</a> (const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Rebalance the data in the cluster so that all nodes contain an equal number of records approximately and/or rebalance the shards to be equally distributed (as much as possible) across all the ranks. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AdminRebalanceResponse">AdminRebalanceResponse</a> & </td>
        <td><a href="#a37e5e1f0651504eee56a0321a77b47c2">adminRebalance</a> (const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1AdminRebalanceResponse">AdminRebalanceResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Rebalance the data in the cluster so that all nodes contain an equal number of records approximately and/or rebalance the shards to be equally distributed (as much as possible) across all the ranks. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AdminRemoveHostResponse">AdminRemoveHostResponse</a> </td>
        <td><a href="#afc27231b396dfca335854fb0094d16e6">adminRemoveHost</a> (const <a href="/content/api/cpp/structgpudb_1_1AdminRemoveHostRequest">AdminRemoveHostRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Removes a host from an existing cluster. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AdminRemoveHostResponse">AdminRemoveHostResponse</a> & </td>
        <td><a href="#ac77e1ed2b6f9e9552b6187bf9553be5f">adminRemoveHost</a> (const <a href="/content/api/cpp/structgpudb_1_1AdminRemoveHostRequest">AdminRemoveHostRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1AdminRemoveHostResponse">AdminRemoveHostResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Removes a host from an existing cluster. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AdminRemoveHostResponse">AdminRemoveHostResponse</a> </td>
        <td><a href="#ab4f8c2922e78db2407c488ce3388ebe3">adminRemoveHost</a> (const std::string \&host, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Removes a host from an existing cluster. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AdminRemoveHostResponse">AdminRemoveHostResponse</a> & </td>
        <td><a href="#a6a88a2a737e8b825f3c201e806346b8f">adminRemoveHost</a> (const std::string \&host, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1AdminRemoveHostResponse">AdminRemoveHostResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Removes a host from an existing cluster. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AdminRemoveRanksResponse">AdminRemoveRanksResponse</a> </td>
        <td><a href="#af47d6fbc166de5aa113aacbd9cad9ca7">adminRemoveRanks</a> (const <a href="/content/api/cpp/structgpudb_1_1AdminRemoveRanksRequest">AdminRemoveRanksRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Remove one or more ranks from an existing Kinetica cluster. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AdminRemoveRanksResponse">AdminRemoveRanksResponse</a> & </td>
        <td><a href="#a96f6705e2aa15bb8a9276b900dfb75af">adminRemoveRanks</a> (const <a href="/content/api/cpp/structgpudb_1_1AdminRemoveRanksRequest">AdminRemoveRanksRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1AdminRemoveRanksResponse">AdminRemoveRanksResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Remove one or more ranks from an existing Kinetica cluster. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AdminRemoveRanksResponse">AdminRemoveRanksResponse</a> </td>
        <td><a href="#a25fe31989868ca19f1e69c67dd67e3c0">adminRemoveRanks</a> (const std::vector\< std::string > \&ranks, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Remove one or more ranks from an existing Kinetica cluster. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AdminRemoveRanksResponse">AdminRemoveRanksResponse</a> & </td>
        <td><a href="#add72201686c919180950f7b44d144631">adminRemoveRanks</a> (const std::vector\< std::string > \&ranks, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1AdminRemoveRanksResponse">AdminRemoveRanksResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Remove one or more ranks from an existing Kinetica cluster. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AdminRepairTableResponse">AdminRepairTableResponse</a> </td>
        <td><a href="#adedd21391e4301a79aca49f95e18a3c9">adminRepairTable</a> (const <a href="/content/api/cpp/structgpudb_1_1AdminRepairTableRequest">AdminRepairTableRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Manually repair a corrupted table. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AdminRepairTableResponse">AdminRepairTableResponse</a> & </td>
        <td><a href="#a2b2b59214a68e36d7781038f9dba1cdb">adminRepairTable</a> (const <a href="/content/api/cpp/structgpudb_1_1AdminRepairTableRequest">AdminRepairTableRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1AdminRepairTableResponse">AdminRepairTableResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Manually repair a corrupted table. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AdminRepairTableResponse">AdminRepairTableResponse</a> </td>
        <td><a href="#a7cc3c26f1ed85ae3f55d77dc0c034a0e">adminRepairTable</a> (const std::vector\< std::string > \&tableNames, const std::map\< std::string, std::string > \&tableTypes, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Manually repair a corrupted table. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AdminRepairTableResponse">AdminRepairTableResponse</a> & </td>
        <td><a href="#a110ae4c3ec9cbc81402621acf5068da5">adminRepairTable</a> (const std::vector\< std::string > \&tableNames, const std::map\< std::string, std::string > \&tableTypes, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1AdminRepairTableResponse">AdminRepairTableResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Manually repair a corrupted table. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AdminSendAlertResponse">AdminSendAlertResponse</a> </td>
        <td><a href="#a2fe86f445de71617b057707c7a50d5d8">adminSendAlert</a> (const <a href="/content/api/cpp/structgpudb_1_1AdminSendAlertRequest">AdminSendAlertRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Sends a user generated alert to the monitoring system. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AdminSendAlertResponse">AdminSendAlertResponse</a> & </td>
        <td><a href="#a04d636efab58468abad5981c37d54f1e">adminSendAlert</a> (const <a href="/content/api/cpp/structgpudb_1_1AdminSendAlertRequest">AdminSendAlertRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1AdminSendAlertResponse">AdminSendAlertResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Sends a user generated alert to the monitoring system. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AdminSendAlertResponse">AdminSendAlertResponse</a> </td>
        <td><a href="#ad3c6c09c9e78dfdbe68f75b09fe7ba80">adminSendAlert</a> (const std::string \&message, const std::string \&label, const std::string \&logLevel, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Sends a user generated alert to the monitoring system. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AdminSendAlertResponse">AdminSendAlertResponse</a> & </td>
        <td><a href="#aa31faecc97bf8c1ccaf916c07a8c80c0">adminSendAlert</a> (const std::string \&message, const std::string \&label, const std::string \&logLevel, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1AdminSendAlertResponse">AdminSendAlertResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Sends a user generated alert to the monitoring system. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AdminShowAlertsResponse">AdminShowAlertsResponse</a> </td>
        <td><a href="#aa089f0e3ed5c9c02279eb96ac08ef332">adminShowAlerts</a> (const <a href="/content/api/cpp/structgpudb_1_1AdminShowAlertsRequest">AdminShowAlertsRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Requests a list of the most recent alerts. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AdminShowAlertsResponse">AdminShowAlertsResponse</a> & </td>
        <td><a href="#a4e548f403acb088b49eeefecf1255ee3">adminShowAlerts</a> (const <a href="/content/api/cpp/structgpudb_1_1AdminShowAlertsRequest">AdminShowAlertsRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1AdminShowAlertsResponse">AdminShowAlertsResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Requests a list of the most recent alerts. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AdminShowAlertsResponse">AdminShowAlertsResponse</a> </td>
        <td><a href="#a20dcafad2c17506babc2c89204723066">adminShowAlerts</a> (const int32\_t numAlerts, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Requests a list of the most recent alerts. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AdminShowAlertsResponse">AdminShowAlertsResponse</a> & </td>
        <td><a href="#ac276578f3cb6b5959e7d47d54b408542">adminShowAlerts</a> (const int32\_t numAlerts, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1AdminShowAlertsResponse">AdminShowAlertsResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Requests a list of the most recent alerts. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AdminShowClusterOperationsResponse">AdminShowClusterOperationsResponse</a> </td>
        <td><a href="#aa11e77cd54b2d748b261fccbb9508765">adminShowClusterOperations</a> (const <a href="/content/api/cpp/structgpudb_1_1AdminShowClusterOperationsRequest">AdminShowClusterOperationsRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Requests the detailed status of the current operation (by default) or a prior cluster operation specified by <a href="/content/api/cpp/structgpudb_1_1AdminShowClusterOperationsRequest#ac6af84e10bd8b42efba940403e60583a">historyIndex</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AdminShowClusterOperationsResponse">AdminShowClusterOperationsResponse</a> & </td>
        <td><a href="#a94884d8e6fd62a9b323eece3fceb919d">adminShowClusterOperations</a> (const <a href="/content/api/cpp/structgpudb_1_1AdminShowClusterOperationsRequest">AdminShowClusterOperationsRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1AdminShowClusterOperationsResponse">AdminShowClusterOperationsResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Requests the detailed status of the current operation (by default) or a prior cluster operation specified by <a href="/content/api/cpp/structgpudb_1_1AdminShowClusterOperationsRequest#ac6af84e10bd8b42efba940403e60583a">historyIndex</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AdminShowClusterOperationsResponse">AdminShowClusterOperationsResponse</a> </td>
        <td><a href="#a291cba4486c80a01e6f7b50b22a10a23">adminShowClusterOperations</a> (const int32\_t historyIndex, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Requests the detailed status of the current operation (by default) or a prior cluster operation specified by <span>historyIndex</span>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AdminShowClusterOperationsResponse">AdminShowClusterOperationsResponse</a> & </td>
        <td><a href="#a2f774e54ed3366000d893ac707c586c9">adminShowClusterOperations</a> (const int32\_t historyIndex, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1AdminShowClusterOperationsResponse">AdminShowClusterOperationsResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Requests the detailed status of the current operation (by default) or a prior cluster operation specified by <span>historyIndex</span>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AdminShowJobsResponse">AdminShowJobsResponse</a> </td>
        <td><a href="#a1a878c279cea5c797d9ba2059fc359ae">adminShowJobs</a> (const <a href="/content/api/cpp/structgpudb_1_1AdminShowJobsRequest">AdminShowJobsRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Get a list of the current jobs in <a href="/content/api/cpp/classgpudb_1_1GPUdb">GPUdb</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AdminShowJobsResponse">AdminShowJobsResponse</a> & </td>
        <td><a href="#ab3936c03c0c0f5da6a4741c2b00f3133">adminShowJobs</a> (const <a href="/content/api/cpp/structgpudb_1_1AdminShowJobsRequest">AdminShowJobsRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1AdminShowJobsResponse">AdminShowJobsResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Get a list of the current jobs in <a href="/content/api/cpp/classgpudb_1_1GPUdb">GPUdb</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AdminShowJobsResponse">AdminShowJobsResponse</a> </td>
        <td><a href="#a0ca888e77117b227a6da7af58bbb64b7">adminShowJobs</a> (const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Get a list of the current jobs in <a href="/content/api/cpp/classgpudb_1_1GPUdb">GPUdb</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AdminShowJobsResponse">AdminShowJobsResponse</a> & </td>
        <td><a href="#aa5763f88ff54e01cca9e7f52230c4680">adminShowJobs</a> (const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1AdminShowJobsResponse">AdminShowJobsResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Get a list of the current jobs in <a href="/content/api/cpp/classgpudb_1_1GPUdb">GPUdb</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AdminShowShardsResponse">AdminShowShardsResponse</a> </td>
        <td><a href="#a2be5c9f06b420c8506042cf997881f5f">adminShowShards</a> (const <a href="/content/api/cpp/structgpudb_1_1AdminShowShardsRequest">AdminShowShardsRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Show the mapping of shards to the corresponding rank and tom. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AdminShowShardsResponse">AdminShowShardsResponse</a> & </td>
        <td><a href="#a7a7df0301c8d4bba30e10c5a4a9262fa">adminShowShards</a> (const <a href="/content/api/cpp/structgpudb_1_1AdminShowShardsRequest">AdminShowShardsRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1AdminShowShardsResponse">AdminShowShardsResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Show the mapping of shards to the corresponding rank and tom. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AdminShowShardsResponse">AdminShowShardsResponse</a> </td>
        <td><a href="#aece0b9daf988f3907f63182816d341ef">adminShowShards</a> (const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Show the mapping of shards to the corresponding rank and tom. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AdminShowShardsResponse">AdminShowShardsResponse</a> & </td>
        <td><a href="#a16118ffb6ba2825aeb6fa2cd09e71430">adminShowShards</a> (const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1AdminShowShardsResponse">AdminShowShardsResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Show the mapping of shards to the corresponding rank and tom. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AdminShutdownResponse">AdminShutdownResponse</a> </td>
        <td><a href="#a6a4b1b30ce919c660ef04f11e7b24b5c">adminShutdown</a> (const <a href="/content/api/cpp/structgpudb_1_1AdminShutdownRequest">AdminShutdownRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Exits the database server application. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AdminShutdownResponse">AdminShutdownResponse</a> & </td>
        <td><a href="#abc3a6fe9fb271905c4136afb676cc71a">adminShutdown</a> (const <a href="/content/api/cpp/structgpudb_1_1AdminShutdownRequest">AdminShutdownRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1AdminShutdownResponse">AdminShutdownResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Exits the database server application. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AdminShutdownResponse">AdminShutdownResponse</a> </td>
        <td><a href="#a523a65e0fd292d5f76222153d213f08a">adminShutdown</a> (const std::string \&exitType, const std::string \&authorization, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Exits the database server application. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AdminShutdownResponse">AdminShutdownResponse</a> & </td>
        <td><a href="#a32b32667fb7d9d45a2b0db686ae82ee6">adminShutdown</a> (const std::string \&exitType, const std::string \&authorization, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1AdminShutdownResponse">AdminShutdownResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Exits the database server application. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AdminSwitchoverResponse">AdminSwitchoverResponse</a> </td>
        <td><a href="#a2c4d8fe04dc3c5feb4e5e343889bddf8">adminSwitchover</a> (const <a href="/content/api/cpp/structgpudb_1_1AdminSwitchoverRequest">AdminSwitchoverRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Manually switch over one or more processes to another host. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AdminSwitchoverResponse">AdminSwitchoverResponse</a> & </td>
        <td><a href="#a2d0d5e334a3de21e3794c94494d4a4c9">adminSwitchover</a> (const <a href="/content/api/cpp/structgpudb_1_1AdminSwitchoverRequest">AdminSwitchoverRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1AdminSwitchoverResponse">AdminSwitchoverResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Manually switch over one or more processes to another host. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AdminSwitchoverResponse">AdminSwitchoverResponse</a> </td>
        <td><a href="#a48a805373da1ea7f31119c18ead8750a">adminSwitchover</a> (const std::vector\< std::string > \&processes, const std::vector\< std::string > \&destinations, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Manually switch over one or more processes to another host. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AdminSwitchoverResponse">AdminSwitchoverResponse</a> & </td>
        <td><a href="#a3809c13a0fefaf894419355760f09e5e">adminSwitchover</a> (const std::vector\< std::string > \&processes, const std::vector\< std::string > \&destinations, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1AdminSwitchoverResponse">AdminSwitchoverResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Manually switch over one or more processes to another host. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AdminVerifyDbResponse">AdminVerifyDbResponse</a> </td>
        <td><a href="#ac2abe130ad4178e02001d86b4874e856">adminVerifyDb</a> (const <a href="/content/api/cpp/structgpudb_1_1AdminVerifyDbRequest">AdminVerifyDbRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Verify database is in a consistent state. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AdminVerifyDbResponse">AdminVerifyDbResponse</a> & </td>
        <td><a href="#a11a512b0c386adcd95d328d971f8ea3f">adminVerifyDb</a> (const <a href="/content/api/cpp/structgpudb_1_1AdminVerifyDbRequest">AdminVerifyDbRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1AdminVerifyDbResponse">AdminVerifyDbResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Verify database is in a consistent state. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AdminVerifyDbResponse">AdminVerifyDbResponse</a> </td>
        <td><a href="#a4651bd91e69f7a8aa697471fa7ddba31">adminVerifyDb</a> (const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Verify database is in a consistent state. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AdminVerifyDbResponse">AdminVerifyDbResponse</a> & </td>
        <td><a href="#a8c581db10e112cbd00bc2e48fcc065e5">adminVerifyDb</a> (const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1AdminVerifyDbResponse">AdminVerifyDbResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Verify database is in a consistent state. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AggregateConvexHullResponse">AggregateConvexHullResponse</a> </td>
        <td><a href="#a53f33c09e6417aa4f7ce8f9d2bf5ae17">aggregateConvexHull</a> (const <a href="/content/api/cpp/structgpudb_1_1AggregateConvexHullRequest">AggregateConvexHullRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Calculates and returns the convex hull for the values in a table specified by <a href="/content/api/cpp/structgpudb_1_1AggregateConvexHullRequest#aa5c059d247ea25d4b3fa3431300786c0">tableName</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AggregateConvexHullResponse">AggregateConvexHullResponse</a> & </td>
        <td><a href="#a5342713aad628b695f89b31e5385d1bc">aggregateConvexHull</a> (const <a href="/content/api/cpp/structgpudb_1_1AggregateConvexHullRequest">AggregateConvexHullRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1AggregateConvexHullResponse">AggregateConvexHullResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Calculates and returns the convex hull for the values in a table specified by <a href="/content/api/cpp/structgpudb_1_1AggregateConvexHullRequest#aa5c059d247ea25d4b3fa3431300786c0">tableName</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AggregateConvexHullResponse">AggregateConvexHullResponse</a> </td>
        <td><a href="#ab71694e118f02bd23b4174ced64786eb">aggregateConvexHull</a> (const std::string \&tableName, const std::string \&xColumnName, const std::string \&yColumnName, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Calculates and returns the convex hull for the values in a table specified by <span>tableName</span>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AggregateConvexHullResponse">AggregateConvexHullResponse</a> & </td>
        <td><a href="#a361f86c14f9326e73fff076f842f69ed">aggregateConvexHull</a> (const std::string \&tableName, const std::string \&xColumnName, const std::string \&yColumnName, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1AggregateConvexHullResponse">AggregateConvexHullResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Calculates and returns the convex hull for the values in a table specified by <span>tableName</span>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1RawAggregateGroupByResponse">RawAggregateGroupByResponse</a> </td>
        <td><a href="#a229b78476fee686199caaa9de5a113b2">aggregateGroupByRaw</a> (const <a href="/content/api/cpp/structgpudb_1_1AggregateGroupByRequest">AggregateGroupByRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Calculates unique combinations (groups) of values for the given columns in a given table or view and computes aggregates on each unique combination. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1RawAggregateGroupByResponse">RawAggregateGroupByResponse</a> & </td>
        <td><a href="#a7660bce798a03aa6d1512429d1e72401">aggregateGroupByRaw</a> (const <a href="/content/api/cpp/structgpudb_1_1AggregateGroupByRequest">AggregateGroupByRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1RawAggregateGroupByResponse">RawAggregateGroupByResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Calculates unique combinations (groups) of values for the given columns in a given table or view and computes aggregates on each unique combination. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AggregateGroupByResponse">AggregateGroupByResponse</a> </td>
        <td><a href="#a76d7b0a4e087f94ccd17f65a38f3fc8e">aggregateGroupBy</a> (const <a href="/content/api/cpp/structgpudb_1_1AggregateGroupByRequest">AggregateGroupByRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Calculates unique combinations (groups) of values for the given columns in a given table or view and computes aggregates on each unique combination. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AggregateGroupByResponse">AggregateGroupByResponse</a> & </td>
        <td><a href="#ab2b96dbacb58d0a3e621ded87e0efb3e">aggregateGroupBy</a> (const <a href="/content/api/cpp/structgpudb_1_1AggregateGroupByRequest">AggregateGroupByRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1AggregateGroupByResponse">AggregateGroupByResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Calculates unique combinations (groups) of values for the given columns in a given table or view and computes aggregates on each unique combination. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AggregateGroupByResponse">AggregateGroupByResponse</a> </td>
        <td><a href="#a30cac962c6aedc8efc312e2b4217ff31">aggregateGroupBy</a> (const std::string \&tableName, const std::vector\< std::string > \&columnNames, const int64\_t offset, const int64\_t limit, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Calculates unique combinations (groups) of values for the given columns in a given table or view and computes aggregates on each unique combination. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AggregateGroupByResponse">AggregateGroupByResponse</a> & </td>
        <td><a href="#a69c3aebe6f34c6101b93222ba8bc395e">aggregateGroupBy</a> (const std::string \&tableName, const std::vector\< std::string > \&columnNames, const int64\_t offset, const int64\_t limit, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1AggregateGroupByResponse">AggregateGroupByResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Calculates unique combinations (groups) of values for the given columns in a given table or view and computes aggregates on each unique combination. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AggregateHistogramResponse">AggregateHistogramResponse</a> </td>
        <td><a href="#a44f85f0ed810158552eade4159d161ac">aggregateHistogram</a> (const <a href="/content/api/cpp/structgpudb_1_1AggregateHistogramRequest">AggregateHistogramRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Performs a histogram calculation given a table, a column, and an interval function. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AggregateHistogramResponse">AggregateHistogramResponse</a> & </td>
        <td><a href="#a55de0ae15f0c2d85a0a5b785db143275">aggregateHistogram</a> (const <a href="/content/api/cpp/structgpudb_1_1AggregateHistogramRequest">AggregateHistogramRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1AggregateHistogramResponse">AggregateHistogramResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Performs a histogram calculation given a table, a column, and an interval function. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AggregateHistogramResponse">AggregateHistogramResponse</a> </td>
        <td><a href="#a81f941c05e1304c4709f95346eaae747">aggregateHistogram</a> (const std::string \&tableName, const std::string \&columnName, const double start, const double end, const double interval, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Performs a histogram calculation given a table, a column, and an interval function. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AggregateHistogramResponse">AggregateHistogramResponse</a> & </td>
        <td><a href="#af0eea9fee904ec49d2ba8ee73df3b90c">aggregateHistogram</a> (const std::string \&tableName, const std::string \&columnName, const double start, const double end, const double interval, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1AggregateHistogramResponse">AggregateHistogramResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Performs a histogram calculation given a table, a column, and an interval function. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AggregateKMeansResponse">AggregateKMeansResponse</a> </td>
        <td><a href="#ad5a2053d2dbd8781f49d4ce47c902c3e">aggregateKMeans</a> (const <a href="/content/api/cpp/structgpudb_1_1AggregateKMeansRequest">AggregateKMeansRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>This endpoint runs the k-means algorithm - a heuristic algorithm that attempts to do k-means clustering. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AggregateKMeansResponse">AggregateKMeansResponse</a> & </td>
        <td><a href="#ac94cd2cd6cbc6a3d01100b6565c76788">aggregateKMeans</a> (const <a href="/content/api/cpp/structgpudb_1_1AggregateKMeansRequest">AggregateKMeansRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1AggregateKMeansResponse">AggregateKMeansResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>This endpoint runs the k-means algorithm - a heuristic algorithm that attempts to do k-means clustering. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AggregateKMeansResponse">AggregateKMeansResponse</a> </td>
        <td><a href="#ac88006219510944c94cba1df8c2e71cd">aggregateKMeans</a> (const std::string \&tableName, const std::vector\< std::string > \&columnNames, const int32\_t k, const double tolerance, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>This endpoint runs the k-means algorithm - a heuristic algorithm that attempts to do k-means clustering. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AggregateKMeansResponse">AggregateKMeansResponse</a> & </td>
        <td><a href="#a325a1fab76dc072b4bcbbe0890793bc1">aggregateKMeans</a> (const std::string \&tableName, const std::vector\< std::string > \&columnNames, const int32\_t k, const double tolerance, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1AggregateKMeansResponse">AggregateKMeansResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>This endpoint runs the k-means algorithm - a heuristic algorithm that attempts to do k-means clustering. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AggregateMinMaxResponse">AggregateMinMaxResponse</a> </td>
        <td><a href="#a0f4f8435266adafdab5c5c5c81a88ce3">aggregateMinMax</a> (const <a href="/content/api/cpp/structgpudb_1_1AggregateMinMaxRequest">AggregateMinMaxRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Calculates and returns the minimum and maximum values of a particular column in a table. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AggregateMinMaxResponse">AggregateMinMaxResponse</a> & </td>
        <td><a href="#ac77ceff80e8d09cf71435e7d1f735348">aggregateMinMax</a> (const <a href="/content/api/cpp/structgpudb_1_1AggregateMinMaxRequest">AggregateMinMaxRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1AggregateMinMaxResponse">AggregateMinMaxResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Calculates and returns the minimum and maximum values of a particular column in a table. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AggregateMinMaxResponse">AggregateMinMaxResponse</a> </td>
        <td><a href="#a08b988eb93cfa99ca7aeaa3a093acac2">aggregateMinMax</a> (const std::string \&tableName, const std::string \&columnName, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Calculates and returns the minimum and maximum values of a particular column in a table. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AggregateMinMaxResponse">AggregateMinMaxResponse</a> & </td>
        <td><a href="#a814eeb562646d7dbbeddbf4a54d4164e">aggregateMinMax</a> (const std::string \&tableName, const std::string \&columnName, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1AggregateMinMaxResponse">AggregateMinMaxResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Calculates and returns the minimum and maximum values of a particular column in a table. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AggregateMinMaxGeometryResponse">AggregateMinMaxGeometryResponse</a> </td>
        <td><a href="#a2ea45e8117eaaf785e5791d86f7bf31a">aggregateMinMaxGeometry</a> (const <a href="/content/api/cpp/structgpudb_1_1AggregateMinMaxGeometryRequest">AggregateMinMaxGeometryRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Calculates and returns the minimum and maximum x- and y-coordinates of a particular geospatial geometry column in a table. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AggregateMinMaxGeometryResponse">AggregateMinMaxGeometryResponse</a> & </td>
        <td><a href="#a3148eca67319655a1f8bc84d30604405">aggregateMinMaxGeometry</a> (const <a href="/content/api/cpp/structgpudb_1_1AggregateMinMaxGeometryRequest">AggregateMinMaxGeometryRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1AggregateMinMaxGeometryResponse">AggregateMinMaxGeometryResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Calculates and returns the minimum and maximum x- and y-coordinates of a particular geospatial geometry column in a table. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AggregateMinMaxGeometryResponse">AggregateMinMaxGeometryResponse</a> </td>
        <td><a href="#a2922273b4ee8519ce678124d7e640309">aggregateMinMaxGeometry</a> (const std::string \&tableName, const std::string \&columnName, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Calculates and returns the minimum and maximum x- and y-coordinates of a particular geospatial geometry column in a table. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AggregateMinMaxGeometryResponse">AggregateMinMaxGeometryResponse</a> & </td>
        <td><a href="#acd7747a52281b1bba0d77d71bfc4b100">aggregateMinMaxGeometry</a> (const std::string \&tableName, const std::string \&columnName, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1AggregateMinMaxGeometryResponse">AggregateMinMaxGeometryResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Calculates and returns the minimum and maximum x- and y-coordinates of a particular geospatial geometry column in a table. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AggregateStatisticsResponse">AggregateStatisticsResponse</a> </td>
        <td><a href="#ae8be38925c2de5770cde61ce058641c6">aggregateStatistics</a> (const <a href="/content/api/cpp/structgpudb_1_1AggregateStatisticsRequest">AggregateStatisticsRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Calculates the requested statistics of the given column(s) in a given table. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AggregateStatisticsResponse">AggregateStatisticsResponse</a> & </td>
        <td><a href="#a2ec160656cda21fb8968cd0dd74cfc68">aggregateStatistics</a> (const <a href="/content/api/cpp/structgpudb_1_1AggregateStatisticsRequest">AggregateStatisticsRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1AggregateStatisticsResponse">AggregateStatisticsResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Calculates the requested statistics of the given column(s) in a given table. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AggregateStatisticsResponse">AggregateStatisticsResponse</a> </td>
        <td><a href="#a14e2268cde99791da1ffb54f1f8326cb">aggregateStatistics</a> (const std::string \&tableName, const std::string \&columnName, const std::string \&stats, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Calculates the requested statistics of the given column(s) in a given table. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AggregateStatisticsResponse">AggregateStatisticsResponse</a> & </td>
        <td><a href="#ad2e88c5ed0f712c53671d74f8690f8c6">aggregateStatistics</a> (const std::string \&tableName, const std::string \&columnName, const std::string \&stats, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1AggregateStatisticsResponse">AggregateStatisticsResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Calculates the requested statistics of the given column(s) in a given table. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AggregateStatisticsByRangeResponse">AggregateStatisticsByRangeResponse</a> </td>
        <td><a href="#ab4b8d8c9fb721c8337fc9ffec67118df">aggregateStatisticsByRange</a> (const <a href="/content/api/cpp/structgpudb_1_1AggregateStatisticsByRangeRequest">AggregateStatisticsByRangeRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Divides the given set into bins and calculates statistics of the values of a value-column in each bin. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AggregateStatisticsByRangeResponse">AggregateStatisticsByRangeResponse</a> & </td>
        <td><a href="#ac462c1d0e86217293522998fa6923381">aggregateStatisticsByRange</a> (const <a href="/content/api/cpp/structgpudb_1_1AggregateStatisticsByRangeRequest">AggregateStatisticsByRangeRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1AggregateStatisticsByRangeResponse">AggregateStatisticsByRangeResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Divides the given set into bins and calculates statistics of the values of a value-column in each bin. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AggregateStatisticsByRangeResponse">AggregateStatisticsByRangeResponse</a> </td>
        <td><a href="#a5edaf858ba73c3e2582e0d9c9266277e">aggregateStatisticsByRange</a> (const std::string \&tableName, const std::string \&selectExpression, const std::string \&columnName, const std::string \&valueColumnName, const std::string \&stats, const double start, const double end, const double interval, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Divides the given set into bins and calculates statistics of the values of a value-column in each bin. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AggregateStatisticsByRangeResponse">AggregateStatisticsByRangeResponse</a> & </td>
        <td><a href="#a4877d3a8fdad666d77809b3d1ded333b">aggregateStatisticsByRange</a> (const std::string \&tableName, const std::string \&selectExpression, const std::string \&columnName, const std::string \&valueColumnName, const std::string \&stats, const double start, const double end, const double interval, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1AggregateStatisticsByRangeResponse">AggregateStatisticsByRangeResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Divides the given set into bins and calculates statistics of the values of a value-column in each bin. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1RawAggregateUniqueResponse">RawAggregateUniqueResponse</a> </td>
        <td><a href="#ac9490ba63fb5203c35caad4458a0e17f">aggregateUniqueRaw</a> (const <a href="/content/api/cpp/structgpudb_1_1AggregateUniqueRequest">AggregateUniqueRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Returns all the unique values from a particular column (specified by <a href="/content/api/cpp/structgpudb_1_1AggregateUniqueRequest#a3fdc4b7bccd3b9fcd14ab1b45b6c3cb0">columnName</a>) of a particular table or view (specified by <a href="/content/api/cpp/structgpudb_1_1AggregateUniqueRequest#a328a501af128cf4c6a0e48b705d98360">tableName</a>). <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1RawAggregateUniqueResponse">RawAggregateUniqueResponse</a> & </td>
        <td><a href="#ac6cb1c7220529cbdc386956135c7dbd1">aggregateUniqueRaw</a> (const <a href="/content/api/cpp/structgpudb_1_1AggregateUniqueRequest">AggregateUniqueRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1RawAggregateUniqueResponse">RawAggregateUniqueResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Returns all the unique values from a particular column (specified by <a href="/content/api/cpp/structgpudb_1_1AggregateUniqueRequest#a3fdc4b7bccd3b9fcd14ab1b45b6c3cb0">columnName</a>) of a particular table or view (specified by <a href="/content/api/cpp/structgpudb_1_1AggregateUniqueRequest#a328a501af128cf4c6a0e48b705d98360">tableName</a>). <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AggregateUniqueResponse">AggregateUniqueResponse</a> </td>
        <td><a href="#a19a392ef8588ef5bef4b650a2b7a99ba">aggregateUnique</a> (const <a href="/content/api/cpp/structgpudb_1_1AggregateUniqueRequest">AggregateUniqueRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Returns all the unique values from a particular column (specified by <a href="/content/api/cpp/structgpudb_1_1AggregateUniqueRequest#a3fdc4b7bccd3b9fcd14ab1b45b6c3cb0">columnName</a>) of a particular table or view (specified by <a href="/content/api/cpp/structgpudb_1_1AggregateUniqueRequest#a328a501af128cf4c6a0e48b705d98360">tableName</a>). <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AggregateUniqueResponse">AggregateUniqueResponse</a> & </td>
        <td><a href="#a8b74de77f46fc621091997a4eb60b116">aggregateUnique</a> (const <a href="/content/api/cpp/structgpudb_1_1AggregateUniqueRequest">AggregateUniqueRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1AggregateUniqueResponse">AggregateUniqueResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Returns all the unique values from a particular column (specified by <a href="/content/api/cpp/structgpudb_1_1AggregateUniqueRequest#a3fdc4b7bccd3b9fcd14ab1b45b6c3cb0">columnName</a>) of a particular table or view (specified by <a href="/content/api/cpp/structgpudb_1_1AggregateUniqueRequest#a328a501af128cf4c6a0e48b705d98360">tableName</a>). <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AggregateUniqueResponse">AggregateUniqueResponse</a> </td>
        <td><a href="#a5a23184b011dc1f0fea7b2486c7d195e">aggregateUnique</a> (const std::string \&tableName, const std::string \&columnName, const int64\_t offset, const int64\_t limit, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Returns all the unique values from a particular column (specified by <span>columnName</span>) of a particular table or view (specified by <span>tableName</span>). <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AggregateUniqueResponse">AggregateUniqueResponse</a> & </td>
        <td><a href="#acecb5a2b0ce05acfcff56998bd6f6d5c">aggregateUnique</a> (const std::string \&tableName, const std::string \&columnName, const int64\_t offset, const int64\_t limit, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1AggregateUniqueResponse">AggregateUniqueResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Returns all the unique values from a particular column (specified by <span>columnName</span>) of a particular table or view (specified by <span>tableName</span>). <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1RawAggregateUnpivotResponse">RawAggregateUnpivotResponse</a> </td>
        <td><a href="#a147bb1df6e7e6a862c49f148642bde3b">aggregateUnpivotRaw</a> (const <a href="/content/api/cpp/structgpudb_1_1AggregateUnpivotRequest">AggregateUnpivotRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Rotate the column values into rows values. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1RawAggregateUnpivotResponse">RawAggregateUnpivotResponse</a> & </td>
        <td><a href="#ac1b8c35f677977449dee7e9d7361c1b1">aggregateUnpivotRaw</a> (const <a href="/content/api/cpp/structgpudb_1_1AggregateUnpivotRequest">AggregateUnpivotRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1RawAggregateUnpivotResponse">RawAggregateUnpivotResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Rotate the column values into rows values. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AggregateUnpivotResponse">AggregateUnpivotResponse</a> </td>
        <td><a href="#abb9e5e7039f10b231076f29aa7a01f13">aggregateUnpivot</a> (const <a href="/content/api/cpp/structgpudb_1_1AggregateUnpivotRequest">AggregateUnpivotRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Rotate the column values into rows values. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AggregateUnpivotResponse">AggregateUnpivotResponse</a> & </td>
        <td><a href="#a230c26f2273d7f4c8557ea6d855880be">aggregateUnpivot</a> (const <a href="/content/api/cpp/structgpudb_1_1AggregateUnpivotRequest">AggregateUnpivotRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1AggregateUnpivotResponse">AggregateUnpivotResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Rotate the column values into rows values. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AggregateUnpivotResponse">AggregateUnpivotResponse</a> </td>
        <td><a href="#a1d1d8a9064e31a9e7a790a026c5d484c">aggregateUnpivot</a> (const std::string \&tableName, const std::vector\< std::string > \&columnNames, const std::string \&variableColumnName, const std::string \&valueColumnName, const std::vector\< std::string > \&pivotedColumns, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Rotate the column values into rows values. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AggregateUnpivotResponse">AggregateUnpivotResponse</a> & </td>
        <td><a href="#aa11b6bb15992bc255b391433441d5f40">aggregateUnpivot</a> (const std::string \&tableName, const std::vector\< std::string > \&columnNames, const std::string \&variableColumnName, const std::string \&valueColumnName, const std::vector\< std::string > \&pivotedColumns, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1AggregateUnpivotResponse">AggregateUnpivotResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Rotate the column values into rows values. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AlterBackupResponse">AlterBackupResponse</a> </td>
        <td><a href="#a0d261d4f3dab25f405d4c23d98957d50">alterBackup</a> (const <a href="/content/api/cpp/structgpudb_1_1AlterBackupRequest">AlterBackupRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Alters an existing database <a href="/content/admin/backup_restore/#database-backup">backup</a>, accessible via the <a href="/content/concepts/data_sinks/">data sink</a> specified by <a href="/content/api/cpp/structgpudb_1_1AlterBackupRequest#afb40c34397bdfd1b9fd1cbba27a85ef0">datasinkName</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AlterBackupResponse">AlterBackupResponse</a> & </td>
        <td><a href="#a1f41e6f7246ec165a78018ebc4e14bb1">alterBackup</a> (const <a href="/content/api/cpp/structgpudb_1_1AlterBackupRequest">AlterBackupRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1AlterBackupResponse">AlterBackupResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Alters an existing database <a href="/content/admin/backup_restore/#database-backup">backup</a>, accessible via the <a href="/content/concepts/data_sinks/">data sink</a> specified by <a href="/content/api/cpp/structgpudb_1_1AlterBackupRequest#afb40c34397bdfd1b9fd1cbba27a85ef0">datasinkName</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AlterBackupResponse">AlterBackupResponse</a> </td>
        <td><a href="#a8d54f289d7c4c7630c3bf7d582a3473c">alterBackup</a> (const std::string \&backupName, const std::string \&action, const std::string \&value, const std::string \&datasinkName, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Alters an existing database <a href="/content/admin/backup_restore/#database-backup">backup</a>, accessible via the <a href="/content/concepts/data_sinks/">data sink</a> specified by <span>datasinkName</span>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AlterBackupResponse">AlterBackupResponse</a> & </td>
        <td><a href="#aac2057974412bc4ecd18b7d997dfddec">alterBackup</a> (const std::string \&backupName, const std::string \&action, const std::string \&value, const std::string \&datasinkName, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1AlterBackupResponse">AlterBackupResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Alters an existing database <a href="/content/admin/backup_restore/#database-backup">backup</a>, accessible via the <a href="/content/concepts/data_sinks/">data sink</a> specified by <span>datasinkName</span>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AlterCredentialResponse">AlterCredentialResponse</a> </td>
        <td><a href="#a19066a22f5900356bc3548de446d3479">alterCredential</a> (const <a href="/content/api/cpp/structgpudb_1_1AlterCredentialRequest">AlterCredentialRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Alter the properties of an existing <a href="/content/concepts/credentials/">credential</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AlterCredentialResponse">AlterCredentialResponse</a> & </td>
        <td><a href="#ad9f46493013dfadf7407f4eb354c2471">alterCredential</a> (const <a href="/content/api/cpp/structgpudb_1_1AlterCredentialRequest">AlterCredentialRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1AlterCredentialResponse">AlterCredentialResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Alter the properties of an existing <a href="/content/concepts/credentials/">credential</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AlterCredentialResponse">AlterCredentialResponse</a> </td>
        <td><a href="#adaa26ea985ede026372964285b8db9dc">alterCredential</a> (const std::string \&credentialName, const std::map\< std::string, std::string > \&credentialUpdatesMap, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Alter the properties of an existing <a href="/content/concepts/credentials/">credential</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AlterCredentialResponse">AlterCredentialResponse</a> & </td>
        <td><a href="#ab10b0b8b3f630025364dba27f0f565ba">alterCredential</a> (const std::string \&credentialName, const std::map\< std::string, std::string > \&credentialUpdatesMap, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1AlterCredentialResponse">AlterCredentialResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Alter the properties of an existing <a href="/content/concepts/credentials/">credential</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AlterDatasinkResponse">AlterDatasinkResponse</a> </td>
        <td><a href="#aa7b2ae37561ffd0675a2ec5d18b6e5ce">alterDatasink</a> (const <a href="/content/api/cpp/structgpudb_1_1AlterDatasinkRequest">AlterDatasinkRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Alters the properties of an existing <a href="/content/concepts/data_sinks/">data sink</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AlterDatasinkResponse">AlterDatasinkResponse</a> & </td>
        <td><a href="#a52113bd44be00a37c4d3b09e48fb4216">alterDatasink</a> (const <a href="/content/api/cpp/structgpudb_1_1AlterDatasinkRequest">AlterDatasinkRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1AlterDatasinkResponse">AlterDatasinkResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Alters the properties of an existing <a href="/content/concepts/data_sinks/">data sink</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AlterDatasinkResponse">AlterDatasinkResponse</a> </td>
        <td><a href="#a8bbff72646e20ac38334c69ec48fe439">alterDatasink</a> (const std::string \&name, const std::map\< std::string, std::string > \&datasinkUpdatesMap, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Alters the properties of an existing <a href="/content/concepts/data_sinks/">data sink</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AlterDatasinkResponse">AlterDatasinkResponse</a> & </td>
        <td><a href="#aa2db6301075d7952d4dc8d26846ac6fb">alterDatasink</a> (const std::string \&name, const std::map\< std::string, std::string > \&datasinkUpdatesMap, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1AlterDatasinkResponse">AlterDatasinkResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Alters the properties of an existing <a href="/content/concepts/data_sinks/">data sink</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AlterDatasourceResponse">AlterDatasourceResponse</a> </td>
        <td><a href="#a3b682ba6dcd6140d7d489a9c1b76cf79">alterDatasource</a> (const <a href="/content/api/cpp/structgpudb_1_1AlterDatasourceRequest">AlterDatasourceRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Alters the properties of an existing <a href="/content/concepts/data_sources/">data source</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AlterDatasourceResponse">AlterDatasourceResponse</a> & </td>
        <td><a href="#ab0c1a104ed6622a2b8ed7f0de4eddb86">alterDatasource</a> (const <a href="/content/api/cpp/structgpudb_1_1AlterDatasourceRequest">AlterDatasourceRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1AlterDatasourceResponse">AlterDatasourceResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Alters the properties of an existing <a href="/content/concepts/data_sources/">data source</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AlterDatasourceResponse">AlterDatasourceResponse</a> </td>
        <td><a href="#a373cdecccdabad5291381d131f5d1368">alterDatasource</a> (const std::string \&name, const std::map\< std::string, std::string > \&datasourceUpdatesMap, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Alters the properties of an existing <a href="/content/concepts/data_sources/">data source</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AlterDatasourceResponse">AlterDatasourceResponse</a> & </td>
        <td><a href="#ab1dd1115e2c83d49af739259642a95d5">alterDatasource</a> (const std::string \&name, const std::map\< std::string, std::string > \&datasourceUpdatesMap, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1AlterDatasourceResponse">AlterDatasourceResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Alters the properties of an existing <a href="/content/concepts/data_sources/">data source</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AlterDirectoryResponse">AlterDirectoryResponse</a> </td>
        <td><a href="#ad980efe5cc24d3a87cec53c4530b153f">alterDirectory</a> (const <a href="/content/api/cpp/structgpudb_1_1AlterDirectoryRequest">AlterDirectoryRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Alters an existing directory in <a href="/content/tools/kifs/">KiFS</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AlterDirectoryResponse">AlterDirectoryResponse</a> & </td>
        <td><a href="#a7c13a227235c2670b4f421e2309a277d">alterDirectory</a> (const <a href="/content/api/cpp/structgpudb_1_1AlterDirectoryRequest">AlterDirectoryRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1AlterDirectoryResponse">AlterDirectoryResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Alters an existing directory in <a href="/content/tools/kifs/">KiFS</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AlterDirectoryResponse">AlterDirectoryResponse</a> </td>
        <td><a href="#a37f7f5e91df5a80b3c600cb69cfa22c6">alterDirectory</a> (const std::string \&directoryName, const std::map\< std::string, std::string > \&directoryUpdatesMap, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Alters an existing directory in <a href="/content/tools/kifs/">KiFS</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AlterDirectoryResponse">AlterDirectoryResponse</a> & </td>
        <td><a href="#a404cc8288ba6485910fea40740bcd09c">alterDirectory</a> (const std::string \&directoryName, const std::map\< std::string, std::string > \&directoryUpdatesMap, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1AlterDirectoryResponse">AlterDirectoryResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Alters an existing directory in <a href="/content/tools/kifs/">KiFS</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AlterEnvironmentResponse">AlterEnvironmentResponse</a> </td>
        <td><a href="#a7ad22467beee2568754047af78a7bf90">alterEnvironment</a> (const <a href="/content/api/cpp/structgpudb_1_1AlterEnvironmentRequest">AlterEnvironmentRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Alters an existing environment which can be referenced by a <a href="/content/concepts/udf/">user-defined function</a> (UDF). <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AlterEnvironmentResponse">AlterEnvironmentResponse</a> & </td>
        <td><a href="#ae4f9b2cdbdf0fb844a552aa6844af675">alterEnvironment</a> (const <a href="/content/api/cpp/structgpudb_1_1AlterEnvironmentRequest">AlterEnvironmentRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1AlterEnvironmentResponse">AlterEnvironmentResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Alters an existing environment which can be referenced by a <a href="/content/concepts/udf/">user-defined function</a> (UDF). <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AlterEnvironmentResponse">AlterEnvironmentResponse</a> </td>
        <td><a href="#a908327f53abc3d0337024fa7adca1f77">alterEnvironment</a> (const std::string \&environmentName, const std::string \&action, const std::string \&value, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Alters an existing environment which can be referenced by a <a href="/content/concepts/udf/">user-defined function</a> (UDF). <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AlterEnvironmentResponse">AlterEnvironmentResponse</a> & </td>
        <td><a href="#a27395e3418456675335c8547725fe5af">alterEnvironment</a> (const std::string \&environmentName, const std::string \&action, const std::string \&value, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1AlterEnvironmentResponse">AlterEnvironmentResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Alters an existing environment which can be referenced by a <a href="/content/concepts/udf/">user-defined function</a> (UDF). <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AlterResourceGroupResponse">AlterResourceGroupResponse</a> </td>
        <td><a href="#a52be74f95cad4c445058fd741a9f4599">alterResourceGroup</a> (const <a href="/content/api/cpp/structgpudb_1_1AlterResourceGroupRequest">AlterResourceGroupRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Alters the properties of an existing resource group to facilitate resource management. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AlterResourceGroupResponse">AlterResourceGroupResponse</a> & </td>
        <td><a href="#a13779227bf194104ef206c1fc7664a60">alterResourceGroup</a> (const <a href="/content/api/cpp/structgpudb_1_1AlterResourceGroupRequest">AlterResourceGroupRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1AlterResourceGroupResponse">AlterResourceGroupResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Alters the properties of an existing resource group to facilitate resource management. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AlterResourceGroupResponse">AlterResourceGroupResponse</a> </td>
        <td><a href="#a82dd3d7d904bd8a75b2e768f4e51ac0a">alterResourceGroup</a> (const std::string \&name, const std::map\< std::string, std::map\< std::string, std::string > > \&tierAttributes, const std::string \&ranking, const std::string \&adjoiningResourceGroup, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Alters the properties of an existing resource group to facilitate resource management. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AlterResourceGroupResponse">AlterResourceGroupResponse</a> & </td>
        <td><a href="#a57bf15b9abc04e0d2bbd03aa67fb4239">alterResourceGroup</a> (const std::string \&name, const std::map\< std::string, std::map\< std::string, std::string > > \&tierAttributes, const std::string \&ranking, const std::string \&adjoiningResourceGroup, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1AlterResourceGroupResponse">AlterResourceGroupResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Alters the properties of an existing resource group to facilitate resource management. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AlterRoleResponse">AlterRoleResponse</a> </td>
        <td><a href="#afa8f2a294e46d5e721e16056e6decd6a">alterRole</a> (const <a href="/content/api/cpp/structgpudb_1_1AlterRoleRequest">AlterRoleRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Alters a Role. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AlterRoleResponse">AlterRoleResponse</a> & </td>
        <td><a href="#a52ab59dced4e08c16a2fb4199d7e0ba4">alterRole</a> (const <a href="/content/api/cpp/structgpudb_1_1AlterRoleRequest">AlterRoleRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1AlterRoleResponse">AlterRoleResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Alters a Role. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AlterRoleResponse">AlterRoleResponse</a> </td>
        <td><a href="#a68bca33d047ff23768cb913a2d6f210f">alterRole</a> (const std::string \&name, const std::string \&action, const std::string \&value, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Alters a Role. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AlterRoleResponse">AlterRoleResponse</a> & </td>
        <td><a href="#a316c3cbc12eb0e418e43d5872f5767ec">alterRole</a> (const std::string \&name, const std::string \&action, const std::string \&value, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1AlterRoleResponse">AlterRoleResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Alters a Role. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AlterSchemaResponse">AlterSchemaResponse</a> </td>
        <td><a href="#a6d8737eef0ac5964bafee8168c7001c2">alterSchema</a> (const <a href="/content/api/cpp/structgpudb_1_1AlterSchemaRequest">AlterSchemaRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Used to change the name of a SQL-style <a href="/content/concepts/schemas/">schema</a>, specified in <a href="/content/api/cpp/structgpudb_1_1AlterSchemaRequest#a5d2aa8bd3561ad50e0ff38b0fb54e188">schemaName</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AlterSchemaResponse">AlterSchemaResponse</a> & </td>
        <td><a href="#afe7e4516bdc03ae78bcac0da1eab7308">alterSchema</a> (const <a href="/content/api/cpp/structgpudb_1_1AlterSchemaRequest">AlterSchemaRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1AlterSchemaResponse">AlterSchemaResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Used to change the name of a SQL-style <a href="/content/concepts/schemas/">schema</a>, specified in <a href="/content/api/cpp/structgpudb_1_1AlterSchemaRequest#a5d2aa8bd3561ad50e0ff38b0fb54e188">schemaName</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AlterSchemaResponse">AlterSchemaResponse</a> </td>
        <td><a href="#ac3b14375b824755702348959f65b809b">alterSchema</a> (const std::string \&schemaName, const std::string \&action, const std::string \&value, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Used to change the name of a SQL-style <a href="/content/concepts/schemas/">schema</a>, specified in <span>schemaName</span>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AlterSchemaResponse">AlterSchemaResponse</a> & </td>
        <td><a href="#a06fbae44bfb19d07d0336d2fa2baa9de">alterSchema</a> (const std::string \&schemaName, const std::string \&action, const std::string \&value, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1AlterSchemaResponse">AlterSchemaResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Used to change the name of a SQL-style <a href="/content/concepts/schemas/">schema</a>, specified in <span>schemaName</span>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AlterSystemPropertiesResponse">AlterSystemPropertiesResponse</a> </td>
        <td><a href="#a9e3cf621f47f06fb5211ae54f1e46f93">alterSystemProperties</a> (const <a href="/content/api/cpp/structgpudb_1_1AlterSystemPropertiesRequest">AlterSystemPropertiesRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>The <a href="#a9e3cf621f47f06fb5211ae54f1e46f93">alterSystemProperties</a> endpoint is primarily used to simplify the testing of the system and is not expected to be used during normal execution. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AlterSystemPropertiesResponse">AlterSystemPropertiesResponse</a> & </td>
        <td><a href="#a725871fdb042d46d3ba27650b0cbd6d4">alterSystemProperties</a> (const <a href="/content/api/cpp/structgpudb_1_1AlterSystemPropertiesRequest">AlterSystemPropertiesRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1AlterSystemPropertiesResponse">AlterSystemPropertiesResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>The <a href="#a9e3cf621f47f06fb5211ae54f1e46f93">alterSystemProperties</a> endpoint is primarily used to simplify the testing of the system and is not expected to be used during normal execution. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AlterSystemPropertiesResponse">AlterSystemPropertiesResponse</a> </td>
        <td><a href="#a3c2c2636d3219216039c6ea52176acfd">alterSystemProperties</a> (const std::map\< std::string, std::string > \&propertyUpdatesMap, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>The <a href="#a3c2c2636d3219216039c6ea52176acfd">alterSystemProperties</a> endpoint is primarily used to simplify the testing of the system and is not expected to be used during normal execution. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AlterSystemPropertiesResponse">AlterSystemPropertiesResponse</a> & </td>
        <td><a href="#a4bdc47a1dd96b3a0af606a967eb8b00a">alterSystemProperties</a> (const std::map\< std::string, std::string > \&propertyUpdatesMap, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1AlterSystemPropertiesResponse">AlterSystemPropertiesResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>The <a href="#a3c2c2636d3219216039c6ea52176acfd">alterSystemProperties</a> endpoint is primarily used to simplify the testing of the system and is not expected to be used during normal execution. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AlterTableResponse">AlterTableResponse</a> </td>
        <td><a href="#aeddf28ff22f4a296e4b00864bf251f79">alterTable</a> (const <a href="/content/api/cpp/structgpudb_1_1AlterTableRequest">AlterTableRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Apply various modifications to a table or view. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AlterTableResponse">AlterTableResponse</a> & </td>
        <td><a href="#af5f1590fded46609425461f4b8ce06c4">alterTable</a> (const <a href="/content/api/cpp/structgpudb_1_1AlterTableRequest">AlterTableRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1AlterTableResponse">AlterTableResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Apply various modifications to a table or view. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AlterTableResponse">AlterTableResponse</a> </td>
        <td><a href="#a25df43fa85e02f0cdb3dab9e498995ce">alterTable</a> (const std::string \&tableName, const std::string \&action, const std::string \&value, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Apply various modifications to a table or view. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AlterTableResponse">AlterTableResponse</a> & </td>
        <td><a href="#ad081259f73604987cb28a53d129a3774">alterTable</a> (const std::string \&tableName, const std::string \&action, const std::string \&value, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1AlterTableResponse">AlterTableResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Apply various modifications to a table or view. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AlterTableColumnsResponse">AlterTableColumnsResponse</a> </td>
        <td><a href="#a8ec207082dc6a0254352082c611ec00f">alterTableColumns</a> (const <a href="/content/api/cpp/structgpudb_1_1AlterTableColumnsRequest">AlterTableColumnsRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Apply various modifications to columns in a table, view. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AlterTableColumnsResponse">AlterTableColumnsResponse</a> & </td>
        <td><a href="#a93339aac570739da8946cab714a37c4f">alterTableColumns</a> (const <a href="/content/api/cpp/structgpudb_1_1AlterTableColumnsRequest">AlterTableColumnsRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1AlterTableColumnsResponse">AlterTableColumnsResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Apply various modifications to columns in a table, view. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AlterTableColumnsResponse">AlterTableColumnsResponse</a> </td>
        <td><a href="#a9ce980a546b63a37ceed13ad5fa137c6">alterTableColumns</a> (const std::string \&tableName, const std::vector\< std::map\< std::string, std::string > > \&columnAlterations, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Apply various modifications to columns in a table, view. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AlterTableColumnsResponse">AlterTableColumnsResponse</a> & </td>
        <td><a href="#ae09fa70851a84483c624d215193de11e">alterTableColumns</a> (const std::string \&tableName, const std::vector\< std::map\< std::string, std::string > > \&columnAlterations, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1AlterTableColumnsResponse">AlterTableColumnsResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Apply various modifications to columns in a table, view. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AlterTableMetadataResponse">AlterTableMetadataResponse</a> </td>
        <td><a href="#a4fbed5af394ba543a8722e34e0ca8aa4">alterTableMetadata</a> (const <a href="/content/api/cpp/structgpudb_1_1AlterTableMetadataRequest">AlterTableMetadataRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Updates (adds or changes) metadata for tables. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AlterTableMetadataResponse">AlterTableMetadataResponse</a> & </td>
        <td><a href="#ab7b4faf8b1176e08efdd4fca9a263856">alterTableMetadata</a> (const <a href="/content/api/cpp/structgpudb_1_1AlterTableMetadataRequest">AlterTableMetadataRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1AlterTableMetadataResponse">AlterTableMetadataResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Updates (adds or changes) metadata for tables. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AlterTableMetadataResponse">AlterTableMetadataResponse</a> </td>
        <td><a href="#a5ef861b64a087a87b2f545dbe6f83f6f">alterTableMetadata</a> (const std::vector\< std::string > \&tableNames, const std::map\< std::string, std::string > \&metadataMap, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Updates (adds or changes) metadata for tables. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AlterTableMetadataResponse">AlterTableMetadataResponse</a> & </td>
        <td><a href="#a8712c324d3df8f291685f62b9e1b7cb6">alterTableMetadata</a> (const std::vector\< std::string > \&tableNames, const std::map\< std::string, std::string > \&metadataMap, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1AlterTableMetadataResponse">AlterTableMetadataResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Updates (adds or changes) metadata for tables. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AlterTableMonitorResponse">AlterTableMonitorResponse</a> </td>
        <td><a href="#aea7ba4ba63117605613ac472447e3380">alterTableMonitor</a> (const <a href="/content/api/cpp/structgpudb_1_1AlterTableMonitorRequest">AlterTableMonitorRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Alters a table monitor previously created with <a href="#ab379d6656d94cb2e54be2671ecd05d6c">createTableMonitor</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AlterTableMonitorResponse">AlterTableMonitorResponse</a> & </td>
        <td><a href="#aad0c37c21cebb342fce591c2175979fd">alterTableMonitor</a> (const <a href="/content/api/cpp/structgpudb_1_1AlterTableMonitorRequest">AlterTableMonitorRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1AlterTableMonitorResponse">AlterTableMonitorResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Alters a table monitor previously created with <a href="#ab379d6656d94cb2e54be2671ecd05d6c">createTableMonitor</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AlterTableMonitorResponse">AlterTableMonitorResponse</a> </td>
        <td><a href="#a4d8ad3c726a24bebbe3d100c17bf9e00">alterTableMonitor</a> (const std::string \&topicId, const std::map\< std::string, std::string > \&monitorUpdatesMap, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Alters a table monitor previously created with <a href="#a562dc443f79f57ea572cb5ec0f2e8093">createTableMonitor</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AlterTableMonitorResponse">AlterTableMonitorResponse</a> & </td>
        <td><a href="#ad9cbebd143dc0b393c44a3edcb181746">alterTableMonitor</a> (const std::string \&topicId, const std::map\< std::string, std::string > \&monitorUpdatesMap, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1AlterTableMonitorResponse">AlterTableMonitorResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Alters a table monitor previously created with <a href="#a562dc443f79f57ea572cb5ec0f2e8093">createTableMonitor</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AlterTierResponse">AlterTierResponse</a> </td>
        <td><a href="#ae73f596fa5539fff857b7312f5627a52">alterTier</a> (const <a href="/content/api/cpp/structgpudb_1_1AlterTierRequest">AlterTierRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Alters properties of an existing <a href="/content/rm/concepts/#storage-tiers">tier</a> to facilitate <a href="/content/rm/concepts/">resource management</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AlterTierResponse">AlterTierResponse</a> & </td>
        <td><a href="#a1a309e9177463c0e04236d41d7862a7d">alterTier</a> (const <a href="/content/api/cpp/structgpudb_1_1AlterTierRequest">AlterTierRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1AlterTierResponse">AlterTierResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Alters properties of an existing <a href="/content/rm/concepts/#storage-tiers">tier</a> to facilitate <a href="/content/rm/concepts/">resource management</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AlterTierResponse">AlterTierResponse</a> </td>
        <td><a href="#ad0ef8535f3d31c0ed146d697ef1e524e">alterTier</a> (const std::string \&name, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Alters properties of an existing <a href="/content/rm/concepts/#storage-tiers">tier</a> to facilitate <a href="/content/rm/concepts/">resource management</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AlterTierResponse">AlterTierResponse</a> & </td>
        <td><a href="#a13674a20aec621b0560ea8d896b270f8">alterTier</a> (const std::string \&name, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1AlterTierResponse">AlterTierResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Alters properties of an existing <a href="/content/rm/concepts/#storage-tiers">tier</a> to facilitate <a href="/content/rm/concepts/">resource management</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AlterUserResponse">AlterUserResponse</a> </td>
        <td><a href="#a4677397b6e719dfa44657790d64bc6ae">alterUser</a> (const <a href="/content/api/cpp/structgpudb_1_1AlterUserRequest">AlterUserRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Alters a user. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AlterUserResponse">AlterUserResponse</a> & </td>
        <td><a href="#a927df937dad09d422fe2c60e4f41d1e6">alterUser</a> (const <a href="/content/api/cpp/structgpudb_1_1AlterUserRequest">AlterUserRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1AlterUserResponse">AlterUserResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Alters a user. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AlterUserResponse">AlterUserResponse</a> </td>
        <td><a href="#a39c7b6e35407837c195f99e004e6c000">alterUser</a> (const std::string \&name, const std::string \&action, const std::string \&value, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Alters a user. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AlterUserResponse">AlterUserResponse</a> & </td>
        <td><a href="#aed7c48162601a63c3a8331740de86645">alterUser</a> (const std::string \&name, const std::string \&action, const std::string \&value, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1AlterUserResponse">AlterUserResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Alters a user. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AlterVideoResponse">AlterVideoResponse</a> </td>
        <td><a href="#affb51f3e7d9b872b955d0737b3273902">alterVideo</a> (const <a href="/content/api/cpp/structgpudb_1_1AlterVideoRequest">AlterVideoRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Alters a video. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AlterVideoResponse">AlterVideoResponse</a> & </td>
        <td><a href="#afab1da5e43c5aeb1c56c986546571c45">alterVideo</a> (const <a href="/content/api/cpp/structgpudb_1_1AlterVideoRequest">AlterVideoRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1AlterVideoResponse">AlterVideoResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Alters a video. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AlterVideoResponse">AlterVideoResponse</a> </td>
        <td><a href="#ac28c02fe9b43db4d270948b741c2c866">alterVideo</a> (const std::string \&path, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Alters a video. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AlterVideoResponse">AlterVideoResponse</a> & </td>
        <td><a href="#a7588fad781eeea0770caf70f4b3a9317">alterVideo</a> (const std::string \&path, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1AlterVideoResponse">AlterVideoResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Alters a video. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AlterWalResponse">AlterWalResponse</a> </td>
        <td><a href="#a982dab90baf6bd12035b69342f8187a3">alterWal</a> (const <a href="/content/api/cpp/structgpudb_1_1AlterWalRequest">AlterWalRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Alters table write-ahead log (WAL) settings. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AlterWalResponse">AlterWalResponse</a> & </td>
        <td><a href="#af3d0a716ce6da913df55c114c99d7cb1">alterWal</a> (const <a href="/content/api/cpp/structgpudb_1_1AlterWalRequest">AlterWalRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1AlterWalResponse">AlterWalResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Alters table write-ahead log (WAL) settings. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AlterWalResponse">AlterWalResponse</a> </td>
        <td><a href="#ae392fc22d368ad7a63525ad09fb333b8">alterWal</a> (const std::vector\< std::string > \&tableNames, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Alters table write-ahead log (WAL) settings. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AlterWalResponse">AlterWalResponse</a> & </td>
        <td><a href="#a87d7bf3ba965adcab6f283754f470c94">alterWal</a> (const std::vector\< std::string > \&tableNames, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1AlterWalResponse">AlterWalResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Alters table write-ahead log (WAL) settings. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AppendRecordsResponse">AppendRecordsResponse</a> </td>
        <td><a href="#ac902ab53fb7c2f952e232315b7cb6536">appendRecords</a> (const <a href="/content/api/cpp/structgpudb_1_1AppendRecordsRequest">AppendRecordsRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Append (or insert) all records from a source table (specified by <a href="/content/api/cpp/structgpudb_1_1AppendRecordsRequest#a007088ffb6142dd12803205edb8772ff">sourceTableName</a>) to a particular target table (specified by <a href="/content/api/cpp/structgpudb_1_1AppendRecordsRequest#a1f38b6189aefb233a3a6820263f063ac">tableName</a>). <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AppendRecordsResponse">AppendRecordsResponse</a> & </td>
        <td><a href="#a20ee0685b5f6505eb483d369c8649f9b">appendRecords</a> (const <a href="/content/api/cpp/structgpudb_1_1AppendRecordsRequest">AppendRecordsRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1AppendRecordsResponse">AppendRecordsResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Append (or insert) all records from a source table (specified by <a href="/content/api/cpp/structgpudb_1_1AppendRecordsRequest#a007088ffb6142dd12803205edb8772ff">sourceTableName</a>) to a particular target table (specified by <a href="/content/api/cpp/structgpudb_1_1AppendRecordsRequest#a1f38b6189aefb233a3a6820263f063ac">tableName</a>). <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AppendRecordsResponse">AppendRecordsResponse</a> </td>
        <td><a href="#ad2068df53aa2615c45e9bb2586387a27">appendRecords</a> (const std::string \&tableName, const std::string \&sourceTableName, const std::map\< std::string, std::string > \&fieldMap, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Append (or insert) all records from a source table (specified by <span>sourceTableName</span>) to a particular target table (specified by <span>tableName</span>). <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1AppendRecordsResponse">AppendRecordsResponse</a> & </td>
        <td><a href="#acebe4ac75a8f120e5de64daa9535b25e">appendRecords</a> (const std::string \&tableName, const std::string \&sourceTableName, const std::map\< std::string, std::string > \&fieldMap, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1AppendRecordsResponse">AppendRecordsResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Append (or insert) all records from a source table (specified by <span>sourceTableName</span>) to a particular target table (specified by <span>tableName</span>). <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CheckTableResponse">CheckTableResponse</a> </td>
        <td><a href="#a90b3a1ea70450b92e93bcc38ca4e5658">checkTable</a> (const <a href="/content/api/cpp/structgpudb_1_1CheckTableRequest">CheckTableRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Scans the requested tables as specified in <a href="/content/api/cpp/structgpudb_1_1CheckTableRequest#a86963be684731f0b74fd1c68633cd15c">tableNames</a> for integrity. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CheckTableResponse">CheckTableResponse</a> & </td>
        <td><a href="#adebe60a19cff32b856f6b0fdf65fa742">checkTable</a> (const <a href="/content/api/cpp/structgpudb_1_1CheckTableRequest">CheckTableRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1CheckTableResponse">CheckTableResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Scans the requested tables as specified in <a href="/content/api/cpp/structgpudb_1_1CheckTableRequest#a86963be684731f0b74fd1c68633cd15c">tableNames</a> for integrity. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CheckTableResponse">CheckTableResponse</a> </td>
        <td><a href="#af3c5071524742d67504b556411ccca18">checkTable</a> (const std::vector\< std::string > \&tableNames, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Scans the requested tables as specified in <span>tableNames</span> for integrity. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CheckTableResponse">CheckTableResponse</a> & </td>
        <td><a href="#a3ffa91f42f974de2d1872af38fe318f3">checkTable</a> (const std::vector\< std::string > \&tableNames, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1CheckTableResponse">CheckTableResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Scans the requested tables as specified in <span>tableNames</span> for integrity. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ClearStatisticsResponse">ClearStatisticsResponse</a> </td>
        <td><a href="#a4f92562790e4fa6169b14fe3a356d495">clearStatistics</a> (const <a href="/content/api/cpp/structgpudb_1_1ClearStatisticsRequest">ClearStatisticsRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Clears statistics (cardinality, mean value, etc.) for a column in a specified table. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ClearStatisticsResponse">ClearStatisticsResponse</a> & </td>
        <td><a href="#a1db7da64c443bd49d54d3b6643047916">clearStatistics</a> (const <a href="/content/api/cpp/structgpudb_1_1ClearStatisticsRequest">ClearStatisticsRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1ClearStatisticsResponse">ClearStatisticsResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Clears statistics (cardinality, mean value, etc.) for a column in a specified table. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ClearStatisticsResponse">ClearStatisticsResponse</a> </td>
        <td><a href="#ae73eefae2052b3fa6fb5788d819f9e8a">clearStatistics</a> (const std::string \&tableName, const std::string \&columnName, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Clears statistics (cardinality, mean value, etc.) for a column in a specified table. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ClearStatisticsResponse">ClearStatisticsResponse</a> & </td>
        <td><a href="#a8fc73e98a02f047df4bfc89cf0946511">clearStatistics</a> (const std::string \&tableName, const std::string \&columnName, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1ClearStatisticsResponse">ClearStatisticsResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Clears statistics (cardinality, mean value, etc.) for a column in a specified table. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ClearTableResponse">ClearTableResponse</a> </td>
        <td><a href="#a438f915ee5d2c8e5c624610842f47b34">clearTable</a> (const <a href="/content/api/cpp/structgpudb_1_1ClearTableRequest">ClearTableRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Clears (drops) one or all tables in the database cluster. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ClearTableResponse">ClearTableResponse</a> & </td>
        <td><a href="#a05977053bbeeee30aef9c3eccf98bdf3">clearTable</a> (const <a href="/content/api/cpp/structgpudb_1_1ClearTableRequest">ClearTableRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1ClearTableResponse">ClearTableResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Clears (drops) one or all tables in the database cluster. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ClearTableResponse">ClearTableResponse</a> </td>
        <td><a href="#a52e2ee9452af707377a8cca0af68320d">clearTable</a> (const std::string \&tableName, const std::string \&authorization, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Clears (drops) one or all tables in the database cluster. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ClearTableResponse">ClearTableResponse</a> & </td>
        <td><a href="#ae372d9957b28f88e656b4a683fc7de41">clearTable</a> (const std::string \&tableName, const std::string \&authorization, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1ClearTableResponse">ClearTableResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Clears (drops) one or all tables in the database cluster. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ClearTableMonitorResponse">ClearTableMonitorResponse</a> </td>
        <td><a href="#ad2bf08c0671686d9fd13ec177214fa1c">clearTableMonitor</a> (const <a href="/content/api/cpp/structgpudb_1_1ClearTableMonitorRequest">ClearTableMonitorRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Deactivates a table monitor previously created with <a href="#ab379d6656d94cb2e54be2671ecd05d6c">createTableMonitor</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ClearTableMonitorResponse">ClearTableMonitorResponse</a> & </td>
        <td><a href="#acbb596d576cf6071fec8a46cf8f536ca">clearTableMonitor</a> (const <a href="/content/api/cpp/structgpudb_1_1ClearTableMonitorRequest">ClearTableMonitorRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1ClearTableMonitorResponse">ClearTableMonitorResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Deactivates a table monitor previously created with <a href="#ab379d6656d94cb2e54be2671ecd05d6c">createTableMonitor</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ClearTableMonitorResponse">ClearTableMonitorResponse</a> </td>
        <td><a href="#ad85f24dc8ca9ac3d649aaa969febcf25">clearTableMonitor</a> (const std::string \&topicId, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Deactivates a table monitor previously created with <a href="#a562dc443f79f57ea572cb5ec0f2e8093">createTableMonitor</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ClearTableMonitorResponse">ClearTableMonitorResponse</a> & </td>
        <td><a href="#a0d0c0fadbf1e7057cf5e3bfc451e6e49">clearTableMonitor</a> (const std::string \&topicId, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1ClearTableMonitorResponse">ClearTableMonitorResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Deactivates a table monitor previously created with <a href="#a562dc443f79f57ea572cb5ec0f2e8093">createTableMonitor</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ClearTablesResponse">ClearTablesResponse</a> </td>
        <td><a href="#a6ea34c34f63eb6781811eea53b2a7e33">clearTables</a> (const <a href="/content/api/cpp/structgpudb_1_1ClearTablesRequest">ClearTablesRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Clears (drops) tables in the database cluster. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ClearTablesResponse">ClearTablesResponse</a> & </td>
        <td><a href="#aa039ed76125cf6049542860f71f8a2fe">clearTables</a> (const <a href="/content/api/cpp/structgpudb_1_1ClearTablesRequest">ClearTablesRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1ClearTablesResponse">ClearTablesResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Clears (drops) tables in the database cluster. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ClearTablesResponse">ClearTablesResponse</a> </td>
        <td><a href="#ad41cf27b402ded6a1b6876bfcd28770e">clearTables</a> (const std::vector\< std::string > \&tableNames, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Clears (drops) tables in the database cluster. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ClearTablesResponse">ClearTablesResponse</a> & </td>
        <td><a href="#a2be613cf6005c367f6d4f2f9835f2d27">clearTables</a> (const std::vector\< std::string > \&tableNames, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1ClearTablesResponse">ClearTablesResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Clears (drops) tables in the database cluster. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ClearTriggerResponse">ClearTriggerResponse</a> </td>
        <td><a href="#a158a4cbcafb96ac8832f7caeeb07e4b3">clearTrigger</a> (const <a href="/content/api/cpp/structgpudb_1_1ClearTriggerRequest">ClearTriggerRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Clears or cancels the trigger identified by the specified handle. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ClearTriggerResponse">ClearTriggerResponse</a> & </td>
        <td><a href="#a30c0fca7857d41b31082a178e90b024e">clearTrigger</a> (const <a href="/content/api/cpp/structgpudb_1_1ClearTriggerRequest">ClearTriggerRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1ClearTriggerResponse">ClearTriggerResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Clears or cancels the trigger identified by the specified handle. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ClearTriggerResponse">ClearTriggerResponse</a> </td>
        <td><a href="#a582553240e7015f44ae86078ec533a85">clearTrigger</a> (const std::string \&triggerId, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Clears or cancels the trigger identified by the specified handle. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ClearTriggerResponse">ClearTriggerResponse</a> & </td>
        <td><a href="#adfafb6200f23ba0728ffddda95421437">clearTrigger</a> (const std::string \&triggerId, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1ClearTriggerResponse">ClearTriggerResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Clears or cancels the trigger identified by the specified handle. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CollectStatisticsResponse">CollectStatisticsResponse</a> </td>
        <td><a href="#a71a881b85611086a22694f352810dc45">collectStatistics</a> (const <a href="/content/api/cpp/structgpudb_1_1CollectStatisticsRequest">CollectStatisticsRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Collect statistics for a column(s) in a specified table. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CollectStatisticsResponse">CollectStatisticsResponse</a> & </td>
        <td><a href="#a8658d61bf4e34f6ae3b01b3fad968b35">collectStatistics</a> (const <a href="/content/api/cpp/structgpudb_1_1CollectStatisticsRequest">CollectStatisticsRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1CollectStatisticsResponse">CollectStatisticsResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Collect statistics for a column(s) in a specified table. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CollectStatisticsResponse">CollectStatisticsResponse</a> </td>
        <td><a href="#af9b91d47a757a26bd1ba21d88fed6307">collectStatistics</a> (const std::string \&tableName, const std::vector\< std::string > \&columnNames, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Collect statistics for a column(s) in a specified table. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CollectStatisticsResponse">CollectStatisticsResponse</a> & </td>
        <td><a href="#a359611cda560b55497bb44388a699f80">collectStatistics</a> (const std::string \&tableName, const std::vector\< std::string > \&columnNames, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1CollectStatisticsResponse">CollectStatisticsResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Collect statistics for a column(s) in a specified table. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CreateBackupResponse">CreateBackupResponse</a> </td>
        <td><a href="#a8b23a215e39231b2719d9eaf103e91a5">createBackup</a> (const <a href="/content/api/cpp/structgpudb_1_1CreateBackupRequest">CreateBackupRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Creates a database <a href="/content/admin/backup_restore/#database-backup">backup</a>, containing a snapshot of existing objects, at the remote file store accessible via the <a href="/content/concepts/data_sinks/">data sink</a> specified by <a href="/content/api/cpp/structgpudb_1_1CreateBackupRequest#a5e58568622ccf02370239603be22c85d">datasinkName</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CreateBackupResponse">CreateBackupResponse</a> & </td>
        <td><a href="#adee6a721e30c2f3dcb7338b33e34b6f6">createBackup</a> (const <a href="/content/api/cpp/structgpudb_1_1CreateBackupRequest">CreateBackupRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1CreateBackupResponse">CreateBackupResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Creates a database <a href="/content/admin/backup_restore/#database-backup">backup</a>, containing a snapshot of existing objects, at the remote file store accessible via the <a href="/content/concepts/data_sinks/">data sink</a> specified by <a href="/content/api/cpp/structgpudb_1_1CreateBackupRequest#a5e58568622ccf02370239603be22c85d">datasinkName</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CreateBackupResponse">CreateBackupResponse</a> </td>
        <td><a href="#a3042866fcc5ed4439c93db74ccc8e1fd">createBackup</a> (const std::string \&backupName, const std::string \&backupType, const std::map\< std::string, std::string > \&backupObjectsMap, const std::string \&datasinkName, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Creates a database <a href="/content/admin/backup_restore/#database-backup">backup</a>, containing a snapshot of existing objects, at the remote file store accessible via the <a href="/content/concepts/data_sinks/">data sink</a> specified by <span>datasinkName</span>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CreateBackupResponse">CreateBackupResponse</a> & </td>
        <td><a href="#a624eee76216dd95185333b2c4aff6803">createBackup</a> (const std::string \&backupName, const std::string \&backupType, const std::map\< std::string, std::string > \&backupObjectsMap, const std::string \&datasinkName, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1CreateBackupResponse">CreateBackupResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Creates a database <a href="/content/admin/backup_restore/#database-backup">backup</a>, containing a snapshot of existing objects, at the remote file store accessible via the <a href="/content/concepts/data_sinks/">data sink</a> specified by <span>datasinkName</span>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CreateCatalogResponse">CreateCatalogResponse</a> </td>
        <td><a href="#ac1a6c29a53988d10165a41ae5ce64658">createCatalog</a> (const <a href="/content/api/cpp/structgpudb_1_1CreateCatalogRequest">CreateCatalogRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Creates a catalog, which contains the location and connection information for a deltalake catalog that is external to the database. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CreateCatalogResponse">CreateCatalogResponse</a> & </td>
        <td><a href="#a78817925c0fe763a6bcfa967c0c4a3d8">createCatalog</a> (const <a href="/content/api/cpp/structgpudb_1_1CreateCatalogRequest">CreateCatalogRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1CreateCatalogResponse">CreateCatalogResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Creates a catalog, which contains the location and connection information for a deltalake catalog that is external to the database. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CreateCatalogResponse">CreateCatalogResponse</a> </td>
        <td><a href="#a75400b465e05223445c85418a570431a">createCatalog</a> (const std::string \&name, const std::string \&tableFormat, const std::string \&location, const std::string \&type, const std::string \&credential, const std::string \&datasource, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Creates a catalog, which contains the location and connection information for a deltalake catalog that is external to the database. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CreateCatalogResponse">CreateCatalogResponse</a> & </td>
        <td><a href="#a989ff90c51590e7793d43031ad48f7a9">createCatalog</a> (const std::string \&name, const std::string \&tableFormat, const std::string \&location, const std::string \&type, const std::string \&credential, const std::string \&datasource, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1CreateCatalogResponse">CreateCatalogResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Creates a catalog, which contains the location and connection information for a deltalake catalog that is external to the database. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CreateCredentialResponse">CreateCredentialResponse</a> </td>
        <td><a href="#a3e28b2e1d6ee457d0d127139c6369c7c">createCredential</a> (const <a href="/content/api/cpp/structgpudb_1_1CreateCredentialRequest">CreateCredentialRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Create a new <a href="/content/concepts/credentials/">credential</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CreateCredentialResponse">CreateCredentialResponse</a> & </td>
        <td><a href="#a528e40827a0c5c22e9d19379102639a8">createCredential</a> (const <a href="/content/api/cpp/structgpudb_1_1CreateCredentialRequest">CreateCredentialRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1CreateCredentialResponse">CreateCredentialResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Create a new <a href="/content/concepts/credentials/">credential</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CreateCredentialResponse">CreateCredentialResponse</a> </td>
        <td><a href="#af8b6fbc3da2a392838bb700762188a53">createCredential</a> (const std::string \&credentialName, const std::string \&type, const std::string \&identity, const std::string \&secret, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Create a new <a href="/content/concepts/credentials/">credential</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CreateCredentialResponse">CreateCredentialResponse</a> & </td>
        <td><a href="#a6f2cc71c1467245ca17951507a23e956">createCredential</a> (const std::string \&credentialName, const std::string \&type, const std::string \&identity, const std::string \&secret, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1CreateCredentialResponse">CreateCredentialResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Create a new <a href="/content/concepts/credentials/">credential</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CreateDatasinkResponse">CreateDatasinkResponse</a> </td>
        <td><a href="#ad32bfcf63c4db33db0de668a02c2ff8e">createDatasink</a> (const <a href="/content/api/cpp/structgpudb_1_1CreateDatasinkRequest">CreateDatasinkRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Creates a <a href="/content/concepts/data_sinks/">data sink</a>, which contains the destination information for a data sink that is external to the database. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CreateDatasinkResponse">CreateDatasinkResponse</a> & </td>
        <td><a href="#a1e3dded69d198f6e26d88cfd2c9a062e">createDatasink</a> (const <a href="/content/api/cpp/structgpudb_1_1CreateDatasinkRequest">CreateDatasinkRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1CreateDatasinkResponse">CreateDatasinkResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Creates a <a href="/content/concepts/data_sinks/">data sink</a>, which contains the destination information for a data sink that is external to the database. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CreateDatasinkResponse">CreateDatasinkResponse</a> </td>
        <td><a href="#a84ef0210170f53a95829d990695287f0">createDatasink</a> (const std::string \&name, const std::string \&destination, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Creates a <a href="/content/concepts/data_sinks/">data sink</a>, which contains the destination information for a data sink that is external to the database. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CreateDatasinkResponse">CreateDatasinkResponse</a> & </td>
        <td><a href="#ad472ec2d6d8b64d862531a17cc32e2b8">createDatasink</a> (const std::string \&name, const std::string \&destination, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1CreateDatasinkResponse">CreateDatasinkResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Creates a <a href="/content/concepts/data_sinks/">data sink</a>, which contains the destination information for a data sink that is external to the database. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CreateDatasourceResponse">CreateDatasourceResponse</a> </td>
        <td><a href="#aee7f93ffe53262e30f66a08cf99847e5">createDatasource</a> (const <a href="/content/api/cpp/structgpudb_1_1CreateDatasourceRequest">CreateDatasourceRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Creates a <a href="/content/concepts/data_sources/">data source</a>, which contains the location and connection information for a data store that is external to the database. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CreateDatasourceResponse">CreateDatasourceResponse</a> & </td>
        <td><a href="#a7bf5abea868db0f44e0ab9d6298da7aa">createDatasource</a> (const <a href="/content/api/cpp/structgpudb_1_1CreateDatasourceRequest">CreateDatasourceRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1CreateDatasourceResponse">CreateDatasourceResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Creates a <a href="/content/concepts/data_sources/">data source</a>, which contains the location and connection information for a data store that is external to the database. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CreateDatasourceResponse">CreateDatasourceResponse</a> </td>
        <td><a href="#abd907f6e877fc1e5bab4c9a913e54261">createDatasource</a> (const std::string \&name, const std::string \&location, const std::string \&userName, const std::string \&password, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Creates a <a href="/content/concepts/data_sources/">data source</a>, which contains the location and connection information for a data store that is external to the database. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CreateDatasourceResponse">CreateDatasourceResponse</a> & </td>
        <td><a href="#a2be406bc91fb042fccb89e77fd4f1c29">createDatasource</a> (const std::string \&name, const std::string \&location, const std::string \&userName, const std::string \&password, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1CreateDatasourceResponse">CreateDatasourceResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Creates a <a href="/content/concepts/data_sources/">data source</a>, which contains the location and connection information for a data store that is external to the database. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CreateDirectoryResponse">CreateDirectoryResponse</a> </td>
        <td><a href="#ad932eb748735980773e9f45a50aaf818">createDirectory</a> (const <a href="/content/api/cpp/structgpudb_1_1CreateDirectoryRequest">CreateDirectoryRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Creates a new directory in <a href="/content/tools/kifs/">KiFS</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CreateDirectoryResponse">CreateDirectoryResponse</a> & </td>
        <td><a href="#a9ca93f20fbe8707eeb45074103ea0041">createDirectory</a> (const <a href="/content/api/cpp/structgpudb_1_1CreateDirectoryRequest">CreateDirectoryRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1CreateDirectoryResponse">CreateDirectoryResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Creates a new directory in <a href="/content/tools/kifs/">KiFS</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CreateDirectoryResponse">CreateDirectoryResponse</a> </td>
        <td><a href="#a3251f84a1c160b981f62beee27787825">createDirectory</a> (const std::string \&directoryName, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Creates a new directory in <a href="/content/tools/kifs/">KiFS</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CreateDirectoryResponse">CreateDirectoryResponse</a> & </td>
        <td><a href="#a7b984154441271fb6003152b0033f732">createDirectory</a> (const std::string \&directoryName, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1CreateDirectoryResponse">CreateDirectoryResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Creates a new directory in <a href="/content/tools/kifs/">KiFS</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CreateEnvironmentResponse">CreateEnvironmentResponse</a> </td>
        <td><a href="#ae45e294adbb6e195ee0c90b06f8bdf93">createEnvironment</a> (const <a href="/content/api/cpp/structgpudb_1_1CreateEnvironmentRequest">CreateEnvironmentRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Creates a new environment which can be used by <a href="/content/concepts/udf/">user-defined functions</a> (UDF). <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CreateEnvironmentResponse">CreateEnvironmentResponse</a> & </td>
        <td><a href="#a721b9eb3619dbd4be1544cb964870ca8">createEnvironment</a> (const <a href="/content/api/cpp/structgpudb_1_1CreateEnvironmentRequest">CreateEnvironmentRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1CreateEnvironmentResponse">CreateEnvironmentResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Creates a new environment which can be used by <a href="/content/concepts/udf/">user-defined functions</a> (UDF). <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CreateEnvironmentResponse">CreateEnvironmentResponse</a> </td>
        <td><a href="#a406a2b93c56aa4349b0c9044fc45cc2c">createEnvironment</a> (const std::string \&environmentName, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Creates a new environment which can be used by <a href="/content/concepts/udf/">user-defined functions</a> (UDF). <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CreateEnvironmentResponse">CreateEnvironmentResponse</a> & </td>
        <td><a href="#ae802312994c203cd1daf82737d1b59eb">createEnvironment</a> (const std::string \&environmentName, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1CreateEnvironmentResponse">CreateEnvironmentResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Creates a new environment which can be used by <a href="/content/concepts/udf/">user-defined functions</a> (UDF). <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CreateGraphResponse">CreateGraphResponse</a> </td>
        <td><a href="#a4055b3b0cd047d5c78f8ab61350e1c4e">createGraph</a> (const <a href="/content/api/cpp/structgpudb_1_1CreateGraphRequest">CreateGraphRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Creates a new graph network using given nodes, edges, weights, and restrictions. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CreateGraphResponse">CreateGraphResponse</a> & </td>
        <td><a href="#a01658fbf50eee78b0680adaa40c91da1">createGraph</a> (const <a href="/content/api/cpp/structgpudb_1_1CreateGraphRequest">CreateGraphRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1CreateGraphResponse">CreateGraphResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Creates a new graph network using given nodes, edges, weights, and restrictions. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CreateGraphResponse">CreateGraphResponse</a> </td>
        <td><a href="#a025f78582e1d24c590888a3d29e19f36">createGraph</a> (const std::string \&graphName, const bool directedGraph, const std::vector\< std::string > \&nodes, const std::vector\< std::string > \&edges, const std::vector\< std::string > \&weights, const std::vector\< std::string > \&restrictions, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Creates a new graph network using given nodes, edges, weights, and restrictions. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CreateGraphResponse">CreateGraphResponse</a> & </td>
        <td><a href="#aeab804eaaec1a946d6d4a294312d8f7b">createGraph</a> (const std::string \&graphName, const bool directedGraph, const std::vector\< std::string > \&nodes, const std::vector\< std::string > \&edges, const std::vector\< std::string > \&weights, const std::vector\< std::string > \&restrictions, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1CreateGraphResponse">CreateGraphResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Creates a new graph network using given nodes, edges, weights, and restrictions. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CreateJobResponse">CreateJobResponse</a> </td>
        <td><a href="#a02ef4c58e395bbf2c83325cf592397af">createJob</a> (const <a href="/content/api/cpp/structgpudb_1_1CreateJobRequest">CreateJobRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Create a job which will run asynchronously. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CreateJobResponse">CreateJobResponse</a> & </td>
        <td><a href="#a09c09f08b2e5805ff3740daa3eaa06c1">createJob</a> (const <a href="/content/api/cpp/structgpudb_1_1CreateJobRequest">CreateJobRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1CreateJobResponse">CreateJobResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Create a job which will run asynchronously. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CreateJobResponse">CreateJobResponse</a> </td>
        <td><a href="#a2807b0831529b2f2e6fb554339670763">createJob</a> (const std::string \&endpoint, const std::string \&requestEncoding, const std::vector\< uint8\_t > \&data, const std::string \&dataStr, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Create a job which will run asynchronously. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CreateJobResponse">CreateJobResponse</a> & </td>
        <td><a href="#ab9d0718a56686729612f1b0917601983">createJob</a> (const std::string \&endpoint, const std::string \&requestEncoding, const std::vector\< uint8\_t > \&data, const std::string \&dataStr, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1CreateJobResponse">CreateJobResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Create a job which will run asynchronously. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CreateJoinTableResponse">CreateJoinTableResponse</a> </td>
        <td><a href="#a3446363f962c29930fd54ab38b8d2f24">createJoinTable</a> (const <a href="/content/api/cpp/structgpudb_1_1CreateJoinTableRequest">CreateJoinTableRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Creates a table that is the result of a SQL JOIN. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CreateJoinTableResponse">CreateJoinTableResponse</a> & </td>
        <td><a href="#afeec38b18c4d2e97b552f92ab195df27">createJoinTable</a> (const <a href="/content/api/cpp/structgpudb_1_1CreateJoinTableRequest">CreateJoinTableRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1CreateJoinTableResponse">CreateJoinTableResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Creates a table that is the result of a SQL JOIN. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CreateJoinTableResponse">CreateJoinTableResponse</a> </td>
        <td><a href="#a8c4a3b0823d2f0bd9cdd744139ee0e17">createJoinTable</a> (const std::string \&joinTableName, const std::vector\< std::string > \&tableNames, const std::vector\< std::string > \&columnNames, const std::vector\< std::string > \&expressions, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Creates a table that is the result of a SQL JOIN. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CreateJoinTableResponse">CreateJoinTableResponse</a> & </td>
        <td><a href="#a4a344735f4a950fbb09a2fb84f703569">createJoinTable</a> (const std::string \&joinTableName, const std::vector\< std::string > \&tableNames, const std::vector\< std::string > \&columnNames, const std::vector\< std::string > \&expressions, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1CreateJoinTableResponse">CreateJoinTableResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Creates a table that is the result of a SQL JOIN. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CreateMaterializedViewResponse">CreateMaterializedViewResponse</a> </td>
        <td><a href="#a494c22211d9100d2c5ca53d4f6cef62a">createMaterializedView</a> (const <a href="/content/api/cpp/structgpudb_1_1CreateMaterializedViewRequest">CreateMaterializedViewRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Initiates the process of creating a materialized view, reserving the view's name to prevent other views or tables from being created with that name. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CreateMaterializedViewResponse">CreateMaterializedViewResponse</a> & </td>
        <td><a href="#ad86909729ba25bf8a3c781bb50c954dd">createMaterializedView</a> (const <a href="/content/api/cpp/structgpudb_1_1CreateMaterializedViewRequest">CreateMaterializedViewRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1CreateMaterializedViewResponse">CreateMaterializedViewResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Initiates the process of creating a materialized view, reserving the view's name to prevent other views or tables from being created with that name. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CreateMaterializedViewResponse">CreateMaterializedViewResponse</a> </td>
        <td><a href="#a4c585a19766a2de5755448429f034b61">createMaterializedView</a> (const std::string \&tableName, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Initiates the process of creating a materialized view, reserving the view's name to prevent other views or tables from being created with that name. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CreateMaterializedViewResponse">CreateMaterializedViewResponse</a> & </td>
        <td><a href="#abfa74ba57b3f32437a9855e2ffbc93f2">createMaterializedView</a> (const std::string \&tableName, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1CreateMaterializedViewResponse">CreateMaterializedViewResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Initiates the process of creating a materialized view, reserving the view's name to prevent other views or tables from being created with that name. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CreateProcResponse">CreateProcResponse</a> </td>
        <td><a href="#aece60959dc14eef09c0a3b390ddee6ea">createProc</a> (const <a href="/content/api/cpp/structgpudb_1_1CreateProcRequest">CreateProcRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Creates an instance (proc) of the <a href="/content/concepts/udf/">user-defined functions</a> (UDF) specified by the given command, options, and files, and makes it available for execution. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CreateProcResponse">CreateProcResponse</a> & </td>
        <td><a href="#a7d1cc69f145c8d5bfe9d49defc76f52c">createProc</a> (const <a href="/content/api/cpp/structgpudb_1_1CreateProcRequest">CreateProcRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1CreateProcResponse">CreateProcResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Creates an instance (proc) of the <a href="/content/concepts/udf/">user-defined functions</a> (UDF) specified by the given command, options, and files, and makes it available for execution. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CreateProcResponse">CreateProcResponse</a> </td>
        <td><a href="#ace48ccb741aa8b5aaec6fca25b235fe0">createProc</a> (const std::string \&procName, const std::string \&executionMode, const std::map\< std::string, std::vector\< uint8\_t > > \&files, const std::string \&command, const std::vector\< std::string > \&args, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Creates an instance (proc) of the <a href="/content/concepts/udf/">user-defined functions</a> (UDF) specified by the given command, options, and files, and makes it available for execution. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CreateProcResponse">CreateProcResponse</a> & </td>
        <td><a href="#ac9fc234ac65973e64a8a832afeab6017">createProc</a> (const std::string \&procName, const std::string \&executionMode, const std::map\< std::string, std::vector\< uint8\_t > > \&files, const std::string \&command, const std::vector\< std::string > \&args, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1CreateProcResponse">CreateProcResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Creates an instance (proc) of the <a href="/content/concepts/udf/">user-defined functions</a> (UDF) specified by the given command, options, and files, and makes it available for execution. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CreateProjectionResponse">CreateProjectionResponse</a> </td>
        <td><a href="#aab22a8ee1b42ec6fa1acfc3b2f70cf4c">createProjection</a> (const <a href="/content/api/cpp/structgpudb_1_1CreateProjectionRequest">CreateProjectionRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Creates a new <a href="/content/concepts/projections/">projection</a> of an existing table. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CreateProjectionResponse">CreateProjectionResponse</a> & </td>
        <td><a href="#adcce6ef10741d33d2215bc8201dd0256">createProjection</a> (const <a href="/content/api/cpp/structgpudb_1_1CreateProjectionRequest">CreateProjectionRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1CreateProjectionResponse">CreateProjectionResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Creates a new <a href="/content/concepts/projections/">projection</a> of an existing table. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CreateProjectionResponse">CreateProjectionResponse</a> </td>
        <td><a href="#a8dd0f76ba727eed190f006f6d15d2e5b">createProjection</a> (const std::string \&tableName, const std::string \&projectionName, const std::vector\< std::string > \&columnNames, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Creates a new <a href="/content/concepts/projections/">projection</a> of an existing table. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CreateProjectionResponse">CreateProjectionResponse</a> & </td>
        <td><a href="#ab9f111bfe282c4b5f8b1b884f7b89076">createProjection</a> (const std::string \&tableName, const std::string \&projectionName, const std::vector\< std::string > \&columnNames, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1CreateProjectionResponse">CreateProjectionResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Creates a new <a href="/content/concepts/projections/">projection</a> of an existing table. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CreateResourceGroupResponse">CreateResourceGroupResponse</a> </td>
        <td><a href="#a5b9733fe84adc0498c9bf18e758c5eb0">createResourceGroup</a> (const <a href="/content/api/cpp/structgpudb_1_1CreateResourceGroupRequest">CreateResourceGroupRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Creates a new resource group to facilitate resource management. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CreateResourceGroupResponse">CreateResourceGroupResponse</a> & </td>
        <td><a href="#a3b9a0433110a7726b7574a6728108d97">createResourceGroup</a> (const <a href="/content/api/cpp/structgpudb_1_1CreateResourceGroupRequest">CreateResourceGroupRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1CreateResourceGroupResponse">CreateResourceGroupResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Creates a new resource group to facilitate resource management. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CreateResourceGroupResponse">CreateResourceGroupResponse</a> </td>
        <td><a href="#a3243021c43f5f653775767fa3a414806">createResourceGroup</a> (const std::string \&name, const std::map\< std::string, std::map\< std::string, std::string > > \&tierAttributes, const std::string \&ranking, const std::string \&adjoiningResourceGroup, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Creates a new resource group to facilitate resource management. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CreateResourceGroupResponse">CreateResourceGroupResponse</a> & </td>
        <td><a href="#a03a662f7205c9d7c01770e81b8049fa2">createResourceGroup</a> (const std::string \&name, const std::map\< std::string, std::map\< std::string, std::string > > \&tierAttributes, const std::string \&ranking, const std::string \&adjoiningResourceGroup, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1CreateResourceGroupResponse">CreateResourceGroupResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Creates a new resource group to facilitate resource management. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CreateRoleResponse">CreateRoleResponse</a> </td>
        <td><a href="#a11c8fcda3ebbb876681b3b9f20e23a3c">createRole</a> (const <a href="/content/api/cpp/structgpudb_1_1CreateRoleRequest">CreateRoleRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Creates a new role. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CreateRoleResponse">CreateRoleResponse</a> & </td>
        <td><a href="#a9ef4609997fc3c545e985ba94bcefd26">createRole</a> (const <a href="/content/api/cpp/structgpudb_1_1CreateRoleRequest">CreateRoleRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1CreateRoleResponse">CreateRoleResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Creates a new role. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CreateRoleResponse">CreateRoleResponse</a> </td>
        <td><a href="#a5c25be98b6d00d03bc94841dcc1ee348">createRole</a> (const std::string \&name, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Creates a new role. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CreateRoleResponse">CreateRoleResponse</a> & </td>
        <td><a href="#a9d6dd4b8f0c54db178d24393ba674a8e">createRole</a> (const std::string \&name, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1CreateRoleResponse">CreateRoleResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Creates a new role. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CreateSchemaResponse">CreateSchemaResponse</a> </td>
        <td><a href="#a4aa5990ebebfab30b5961654f546cfd0">createSchema</a> (const <a href="/content/api/cpp/structgpudb_1_1CreateSchemaRequest">CreateSchemaRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Creates a SQL-style <a href="/content/concepts/schemas/">schema</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CreateSchemaResponse">CreateSchemaResponse</a> & </td>
        <td><a href="#a38d46d66b880642f20a0c166aa4c2b15">createSchema</a> (const <a href="/content/api/cpp/structgpudb_1_1CreateSchemaRequest">CreateSchemaRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1CreateSchemaResponse">CreateSchemaResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Creates a SQL-style <a href="/content/concepts/schemas/">schema</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CreateSchemaResponse">CreateSchemaResponse</a> </td>
        <td><a href="#a33d9a0a8e738d14b688f9f869f9640ad">createSchema</a> (const std::string \&schemaName, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Creates a SQL-style <a href="/content/concepts/schemas/">schema</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CreateSchemaResponse">CreateSchemaResponse</a> & </td>
        <td><a href="#ae91be6d23881ea7ef324a60ca65cd529">createSchema</a> (const std::string \&schemaName, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1CreateSchemaResponse">CreateSchemaResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Creates a SQL-style <a href="/content/concepts/schemas/">schema</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CreateTableResponse">CreateTableResponse</a> </td>
        <td><a href="#a827d2d54888b00d0dcc69599325de9cf">createTable</a> (const <a href="/content/api/cpp/structgpudb_1_1CreateTableRequest">CreateTableRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Creates a new table with the given type (definition of columns). <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CreateTableResponse">CreateTableResponse</a> & </td>
        <td><a href="#aeb94f06a20fe34915cefb268e375bb64">createTable</a> (const <a href="/content/api/cpp/structgpudb_1_1CreateTableRequest">CreateTableRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1CreateTableResponse">CreateTableResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Creates a new table with the given type (definition of columns). <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CreateTableResponse">CreateTableResponse</a> </td>
        <td><a href="#afa4ded9fdb07b49b4b1cb0835b5ac52a">createTable</a> (const std::string \&tableName, const std::string \&typeId, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Creates a new table with the given type (definition of columns). <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CreateTableResponse">CreateTableResponse</a> & </td>
        <td><a href="#a98dd73575fa84c4fa69a05a89ea9a612">createTable</a> (const std::string \&tableName, const std::string \&typeId, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1CreateTableResponse">CreateTableResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Creates a new table with the given type (definition of columns). <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CreateTableExternalResponse">CreateTableExternalResponse</a> </td>
        <td><a href="#ac963efc014c345b859fc672fd61425c2">createTableExternal</a> (const <a href="/content/api/cpp/structgpudb_1_1CreateTableExternalRequest">CreateTableExternalRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Creates a new <a href="/content/concepts/external_tables/">external table</a>, which is a local database object whose source data is located externally to the database. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CreateTableExternalResponse">CreateTableExternalResponse</a> & </td>
        <td><a href="#af50aed1723c9972c56a6422439018d4c">createTableExternal</a> (const <a href="/content/api/cpp/structgpudb_1_1CreateTableExternalRequest">CreateTableExternalRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1CreateTableExternalResponse">CreateTableExternalResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Creates a new <a href="/content/concepts/external_tables/">external table</a>, which is a local database object whose source data is located externally to the database. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CreateTableExternalResponse">CreateTableExternalResponse</a> </td>
        <td><a href="#ab295ed721682bb4ed0da6ac4e79d7fc2">createTableExternal</a> (const std::string \&tableName, const std::vector\< std::string > \&filepaths, const std::map\< std::string, std::map\< std::string, std::string > > \&modifyColumns, const std::map\< std::string, std::string > \&createTableOptions, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Creates a new <a href="/content/concepts/external_tables/">external table</a>, which is a local database object whose source data is located externally to the database. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CreateTableExternalResponse">CreateTableExternalResponse</a> & </td>
        <td><a href="#aa8ac79e9d3b97f1d6e4addb282293a2f">createTableExternal</a> (const std::string \&tableName, const std::vector\< std::string > \&filepaths, const std::map\< std::string, std::map\< std::string, std::string > > \&modifyColumns, const std::map\< std::string, std::string > \&createTableOptions, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1CreateTableExternalResponse">CreateTableExternalResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Creates a new <a href="/content/concepts/external_tables/">external table</a>, which is a local database object whose source data is located externally to the database. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CreateTableMonitorResponse">CreateTableMonitorResponse</a> </td>
        <td><a href="#ab379d6656d94cb2e54be2671ecd05d6c">createTableMonitor</a> (const <a href="/content/api/cpp/structgpudb_1_1CreateTableMonitorRequest">CreateTableMonitorRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Creates a monitor that watches for a single table modification event type (insert, update, or delete) on a particular table (identified by <a href="/content/api/cpp/structgpudb_1_1CreateTableMonitorRequest#a0e8f2441270fcee8e907355690991ec4">tableName</a>) and forwards event notifications to subscribers via ZMQ. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CreateTableMonitorResponse">CreateTableMonitorResponse</a> & </td>
        <td><a href="#a0efddb12766e77b5014d575272644633">createTableMonitor</a> (const <a href="/content/api/cpp/structgpudb_1_1CreateTableMonitorRequest">CreateTableMonitorRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1CreateTableMonitorResponse">CreateTableMonitorResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Creates a monitor that watches for a single table modification event type (insert, update, or delete) on a particular table (identified by <a href="/content/api/cpp/structgpudb_1_1CreateTableMonitorRequest#a0e8f2441270fcee8e907355690991ec4">tableName</a>) and forwards event notifications to subscribers via ZMQ. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CreateTableMonitorResponse">CreateTableMonitorResponse</a> </td>
        <td><a href="#a562dc443f79f57ea572cb5ec0f2e8093">createTableMonitor</a> (const std::string \&tableName, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Creates a monitor that watches for a single table modification event type (insert, update, or delete) on a particular table (identified by <span>tableName</span>) and forwards event notifications to subscribers via ZMQ. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CreateTableMonitorResponse">CreateTableMonitorResponse</a> & </td>
        <td><a href="#a2cd20ebde22e894c8d7ccb47f4af4fb4">createTableMonitor</a> (const std::string \&tableName, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1CreateTableMonitorResponse">CreateTableMonitorResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Creates a monitor that watches for a single table modification event type (insert, update, or delete) on a particular table (identified by <span>tableName</span>) and forwards event notifications to subscribers via ZMQ. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CreateTriggerByAreaResponse">CreateTriggerByAreaResponse</a> </td>
        <td><a href="#a69d7d88cd6f9cdad1145d3ba6a4b575f">createTriggerByArea</a> (const <a href="/content/api/cpp/structgpudb_1_1CreateTriggerByAreaRequest">CreateTriggerByAreaRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Sets up an area trigger mechanism for two column\_names for one or more tables. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CreateTriggerByAreaResponse">CreateTriggerByAreaResponse</a> & </td>
        <td><a href="#a357880c27d0836142fb17b2369720716">createTriggerByArea</a> (const <a href="/content/api/cpp/structgpudb_1_1CreateTriggerByAreaRequest">CreateTriggerByAreaRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1CreateTriggerByAreaResponse">CreateTriggerByAreaResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Sets up an area trigger mechanism for two column\_names for one or more tables. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CreateTriggerByAreaResponse">CreateTriggerByAreaResponse</a> </td>
        <td><a href="#a3d85ea830f5909e01b6888e53167bbc7">createTriggerByArea</a> (const std::string \&requestId, const std::vector\< std::string > \&tableNames, const std::string \&xColumnName, const std::vector\< double > \&xVector, const std::string \&yColumnName, const std::vector\< double > \&yVector, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Sets up an area trigger mechanism for two column\_names for one or more tables. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CreateTriggerByAreaResponse">CreateTriggerByAreaResponse</a> & </td>
        <td><a href="#a31add72aae86cd249dfdd622c161bb37">createTriggerByArea</a> (const std::string \&requestId, const std::vector\< std::string > \&tableNames, const std::string \&xColumnName, const std::vector\< double > \&xVector, const std::string \&yColumnName, const std::vector\< double > \&yVector, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1CreateTriggerByAreaResponse">CreateTriggerByAreaResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Sets up an area trigger mechanism for two column\_names for one or more tables. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CreateTriggerByRangeResponse">CreateTriggerByRangeResponse</a> </td>
        <td><a href="#aa77f37d9c9d2aa51450c6831584aa942">createTriggerByRange</a> (const <a href="/content/api/cpp/structgpudb_1_1CreateTriggerByRangeRequest">CreateTriggerByRangeRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Sets up a simple range trigger for a column\_name for one or more tables. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CreateTriggerByRangeResponse">CreateTriggerByRangeResponse</a> & </td>
        <td><a href="#a48e03f5bf1ad6d725a68f9f8d172b5d5">createTriggerByRange</a> (const <a href="/content/api/cpp/structgpudb_1_1CreateTriggerByRangeRequest">CreateTriggerByRangeRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1CreateTriggerByRangeResponse">CreateTriggerByRangeResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Sets up a simple range trigger for a column\_name for one or more tables. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CreateTriggerByRangeResponse">CreateTriggerByRangeResponse</a> </td>
        <td><a href="#aa331f41ea50603fee702f9606cffebb4">createTriggerByRange</a> (const std::string \&requestId, const std::vector\< std::string > \&tableNames, const std::string \&columnName, const double min, const double max, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Sets up a simple range trigger for a column\_name for one or more tables. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CreateTriggerByRangeResponse">CreateTriggerByRangeResponse</a> & </td>
        <td><a href="#a2b7b40a138abfaf1072e3c009cb8869a">createTriggerByRange</a> (const std::string \&requestId, const std::vector\< std::string > \&tableNames, const std::string \&columnName, const double min, const double max, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1CreateTriggerByRangeResponse">CreateTriggerByRangeResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Sets up a simple range trigger for a column\_name for one or more tables. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CreateTypeResponse">CreateTypeResponse</a> </td>
        <td><a href="#abaf7eca0d3c131b8fede4850d51f1a1a">createType</a> (const <a href="/content/api/cpp/structgpudb_1_1CreateTypeRequest">CreateTypeRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Creates a new type describing the columns of a table. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CreateTypeResponse">CreateTypeResponse</a> & </td>
        <td><a href="#ae8b6df8ac9858f30d8bc46c35010af18">createType</a> (const <a href="/content/api/cpp/structgpudb_1_1CreateTypeRequest">CreateTypeRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1CreateTypeResponse">CreateTypeResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Creates a new type describing the columns of a table. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CreateTypeResponse">CreateTypeResponse</a> </td>
        <td><a href="#a1698840c08d7212878c9c1dac3f94cfc">createType</a> (const std::string \&typeDefinition, const std::string \&label, const std::map\< std::string, std::vector\< std::string > > \&properties, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Creates a new type describing the columns of a table. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CreateTypeResponse">CreateTypeResponse</a> & </td>
        <td><a href="#a5d88689120cf75e0c9f90d58d260926b">createType</a> (const std::string \&typeDefinition, const std::string \&label, const std::map\< std::string, std::vector\< std::string > > \&properties, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1CreateTypeResponse">CreateTypeResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Creates a new type describing the columns of a table. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CreateUnionResponse">CreateUnionResponse</a> </td>
        <td><a href="#af715d41bccfba570e4e335da030f8576">createUnion</a> (const <a href="/content/api/cpp/structgpudb_1_1CreateUnionRequest">CreateUnionRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Merges data from one or more tables with comparable data types into a new table. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CreateUnionResponse">CreateUnionResponse</a> & </td>
        <td><a href="#ab65629316eb66dee1c6b8998423c46e6">createUnion</a> (const <a href="/content/api/cpp/structgpudb_1_1CreateUnionRequest">CreateUnionRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1CreateUnionResponse">CreateUnionResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Merges data from one or more tables with comparable data types into a new table. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CreateUnionResponse">CreateUnionResponse</a> </td>
        <td><a href="#ad46a1ca661db2c102c37940364563143">createUnion</a> (const std::string \&tableName, const std::vector\< std::string > \&tableNames, const std::vector\< std::vector\< std::string > > \&inputColumnNames, const std::vector\< std::string > \&outputColumnNames, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Merges data from one or more tables with comparable data types into a new table. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CreateUnionResponse">CreateUnionResponse</a> & </td>
        <td><a href="#a77e0ada501f72a9c0bde63922fdcf77d">createUnion</a> (const std::string \&tableName, const std::vector\< std::string > \&tableNames, const std::vector\< std::vector\< std::string > > \&inputColumnNames, const std::vector\< std::string > \&outputColumnNames, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1CreateUnionResponse">CreateUnionResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Merges data from one or more tables with comparable data types into a new table. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CreateUserExternalResponse">CreateUserExternalResponse</a> </td>
        <td><a href="#a0b63a9b008db5b7c78b098877286af3c">createUserExternal</a> (const <a href="/content/api/cpp/structgpudb_1_1CreateUserExternalRequest">CreateUserExternalRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Creates a new external user (a user whose credentials are managed by an external LDAP). <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CreateUserExternalResponse">CreateUserExternalResponse</a> & </td>
        <td><a href="#a536d649e7acb6a0e2c0a138c8c8d7dda">createUserExternal</a> (const <a href="/content/api/cpp/structgpudb_1_1CreateUserExternalRequest">CreateUserExternalRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1CreateUserExternalResponse">CreateUserExternalResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Creates a new external user (a user whose credentials are managed by an external LDAP). <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CreateUserExternalResponse">CreateUserExternalResponse</a> </td>
        <td><a href="#abf75994b026f56c55ebc0abef27b0227">createUserExternal</a> (const std::string \&name, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Creates a new external user (a user whose credentials are managed by an external LDAP). <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CreateUserExternalResponse">CreateUserExternalResponse</a> & </td>
        <td><a href="#abbcbb0ef0e7787d413ae18f5e9f3cfd7">createUserExternal</a> (const std::string \&name, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1CreateUserExternalResponse">CreateUserExternalResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Creates a new external user (a user whose credentials are managed by an external LDAP). <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CreateUserInternalResponse">CreateUserInternalResponse</a> </td>
        <td><a href="#a00da63ad9e89859132ae0b44226d9015">createUserInternal</a> (const <a href="/content/api/cpp/structgpudb_1_1CreateUserInternalRequest">CreateUserInternalRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Creates a new internal user (a user whose credentials are managed by the database system). <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CreateUserInternalResponse">CreateUserInternalResponse</a> & </td>
        <td><a href="#adefdfd170305aab9d2c49023c4122f46">createUserInternal</a> (const <a href="/content/api/cpp/structgpudb_1_1CreateUserInternalRequest">CreateUserInternalRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1CreateUserInternalResponse">CreateUserInternalResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Creates a new internal user (a user whose credentials are managed by the database system). <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CreateUserInternalResponse">CreateUserInternalResponse</a> </td>
        <td><a href="#afac3f442800a21affe448aac71d6c10b">createUserInternal</a> (const std::string \&name, const std::string \&password, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Creates a new internal user (a user whose credentials are managed by the database system). <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CreateUserInternalResponse">CreateUserInternalResponse</a> & </td>
        <td><a href="#ae94b0a8211f45f2a1be1c00a6c226cbf">createUserInternal</a> (const std::string \&name, const std::string \&password, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1CreateUserInternalResponse">CreateUserInternalResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Creates a new internal user (a user whose credentials are managed by the database system). <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CreateVideoResponse">CreateVideoResponse</a> </td>
        <td><a href="#ae81d077f831f4e98c69ea0a58be83c32">createVideo</a> (const <a href="/content/api/cpp/structgpudb_1_1CreateVideoRequest">CreateVideoRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Creates a job to generate a sequence of raster images that visualize data over a specified time. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CreateVideoResponse">CreateVideoResponse</a> & </td>
        <td><a href="#ab496488e5c4fe83f0974f79c0f222fe8">createVideo</a> (const <a href="/content/api/cpp/structgpudb_1_1CreateVideoRequest">CreateVideoRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1CreateVideoResponse">CreateVideoResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Creates a job to generate a sequence of raster images that visualize data over a specified time. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CreateVideoResponse">CreateVideoResponse</a> </td>
        <td><a href="#af14dc5b767384075f16aa02a1ede6f0d">createVideo</a> (const std::string \&attribute, const std::string \&begin, const double durationSeconds, const std::string \&end, const double framesPerSecond, const std::string \&style, const std::string \&path, const std::string \&styleParameters, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Creates a job to generate a sequence of raster images that visualize data over a specified time. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1CreateVideoResponse">CreateVideoResponse</a> & </td>
        <td><a href="#a7fdf6087dc9b6b89564696f7e7a2a8b0">createVideo</a> (const std::string \&attribute, const std::string \&begin, const double durationSeconds, const std::string \&end, const double framesPerSecond, const std::string \&style, const std::string \&path, const std::string \&styleParameters, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1CreateVideoResponse">CreateVideoResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Creates a job to generate a sequence of raster images that visualize data over a specified time. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1DeleteDirectoryResponse">DeleteDirectoryResponse</a> </td>
        <td><a href="#afe45987d438414b862ff310e0232e83e">deleteDirectory</a> (const <a href="/content/api/cpp/structgpudb_1_1DeleteDirectoryRequest">DeleteDirectoryRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Deletes a directory from <a href="/content/tools/kifs/">KiFS</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1DeleteDirectoryResponse">DeleteDirectoryResponse</a> & </td>
        <td><a href="#ad4386f3a6f03bc6a845ea8296303d10a">deleteDirectory</a> (const <a href="/content/api/cpp/structgpudb_1_1DeleteDirectoryRequest">DeleteDirectoryRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1DeleteDirectoryResponse">DeleteDirectoryResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Deletes a directory from <a href="/content/tools/kifs/">KiFS</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1DeleteDirectoryResponse">DeleteDirectoryResponse</a> </td>
        <td><a href="#a95029975ac7617f02a217e6a1303a743">deleteDirectory</a> (const std::string \&directoryName, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Deletes a directory from <a href="/content/tools/kifs/">KiFS</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1DeleteDirectoryResponse">DeleteDirectoryResponse</a> & </td>
        <td><a href="#a8f2c1ddfb5625eedbee937a15e8041af">deleteDirectory</a> (const std::string \&directoryName, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1DeleteDirectoryResponse">DeleteDirectoryResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Deletes a directory from <a href="/content/tools/kifs/">KiFS</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1DeleteFilesResponse">DeleteFilesResponse</a> </td>
        <td><a href="#a75e4fd348dc250cbb2a1c21fb893ec4f">deleteFiles</a> (const <a href="/content/api/cpp/structgpudb_1_1DeleteFilesRequest">DeleteFilesRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Deletes one or more files from <a href="/content/tools/kifs/">KiFS</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1DeleteFilesResponse">DeleteFilesResponse</a> & </td>
        <td><a href="#ae3198839ed8dfbd5be8a9177fca50925">deleteFiles</a> (const <a href="/content/api/cpp/structgpudb_1_1DeleteFilesRequest">DeleteFilesRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1DeleteFilesResponse">DeleteFilesResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Deletes one or more files from <a href="/content/tools/kifs/">KiFS</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1DeleteFilesResponse">DeleteFilesResponse</a> </td>
        <td><a href="#afb117f49f083747753d3f0c8c0f3c09c">deleteFiles</a> (const std::vector\< std::string > \&fileNames, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Deletes one or more files from <a href="/content/tools/kifs/">KiFS</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1DeleteFilesResponse">DeleteFilesResponse</a> & </td>
        <td><a href="#a1599c4b1573a494c833d7c683f3b68ed">deleteFiles</a> (const std::vector\< std::string > \&fileNames, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1DeleteFilesResponse">DeleteFilesResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Deletes one or more files from <a href="/content/tools/kifs/">KiFS</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1DeleteGraphResponse">DeleteGraphResponse</a> </td>
        <td><a href="#a856b5855b4b4179036949947353ffa11">deleteGraph</a> (const <a href="/content/api/cpp/structgpudb_1_1DeleteGraphRequest">DeleteGraphRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Deletes an existing graph from the graph server and/or persist. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1DeleteGraphResponse">DeleteGraphResponse</a> & </td>
        <td><a href="#a7c348316ef92aa6211508d943e40453a">deleteGraph</a> (const <a href="/content/api/cpp/structgpudb_1_1DeleteGraphRequest">DeleteGraphRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1DeleteGraphResponse">DeleteGraphResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Deletes an existing graph from the graph server and/or persist. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1DeleteGraphResponse">DeleteGraphResponse</a> </td>
        <td><a href="#aaa544a93e287b733c600682cbf3dfb4b">deleteGraph</a> (const std::string \&graphName, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Deletes an existing graph from the graph server and/or persist. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1DeleteGraphResponse">DeleteGraphResponse</a> & </td>
        <td><a href="#a6b0dd83e8aec362c8812868088ca4ce1">deleteGraph</a> (const std::string \&graphName, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1DeleteGraphResponse">DeleteGraphResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Deletes an existing graph from the graph server and/or persist. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1DeleteProcResponse">DeleteProcResponse</a> </td>
        <td><a href="#a031d477fc8efd8fff4c0dbddec79a061">deleteProc</a> (const <a href="/content/api/cpp/structgpudb_1_1DeleteProcRequest">DeleteProcRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Deletes a proc. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1DeleteProcResponse">DeleteProcResponse</a> & </td>
        <td><a href="#aa1eadd0fc6cd3e3a57cece7d4bccec2b">deleteProc</a> (const <a href="/content/api/cpp/structgpudb_1_1DeleteProcRequest">DeleteProcRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1DeleteProcResponse">DeleteProcResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Deletes a proc. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1DeleteProcResponse">DeleteProcResponse</a> </td>
        <td><a href="#adcbac7a4a4f00e9d259bfd223cbe0965">deleteProc</a> (const std::string \&procName, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Deletes a proc. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1DeleteProcResponse">DeleteProcResponse</a> & </td>
        <td><a href="#abacf44b2b918a5701dc13b321ea2aaeb">deleteProc</a> (const std::string \&procName, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1DeleteProcResponse">DeleteProcResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Deletes a proc. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1DeleteRecordsResponse">DeleteRecordsResponse</a> </td>
        <td><a href="#a737a76b0c9fdd8d091dc6d02e9fcac78">deleteRecords</a> (const <a href="/content/api/cpp/structgpudb_1_1DeleteRecordsRequest">DeleteRecordsRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Deletes record(s) matching the provided criteria from the given table. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1DeleteRecordsResponse">DeleteRecordsResponse</a> & </td>
        <td><a href="#af182254f80a9af09535b294c1ec135bb">deleteRecords</a> (const <a href="/content/api/cpp/structgpudb_1_1DeleteRecordsRequest">DeleteRecordsRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1DeleteRecordsResponse">DeleteRecordsResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Deletes record(s) matching the provided criteria from the given table. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1DeleteRecordsResponse">DeleteRecordsResponse</a> </td>
        <td><a href="#a8f916f1513778ef51cfb294659f452ae">deleteRecords</a> (const std::string \&tableName, const std::vector\< std::string > \&expressions, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Deletes record(s) matching the provided criteria from the given table. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1DeleteRecordsResponse">DeleteRecordsResponse</a> & </td>
        <td><a href="#a1ce474514d4e6ad6396ee5611d5dfebd">deleteRecords</a> (const std::string \&tableName, const std::vector\< std::string > \&expressions, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1DeleteRecordsResponse">DeleteRecordsResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Deletes record(s) matching the provided criteria from the given table. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1DeleteResourceGroupResponse">DeleteResourceGroupResponse</a> </td>
        <td><a href="#a983a125a43a75d06297c7267db1fd39f">deleteResourceGroup</a> (const <a href="/content/api/cpp/structgpudb_1_1DeleteResourceGroupRequest">DeleteResourceGroupRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Deletes a resource group. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1DeleteResourceGroupResponse">DeleteResourceGroupResponse</a> & </td>
        <td><a href="#a220b0089ccf5bcec01b61474e9b191eb">deleteResourceGroup</a> (const <a href="/content/api/cpp/structgpudb_1_1DeleteResourceGroupRequest">DeleteResourceGroupRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1DeleteResourceGroupResponse">DeleteResourceGroupResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Deletes a resource group. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1DeleteResourceGroupResponse">DeleteResourceGroupResponse</a> </td>
        <td><a href="#aef9d2564d591dcd37d7aa12868ecf89a">deleteResourceGroup</a> (const std::string \&name, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Deletes a resource group. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1DeleteResourceGroupResponse">DeleteResourceGroupResponse</a> & </td>
        <td><a href="#afd36b5f318b6399040e89654dee50a9e">deleteResourceGroup</a> (const std::string \&name, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1DeleteResourceGroupResponse">DeleteResourceGroupResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Deletes a resource group. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1DeleteRoleResponse">DeleteRoleResponse</a> </td>
        <td><a href="#acb8c8e4ff462c0b9cc0e75bc362cf394">deleteRole</a> (const <a href="/content/api/cpp/structgpudb_1_1DeleteRoleRequest">DeleteRoleRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Deletes an existing role. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1DeleteRoleResponse">DeleteRoleResponse</a> & </td>
        <td><a href="#a3e39bf2702fb01b28029959a06a1b18f">deleteRole</a> (const <a href="/content/api/cpp/structgpudb_1_1DeleteRoleRequest">DeleteRoleRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1DeleteRoleResponse">DeleteRoleResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Deletes an existing role. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1DeleteRoleResponse">DeleteRoleResponse</a> </td>
        <td><a href="#a5c85e8fd1f97fc0d9a2f720665eea844">deleteRole</a> (const std::string \&name, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Deletes an existing role. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1DeleteRoleResponse">DeleteRoleResponse</a> & </td>
        <td><a href="#a45c82198eabb33621afe2cb4b13b514b">deleteRole</a> (const std::string \&name, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1DeleteRoleResponse">DeleteRoleResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Deletes an existing role. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1DeleteUserResponse">DeleteUserResponse</a> </td>
        <td><a href="#a977b2b3d77af5d89bede6fdfae47d65c">deleteUser</a> (const <a href="/content/api/cpp/structgpudb_1_1DeleteUserRequest">DeleteUserRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Deletes an existing user. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1DeleteUserResponse">DeleteUserResponse</a> & </td>
        <td><a href="#a27f5c15ec81e270fdcd98cd96935562a">deleteUser</a> (const <a href="/content/api/cpp/structgpudb_1_1DeleteUserRequest">DeleteUserRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1DeleteUserResponse">DeleteUserResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Deletes an existing user. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1DeleteUserResponse">DeleteUserResponse</a> </td>
        <td><a href="#a28aafe4501af2b2641a3b902e3bcec31">deleteUser</a> (const std::string \&name, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Deletes an existing user. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1DeleteUserResponse">DeleteUserResponse</a> & </td>
        <td><a href="#a1ff04dbda4bae58ffb43ef23643c5d45">deleteUser</a> (const std::string \&name, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1DeleteUserResponse">DeleteUserResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Deletes an existing user. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1DownloadFilesResponse">DownloadFilesResponse</a> </td>
        <td><a href="#a862c8a95bf7cf33f3b26e9237a57e139">downloadFiles</a> (const <a href="/content/api/cpp/structgpudb_1_1DownloadFilesRequest">DownloadFilesRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Downloads one or more files from <a href="/content/tools/kifs/">KiFS</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1DownloadFilesResponse">DownloadFilesResponse</a> & </td>
        <td><a href="#a050ab03f2c3744e30373d501b6be605a">downloadFiles</a> (const <a href="/content/api/cpp/structgpudb_1_1DownloadFilesRequest">DownloadFilesRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1DownloadFilesResponse">DownloadFilesResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Downloads one or more files from <a href="/content/tools/kifs/">KiFS</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1DownloadFilesResponse">DownloadFilesResponse</a> </td>
        <td><a href="#a9ca866bcfa55789da0ae6cacd9c38fa9">downloadFiles</a> (const std::vector\< std::string > \&fileNames, const std::vector\< int64\_t > \&readOffsets, const std::vector\< int64\_t > \&readLengths, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Downloads one or more files from <a href="/content/tools/kifs/">KiFS</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1DownloadFilesResponse">DownloadFilesResponse</a> & </td>
        <td><a href="#a12761bd43c23e964d5e5b1b2b2b4c529">downloadFiles</a> (const std::vector\< std::string > \&fileNames, const std::vector\< int64\_t > \&readOffsets, const std::vector\< int64\_t > \&readLengths, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1DownloadFilesResponse">DownloadFilesResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Downloads one or more files from <a href="/content/tools/kifs/">KiFS</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1DropBackupResponse">DropBackupResponse</a> </td>
        <td><a href="#aa6f1b56740a5cc4a68fb18396971e2cb">dropBackup</a> (const <a href="/content/api/cpp/structgpudb_1_1DropBackupRequest">DropBackupRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Deletes one or more existing database <a href="/content/admin/backup_restore/#database-backup">backups</a> and contained snapshots, accessible via the <a href="/content/concepts/data_sinks/">data sink</a> specified by <a href="/content/api/cpp/structgpudb_1_1DropBackupRequest#a4b5c92fb561b0e6d2a480f95cf678a6f">datasinkName</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1DropBackupResponse">DropBackupResponse</a> & </td>
        <td><a href="#ade81d264162c890bc255e79fa367a368">dropBackup</a> (const <a href="/content/api/cpp/structgpudb_1_1DropBackupRequest">DropBackupRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1DropBackupResponse">DropBackupResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Deletes one or more existing database <a href="/content/admin/backup_restore/#database-backup">backups</a> and contained snapshots, accessible via the <a href="/content/concepts/data_sinks/">data sink</a> specified by <a href="/content/api/cpp/structgpudb_1_1DropBackupRequest#a4b5c92fb561b0e6d2a480f95cf678a6f">datasinkName</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1DropBackupResponse">DropBackupResponse</a> </td>
        <td><a href="#abedce955754617f8bded614fe8ac3af9">dropBackup</a> (const std::string \&backupName, const std::string \&datasinkName, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Deletes one or more existing database <a href="/content/admin/backup_restore/#database-backup">backups</a> and contained snapshots, accessible via the <a href="/content/concepts/data_sinks/">data sink</a> specified by <span>datasinkName</span>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1DropBackupResponse">DropBackupResponse</a> & </td>
        <td><a href="#a5a27fbd8c029c24986496744913025d4">dropBackup</a> (const std::string \&backupName, const std::string \&datasinkName, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1DropBackupResponse">DropBackupResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Deletes one or more existing database <a href="/content/admin/backup_restore/#database-backup">backups</a> and contained snapshots, accessible via the <a href="/content/concepts/data_sinks/">data sink</a> specified by <span>datasinkName</span>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1DropCatalogResponse">DropCatalogResponse</a> </td>
        <td><a href="#a5938a9ec650a73ebb60a1112d6b2f1ad">dropCatalog</a> (const <a href="/content/api/cpp/structgpudb_1_1DropCatalogRequest">DropCatalogRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Drops an existing catalog. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1DropCatalogResponse">DropCatalogResponse</a> & </td>
        <td><a href="#ac26622d4790f14ee7470f092f4d8872c">dropCatalog</a> (const <a href="/content/api/cpp/structgpudb_1_1DropCatalogRequest">DropCatalogRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1DropCatalogResponse">DropCatalogResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Drops an existing catalog. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1DropCatalogResponse">DropCatalogResponse</a> </td>
        <td><a href="#a6f12b30ee6107d9ec3827b365651e003">dropCatalog</a> (const std::string \&name, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Drops an existing catalog. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1DropCatalogResponse">DropCatalogResponse</a> & </td>
        <td><a href="#a414d23ccc2112bc4deca4ae5d5810e8f">dropCatalog</a> (const std::string \&name, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1DropCatalogResponse">DropCatalogResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Drops an existing catalog. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1DropCredentialResponse">DropCredentialResponse</a> </td>
        <td><a href="#a556dd0d37ed777617e2817d296e1d642">dropCredential</a> (const <a href="/content/api/cpp/structgpudb_1_1DropCredentialRequest">DropCredentialRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Drop an existing <a href="/content/concepts/credentials/">credential</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1DropCredentialResponse">DropCredentialResponse</a> & </td>
        <td><a href="#aa9b333fad3f81ec65ddb772a5a512b25">dropCredential</a> (const <a href="/content/api/cpp/structgpudb_1_1DropCredentialRequest">DropCredentialRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1DropCredentialResponse">DropCredentialResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Drop an existing <a href="/content/concepts/credentials/">credential</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1DropCredentialResponse">DropCredentialResponse</a> </td>
        <td><a href="#a790500800a3b7f0e2e0504b9a1fbf99f">dropCredential</a> (const std::string \&credentialName, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Drop an existing <a href="/content/concepts/credentials/">credential</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1DropCredentialResponse">DropCredentialResponse</a> & </td>
        <td><a href="#aebd9322f7ec6a2873592ced8b23b934b">dropCredential</a> (const std::string \&credentialName, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1DropCredentialResponse">DropCredentialResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Drop an existing <a href="/content/concepts/credentials/">credential</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1DropDatasinkResponse">DropDatasinkResponse</a> </td>
        <td><a href="#ad3e43fa7e239c990fa449b0ad0e93d0e">dropDatasink</a> (const <a href="/content/api/cpp/structgpudb_1_1DropDatasinkRequest">DropDatasinkRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Drops an existing <a href="/content/concepts/data_sinks/">data sink</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1DropDatasinkResponse">DropDatasinkResponse</a> & </td>
        <td><a href="#a5d3a3cafd0ff809135fcd05bb8d9db3d">dropDatasink</a> (const <a href="/content/api/cpp/structgpudb_1_1DropDatasinkRequest">DropDatasinkRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1DropDatasinkResponse">DropDatasinkResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Drops an existing <a href="/content/concepts/data_sinks/">data sink</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1DropDatasinkResponse">DropDatasinkResponse</a> </td>
        <td><a href="#a7b33b61ed8cc32ae56f5e5009676c72a">dropDatasink</a> (const std::string \&name, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Drops an existing <a href="/content/concepts/data_sinks/">data sink</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1DropDatasinkResponse">DropDatasinkResponse</a> & </td>
        <td><a href="#a81c7c92ff33688011d71a74610bfb4c0">dropDatasink</a> (const std::string \&name, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1DropDatasinkResponse">DropDatasinkResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Drops an existing <a href="/content/concepts/data_sinks/">data sink</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1DropDatasourceResponse">DropDatasourceResponse</a> </td>
        <td><a href="#a70b16df3e8913595a9f93f37f1e3e27d">dropDatasource</a> (const <a href="/content/api/cpp/structgpudb_1_1DropDatasourceRequest">DropDatasourceRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Drops an existing <a href="/content/concepts/data_sources/">data source</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1DropDatasourceResponse">DropDatasourceResponse</a> & </td>
        <td><a href="#a73d6e07455d28d4d8b50713fbe9978d4">dropDatasource</a> (const <a href="/content/api/cpp/structgpudb_1_1DropDatasourceRequest">DropDatasourceRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1DropDatasourceResponse">DropDatasourceResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Drops an existing <a href="/content/concepts/data_sources/">data source</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1DropDatasourceResponse">DropDatasourceResponse</a> </td>
        <td><a href="#a7050dd9f8036e7f2e3f1adb7d7a933e6">dropDatasource</a> (const std::string \&name, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Drops an existing <a href="/content/concepts/data_sources/">data source</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1DropDatasourceResponse">DropDatasourceResponse</a> & </td>
        <td><a href="#acf576751dde2dc4e5109f8cc856a57e0">dropDatasource</a> (const std::string \&name, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1DropDatasourceResponse">DropDatasourceResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Drops an existing <a href="/content/concepts/data_sources/">data source</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1DropEnvironmentResponse">DropEnvironmentResponse</a> </td>
        <td><a href="#a14b76ff4dd5ab041e2ccbda35bf3b023">dropEnvironment</a> (const <a href="/content/api/cpp/structgpudb_1_1DropEnvironmentRequest">DropEnvironmentRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Drop an existing <a href="/content/concepts/udf/">user-defined function</a> (UDF) environment. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1DropEnvironmentResponse">DropEnvironmentResponse</a> & </td>
        <td><a href="#a0f80c4f0b898b5927f320959936a4c8a">dropEnvironment</a> (const <a href="/content/api/cpp/structgpudb_1_1DropEnvironmentRequest">DropEnvironmentRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1DropEnvironmentResponse">DropEnvironmentResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Drop an existing <a href="/content/concepts/udf/">user-defined function</a> (UDF) environment. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1DropEnvironmentResponse">DropEnvironmentResponse</a> </td>
        <td><a href="#a4f26b8f86f7ff4ca39a09c24fe641aa2">dropEnvironment</a> (const std::string \&environmentName, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Drop an existing <a href="/content/concepts/udf/">user-defined function</a> (UDF) environment. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1DropEnvironmentResponse">DropEnvironmentResponse</a> & </td>
        <td><a href="#ae8f2547ef7a85f8c361af0c5356a487a">dropEnvironment</a> (const std::string \&environmentName, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1DropEnvironmentResponse">DropEnvironmentResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Drop an existing <a href="/content/concepts/udf/">user-defined function</a> (UDF) environment. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1DropSchemaResponse">DropSchemaResponse</a> </td>
        <td><a href="#ac647bfdc553a47cc69938b7b174dc499">dropSchema</a> (const <a href="/content/api/cpp/structgpudb_1_1DropSchemaRequest">DropSchemaRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Drops an existing SQL-style <a href="/content/concepts/schemas/">schema</a>, specified in <a href="/content/api/cpp/structgpudb_1_1DropSchemaRequest#a4ef1f491b078fbb00d81ac38593cb57d">schemaName</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1DropSchemaResponse">DropSchemaResponse</a> & </td>
        <td><a href="#a87cbc225b0173798cdbc758079902d98">dropSchema</a> (const <a href="/content/api/cpp/structgpudb_1_1DropSchemaRequest">DropSchemaRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1DropSchemaResponse">DropSchemaResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Drops an existing SQL-style <a href="/content/concepts/schemas/">schema</a>, specified in <a href="/content/api/cpp/structgpudb_1_1DropSchemaRequest#a4ef1f491b078fbb00d81ac38593cb57d">schemaName</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1DropSchemaResponse">DropSchemaResponse</a> </td>
        <td><a href="#a7e22b839836772439bc1acb7215ce084">dropSchema</a> (const std::string \&schemaName, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Drops an existing SQL-style <a href="/content/concepts/schemas/">schema</a>, specified in <span>schemaName</span>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1DropSchemaResponse">DropSchemaResponse</a> & </td>
        <td><a href="#aa3247798804eafcb3954e99f32a2b706">dropSchema</a> (const std::string \&schemaName, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1DropSchemaResponse">DropSchemaResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Drops an existing SQL-style <a href="/content/concepts/schemas/">schema</a>, specified in <span>schemaName</span>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ExecuteProcResponse">ExecuteProcResponse</a> </td>
        <td><a href="#aec2cf18c6185bf22d4fa351019b9924e">executeProc</a> (const <a href="/content/api/cpp/structgpudb_1_1ExecuteProcRequest">ExecuteProcRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Executes a proc. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ExecuteProcResponse">ExecuteProcResponse</a> & </td>
        <td><a href="#a2a61a65eada999d993bcb1bae69656ee">executeProc</a> (const <a href="/content/api/cpp/structgpudb_1_1ExecuteProcRequest">ExecuteProcRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1ExecuteProcResponse">ExecuteProcResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Executes a proc. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ExecuteProcResponse">ExecuteProcResponse</a> </td>
        <td><a href="#a19f569cb61a53022021bbfd9e031468d">executeProc</a> (const std::string \&procName, const std::map\< std::string, std::string > \&params, const std::map\< std::string, std::vector\< uint8\_t > > \&binParams, const std::vector\< std::string > \&inputTableNames, const std::map\< std::string, std::vector\< std::string > > \&inputColumnNames, const std::vector\< std::string > \&outputTableNames, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Executes a proc. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ExecuteProcResponse">ExecuteProcResponse</a> & </td>
        <td><a href="#a6755a1b383ff5e0fbfb163365bcfa7bc">executeProc</a> (const std::string \&procName, const std::map\< std::string, std::string > \&params, const std::map\< std::string, std::vector\< uint8\_t > > \&binParams, const std::vector\< std::string > \&inputTableNames, const std::map\< std::string, std::vector\< std::string > > \&inputColumnNames, const std::vector\< std::string > \&outputTableNames, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1ExecuteProcResponse">ExecuteProcResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Executes a proc. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1RawExecuteSqlResponse">RawExecuteSqlResponse</a> </td>
        <td><a href="#a0467a00f7a623da381265796b580e7ce">executeSqlRaw</a> (const <a href="/content/api/cpp/structgpudb_1_1ExecuteSqlRequest">ExecuteSqlRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Execute a SQL statement (query, DML, or DDL). <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1RawExecuteSqlResponse">RawExecuteSqlResponse</a> & </td>
        <td><a href="#a0b1e04620afea4b5b3b0ce3eea517a55">executeSqlRaw</a> (const <a href="/content/api/cpp/structgpudb_1_1ExecuteSqlRequest">ExecuteSqlRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1RawExecuteSqlResponse">RawExecuteSqlResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Execute a SQL statement (query, DML, or DDL). <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ExecuteSqlResponse">ExecuteSqlResponse</a> </td>
        <td><a href="#a6b771232d18e050420781df48d656cf1">executeSql</a> (const <a href="/content/api/cpp/structgpudb_1_1ExecuteSqlRequest">ExecuteSqlRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Execute a SQL statement (query, DML, or DDL). <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ExecuteSqlResponse">ExecuteSqlResponse</a> & </td>
        <td><a href="#a45e5aeffa656d78105e9138e03fac841">executeSql</a> (const <a href="/content/api/cpp/structgpudb_1_1ExecuteSqlRequest">ExecuteSqlRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1ExecuteSqlResponse">ExecuteSqlResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Execute a SQL statement (query, DML, or DDL). <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ExecuteSqlResponse">ExecuteSqlResponse</a> </td>
        <td><a href="#a3aa7bd7abb665f7371b9a23f587c6134">executeSql</a> (const std::string \&statement, const int64\_t offset, const int64\_t limit, const std::string \&requestSchemaStr, const std::vector\< std::vector\< uint8\_t > > \&data, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Execute a SQL statement (query, DML, or DDL). <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ExecuteSqlResponse">ExecuteSqlResponse</a> & </td>
        <td><a href="#a1e52b8d7a110fe25ed3cf8161a565735">executeSql</a> (const std::string \&statement, const int64\_t offset, const int64\_t limit, const std::string \&requestSchemaStr, const std::vector\< std::vector\< uint8\_t > > \&data, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1ExecuteSqlResponse">ExecuteSqlResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Execute a SQL statement (query, DML, or DDL). <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ExportQueryMetricsResponse">ExportQueryMetricsResponse</a> </td>
        <td><a href="#a6df9ad317c7d2a3d64d8ac8458714ee8">exportQueryMetrics</a> (const <a href="/content/api/cpp/structgpudb_1_1ExportQueryMetricsRequest">ExportQueryMetricsRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Export query metrics to a given destination. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ExportQueryMetricsResponse">ExportQueryMetricsResponse</a> & </td>
        <td><a href="#a43c34114c40250de0da0d9d648a17c2b">exportQueryMetrics</a> (const <a href="/content/api/cpp/structgpudb_1_1ExportQueryMetricsRequest">ExportQueryMetricsRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1ExportQueryMetricsResponse">ExportQueryMetricsResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Export query metrics to a given destination. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ExportQueryMetricsResponse">ExportQueryMetricsResponse</a> </td>
        <td><a href="#a1fa54ce032273e8e7d62caa01d88af62">exportQueryMetrics</a> (const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Export query metrics to a given destination. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ExportQueryMetricsResponse">ExportQueryMetricsResponse</a> & </td>
        <td><a href="#a292947b6dc2f76450057d3cfdf279d3e">exportQueryMetrics</a> (const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1ExportQueryMetricsResponse">ExportQueryMetricsResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Export query metrics to a given destination. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ExportRecordsToFilesResponse">ExportRecordsToFilesResponse</a> </td>
        <td><a href="#ac87ebd44dd67211df26b516cd7d3a7a4">exportRecordsToFiles</a> (const <a href="/content/api/cpp/structgpudb_1_1ExportRecordsToFilesRequest">ExportRecordsToFilesRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Export records from a table to files. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ExportRecordsToFilesResponse">ExportRecordsToFilesResponse</a> & </td>
        <td><a href="#a66c79c3143982b18ff2d8e48e99e9100">exportRecordsToFiles</a> (const <a href="/content/api/cpp/structgpudb_1_1ExportRecordsToFilesRequest">ExportRecordsToFilesRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1ExportRecordsToFilesResponse">ExportRecordsToFilesResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Export records from a table to files. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ExportRecordsToFilesResponse">ExportRecordsToFilesResponse</a> </td>
        <td><a href="#a66a1fac770f06727b15cc86643507496">exportRecordsToFiles</a> (const std::string \&tableName, const std::string \&filepath, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Export records from a table to files. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ExportRecordsToFilesResponse">ExportRecordsToFilesResponse</a> & </td>
        <td><a href="#ab374af267e3c6213b782792a76c26411">exportRecordsToFiles</a> (const std::string \&tableName, const std::string \&filepath, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1ExportRecordsToFilesResponse">ExportRecordsToFilesResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Export records from a table to files. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ExportRecordsToTableResponse">ExportRecordsToTableResponse</a> </td>
        <td><a href="#a63a3d3e6b0df86ad1a7cab47c9223904">exportRecordsToTable</a> (const <a href="/content/api/cpp/structgpudb_1_1ExportRecordsToTableRequest">ExportRecordsToTableRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Exports records from source table to the specified target table in an external database. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ExportRecordsToTableResponse">ExportRecordsToTableResponse</a> & </td>
        <td><a href="#a19cc9e60db0a4e1464ab705dd22f7c4a">exportRecordsToTable</a> (const <a href="/content/api/cpp/structgpudb_1_1ExportRecordsToTableRequest">ExportRecordsToTableRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1ExportRecordsToTableResponse">ExportRecordsToTableResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Exports records from source table to the specified target table in an external database. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ExportRecordsToTableResponse">ExportRecordsToTableResponse</a> </td>
        <td><a href="#a6e8f99e3e18f0dc268bd05fab42177b4">exportRecordsToTable</a> (const std::string \&tableName, const std::string \&remoteQuery, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Exports records from source table to the specified target table in an external database. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ExportRecordsToTableResponse">ExportRecordsToTableResponse</a> & </td>
        <td><a href="#ae4b6afe4a9a67fa6eeba83b2f596afe4">exportRecordsToTable</a> (const std::string \&tableName, const std::string \&remoteQuery, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1ExportRecordsToTableResponse">ExportRecordsToTableResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Exports records from source table to the specified target table in an external database. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1FilterResponse">FilterResponse</a> </td>
        <td><a href="#ad975f31cd9d87d805ebb0513f652eca6">filter</a> (const <a href="/content/api/cpp/structgpudb_1_1FilterRequest">FilterRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Filters data based on the specified expression. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1FilterResponse">FilterResponse</a> & </td>
        <td><a href="#a345135f1227d9d1576c3d30a997a258d">filter</a> (const <a href="/content/api/cpp/structgpudb_1_1FilterRequest">FilterRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1FilterResponse">FilterResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Filters data based on the specified expression. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1FilterResponse">FilterResponse</a> </td>
        <td><a href="#ac5b65e73c01c331f1fcfb21b0e8d67ce">filter</a> (const std::string \&tableName, const std::string \&viewName, const std::string \&expression, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Filters data based on the specified expression. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1FilterResponse">FilterResponse</a> & </td>
        <td><a href="#a98d8963830d3286bd2bbee4271a259b0">filter</a> (const std::string \&tableName, const std::string \&viewName, const std::string \&expression, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1FilterResponse">FilterResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Filters data based on the specified expression. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1FilterByAreaResponse">FilterByAreaResponse</a> </td>
        <td><a href="#a65f7751d7d3b9a971ad0cb4f94a29826">filterByArea</a> (const <a href="/content/api/cpp/structgpudb_1_1FilterByAreaRequest">FilterByAreaRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Calculates which objects from a table are within a named area of interest (NAI/polygon). <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1FilterByAreaResponse">FilterByAreaResponse</a> & </td>
        <td><a href="#ab6356f6e151c19b722161d511cc7680b">filterByArea</a> (const <a href="/content/api/cpp/structgpudb_1_1FilterByAreaRequest">FilterByAreaRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1FilterByAreaResponse">FilterByAreaResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Calculates which objects from a table are within a named area of interest (NAI/polygon). <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1FilterByAreaResponse">FilterByAreaResponse</a> </td>
        <td><a href="#aaf78a92abcaa5bfba493cdc0b79ff57e">filterByArea</a> (const std::string \&tableName, const std::string \&viewName, const std::string \&xColumnName, const std::vector\< double > \&xVector, const std::string \&yColumnName, const std::vector\< double > \&yVector, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Calculates which objects from a table are within a named area of interest (NAI/polygon). <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1FilterByAreaResponse">FilterByAreaResponse</a> & </td>
        <td><a href="#a44e614f3e78963e8ec9da02bd2c86475">filterByArea</a> (const std::string \&tableName, const std::string \&viewName, const std::string \&xColumnName, const std::vector\< double > \&xVector, const std::string \&yColumnName, const std::vector\< double > \&yVector, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1FilterByAreaResponse">FilterByAreaResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Calculates which objects from a table are within a named area of interest (NAI/polygon). <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1FilterByAreaGeometryResponse">FilterByAreaGeometryResponse</a> </td>
        <td><a href="#aa47be462dde2c9491093a82f7ace9315">filterByAreaGeometry</a> (const <a href="/content/api/cpp/structgpudb_1_1FilterByAreaGeometryRequest">FilterByAreaGeometryRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Calculates which geospatial geometry objects from a table intersect a named area of interest (NAI/polygon). <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1FilterByAreaGeometryResponse">FilterByAreaGeometryResponse</a> & </td>
        <td><a href="#a06cbbea9c031b7d73dbbe5a25b1ed930">filterByAreaGeometry</a> (const <a href="/content/api/cpp/structgpudb_1_1FilterByAreaGeometryRequest">FilterByAreaGeometryRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1FilterByAreaGeometryResponse">FilterByAreaGeometryResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Calculates which geospatial geometry objects from a table intersect a named area of interest (NAI/polygon). <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1FilterByAreaGeometryResponse">FilterByAreaGeometryResponse</a> </td>
        <td><a href="#a04e87bd426d13ebca107834c29c420a9">filterByAreaGeometry</a> (const std::string \&tableName, const std::string \&viewName, const std::string \&columnName, const std::vector\< double > \&xVector, const std::vector\< double > \&yVector, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Calculates which geospatial geometry objects from a table intersect a named area of interest (NAI/polygon). <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1FilterByAreaGeometryResponse">FilterByAreaGeometryResponse</a> & </td>
        <td><a href="#ad2099ed76a05134490875509eed4fa66">filterByAreaGeometry</a> (const std::string \&tableName, const std::string \&viewName, const std::string \&columnName, const std::vector\< double > \&xVector, const std::vector\< double > \&yVector, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1FilterByAreaGeometryResponse">FilterByAreaGeometryResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Calculates which geospatial geometry objects from a table intersect a named area of interest (NAI/polygon). <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1FilterByBoxResponse">FilterByBoxResponse</a> </td>
        <td><a href="#a7ff600263469d50ac759bc5c458448f5">filterByBox</a> (const <a href="/content/api/cpp/structgpudb_1_1FilterByBoxRequest">FilterByBoxRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Calculates how many objects within the given table lie in a rectangular box. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1FilterByBoxResponse">FilterByBoxResponse</a> & </td>
        <td><a href="#a30b08ec7f60291ea463b36f40ff6369e">filterByBox</a> (const <a href="/content/api/cpp/structgpudb_1_1FilterByBoxRequest">FilterByBoxRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1FilterByBoxResponse">FilterByBoxResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Calculates how many objects within the given table lie in a rectangular box. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1FilterByBoxResponse">FilterByBoxResponse</a> </td>
        <td><a href="#a3bd9f66e3c922c0e6332cd45d7c788dd">filterByBox</a> (const std::string \&tableName, const std::string \&viewName, const std::string \&xColumnName, const double minX, const double maxX, const std::string \&yColumnName, const double minY, const double maxY, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Calculates how many objects within the given table lie in a rectangular box. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1FilterByBoxResponse">FilterByBoxResponse</a> & </td>
        <td><a href="#a989bf054ca50099e75b1cfe306d9a64b">filterByBox</a> (const std::string \&tableName, const std::string \&viewName, const std::string \&xColumnName, const double minX, const double maxX, const std::string \&yColumnName, const double minY, const double maxY, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1FilterByBoxResponse">FilterByBoxResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Calculates how many objects within the given table lie in a rectangular box. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1FilterByBoxGeometryResponse">FilterByBoxGeometryResponse</a> </td>
        <td><a href="#a91e87e0190250bf93d78ae3560a2cd01">filterByBoxGeometry</a> (const <a href="/content/api/cpp/structgpudb_1_1FilterByBoxGeometryRequest">FilterByBoxGeometryRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Calculates which geospatial geometry objects from a table intersect a rectangular box. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1FilterByBoxGeometryResponse">FilterByBoxGeometryResponse</a> & </td>
        <td><a href="#ac9b5f5edd838415599ee4c013ca6ac38">filterByBoxGeometry</a> (const <a href="/content/api/cpp/structgpudb_1_1FilterByBoxGeometryRequest">FilterByBoxGeometryRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1FilterByBoxGeometryResponse">FilterByBoxGeometryResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Calculates which geospatial geometry objects from a table intersect a rectangular box. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1FilterByBoxGeometryResponse">FilterByBoxGeometryResponse</a> </td>
        <td><a href="#a9d0f8bc3e06532e682f2db0189a35e7f">filterByBoxGeometry</a> (const std::string \&tableName, const std::string \&viewName, const std::string \&columnName, const double minX, const double maxX, const double minY, const double maxY, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Calculates which geospatial geometry objects from a table intersect a rectangular box. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1FilterByBoxGeometryResponse">FilterByBoxGeometryResponse</a> & </td>
        <td><a href="#a758e0f01ae576cd1fac86557617d8d7d">filterByBoxGeometry</a> (const std::string \&tableName, const std::string \&viewName, const std::string \&columnName, const double minX, const double maxX, const double minY, const double maxY, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1FilterByBoxGeometryResponse">FilterByBoxGeometryResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Calculates which geospatial geometry objects from a table intersect a rectangular box. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1FilterByGeometryResponse">FilterByGeometryResponse</a> </td>
        <td><a href="#a1bebed28c75d07732fb9ad15f64c58ff">filterByGeometry</a> (const <a href="/content/api/cpp/structgpudb_1_1FilterByGeometryRequest">FilterByGeometryRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Applies a geometry filter against a geospatial geometry column in a given table or view. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1FilterByGeometryResponse">FilterByGeometryResponse</a> & </td>
        <td><a href="#a323acd0004c11a55be16b40ab91818ba">filterByGeometry</a> (const <a href="/content/api/cpp/structgpudb_1_1FilterByGeometryRequest">FilterByGeometryRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1FilterByGeometryResponse">FilterByGeometryResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Applies a geometry filter against a geospatial geometry column in a given table or view. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1FilterByGeometryResponse">FilterByGeometryResponse</a> </td>
        <td><a href="#a922116bd986d005f07507a265332b9eb">filterByGeometry</a> (const std::string \&tableName, const std::string \&viewName, const std::string \&columnName, const std::string \&inputWkt, const std::string \&operation, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Applies a geometry filter against a geospatial geometry column in a given table or view. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1FilterByGeometryResponse">FilterByGeometryResponse</a> & </td>
        <td><a href="#a77c2a9d3b73e4bd4966bf2fe5e85e1cc">filterByGeometry</a> (const std::string \&tableName, const std::string \&viewName, const std::string \&columnName, const std::string \&inputWkt, const std::string \&operation, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1FilterByGeometryResponse">FilterByGeometryResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Applies a geometry filter against a geospatial geometry column in a given table or view. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1FilterByListResponse">FilterByListResponse</a> </td>
        <td><a href="#a16572195af55d6e7b2b6f267977998ec">filterByList</a> (const <a href="/content/api/cpp/structgpudb_1_1FilterByListRequest">FilterByListRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Calculates which records from a table have values in the given list for the corresponding column. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1FilterByListResponse">FilterByListResponse</a> & </td>
        <td><a href="#ac2e4d574684346f53d2662ff3f7b868d">filterByList</a> (const <a href="/content/api/cpp/structgpudb_1_1FilterByListRequest">FilterByListRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1FilterByListResponse">FilterByListResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Calculates which records from a table have values in the given list for the corresponding column. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1FilterByListResponse">FilterByListResponse</a> </td>
        <td><a href="#a2c1c1d116e1600a9426bd20f9d1ac425">filterByList</a> (const std::string \&tableName, const std::string \&viewName, const std::map\< std::string, std::vector\< std::string > > \&columnValuesMap, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Calculates which records from a table have values in the given list for the corresponding column. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1FilterByListResponse">FilterByListResponse</a> & </td>
        <td><a href="#ad46d13e6efcd003b0877462de256703a">filterByList</a> (const std::string \&tableName, const std::string \&viewName, const std::map\< std::string, std::vector\< std::string > > \&columnValuesMap, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1FilterByListResponse">FilterByListResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Calculates which records from a table have values in the given list for the corresponding column. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1FilterByRadiusResponse">FilterByRadiusResponse</a> </td>
        <td><a href="#a2c1e67f2a3f2381078fdc39377184c0c">filterByRadius</a> (const <a href="/content/api/cpp/structgpudb_1_1FilterByRadiusRequest">FilterByRadiusRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Calculates which objects from a table lie within a circle with the given radius and center point (i.e. circular NAI). <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1FilterByRadiusResponse">FilterByRadiusResponse</a> & </td>
        <td><a href="#adc36d48ae5bb60782da377c45ef1836e">filterByRadius</a> (const <a href="/content/api/cpp/structgpudb_1_1FilterByRadiusRequest">FilterByRadiusRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1FilterByRadiusResponse">FilterByRadiusResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Calculates which objects from a table lie within a circle with the given radius and center point (i.e. circular NAI). <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1FilterByRadiusResponse">FilterByRadiusResponse</a> </td>
        <td><a href="#a28e32e78ccc815eeaac93f3cb3e59bac">filterByRadius</a> (const std::string \&tableName, const std::string \&viewName, const std::string \&xColumnName, const double xCenter, const std::string \&yColumnName, const double yCenter, const double radius, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Calculates which objects from a table lie within a circle with the given radius and center point (i.e. circular NAI). <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1FilterByRadiusResponse">FilterByRadiusResponse</a> & </td>
        <td><a href="#a339d080b90896acb584c8c903ccc6135">filterByRadius</a> (const std::string \&tableName, const std::string \&viewName, const std::string \&xColumnName, const double xCenter, const std::string \&yColumnName, const double yCenter, const double radius, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1FilterByRadiusResponse">FilterByRadiusResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Calculates which objects from a table lie within a circle with the given radius and center point (i.e. circular NAI). <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1FilterByRadiusGeometryResponse">FilterByRadiusGeometryResponse</a> </td>
        <td><a href="#a053919df7c9a2cd548386cf5490b626b">filterByRadiusGeometry</a> (const <a href="/content/api/cpp/structgpudb_1_1FilterByRadiusGeometryRequest">FilterByRadiusGeometryRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Calculates which geospatial geometry objects from a table intersect a circle with the given radius and center point (i.e. circular NAI). <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1FilterByRadiusGeometryResponse">FilterByRadiusGeometryResponse</a> & </td>
        <td><a href="#a4fd603a05fcd7e293eacac31dbef40ee">filterByRadiusGeometry</a> (const <a href="/content/api/cpp/structgpudb_1_1FilterByRadiusGeometryRequest">FilterByRadiusGeometryRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1FilterByRadiusGeometryResponse">FilterByRadiusGeometryResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Calculates which geospatial geometry objects from a table intersect a circle with the given radius and center point (i.e. circular NAI). <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1FilterByRadiusGeometryResponse">FilterByRadiusGeometryResponse</a> </td>
        <td><a href="#a007497ef1b48038f75b28a5236fbae5e">filterByRadiusGeometry</a> (const std::string \&tableName, const std::string \&viewName, const std::string \&columnName, const double xCenter, const double yCenter, const double radius, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Calculates which geospatial geometry objects from a table intersect a circle with the given radius and center point (i.e. circular NAI). <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1FilterByRadiusGeometryResponse">FilterByRadiusGeometryResponse</a> & </td>
        <td><a href="#ab97caa1af20257efea7ca3c1e8dbbc10">filterByRadiusGeometry</a> (const std::string \&tableName, const std::string \&viewName, const std::string \&columnName, const double xCenter, const double yCenter, const double radius, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1FilterByRadiusGeometryResponse">FilterByRadiusGeometryResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Calculates which geospatial geometry objects from a table intersect a circle with the given radius and center point (i.e. circular NAI). <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1FilterByRangeResponse">FilterByRangeResponse</a> </td>
        <td><a href="#abb55e3a7ca457708686d596cdd5f1d05">filterByRange</a> (const <a href="/content/api/cpp/structgpudb_1_1FilterByRangeRequest">FilterByRangeRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Calculates which objects from a table have a column that is within the given bounds. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1FilterByRangeResponse">FilterByRangeResponse</a> & </td>
        <td><a href="#ab9870f431c1afe2a8454a167c143f1be">filterByRange</a> (const <a href="/content/api/cpp/structgpudb_1_1FilterByRangeRequest">FilterByRangeRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1FilterByRangeResponse">FilterByRangeResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Calculates which objects from a table have a column that is within the given bounds. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1FilterByRangeResponse">FilterByRangeResponse</a> </td>
        <td><a href="#a5053d89bf393fe4405f6011fa4a2a6ce">filterByRange</a> (const std::string \&tableName, const std::string \&viewName, const std::string \&columnName, const double lowerBound, const double upperBound, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Calculates which objects from a table have a column that is within the given bounds. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1FilterByRangeResponse">FilterByRangeResponse</a> & </td>
        <td><a href="#a2f9a414b5ba06eba04464e4b76dae887">filterByRange</a> (const std::string \&tableName, const std::string \&viewName, const std::string \&columnName, const double lowerBound, const double upperBound, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1FilterByRangeResponse">FilterByRangeResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Calculates which objects from a table have a column that is within the given bounds. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1FilterBySeriesResponse">FilterBySeriesResponse</a> </td>
        <td><a href="#aa46f3221490a48a0145d65ed38a97563">filterBySeries</a> (const <a href="/content/api/cpp/structgpudb_1_1FilterBySeriesRequest">FilterBySeriesRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Filters objects matching all points of the given track (works only on track type data). <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1FilterBySeriesResponse">FilterBySeriesResponse</a> & </td>
        <td><a href="#a8a754c08f50d55e2d688eecd62772dde">filterBySeries</a> (const <a href="/content/api/cpp/structgpudb_1_1FilterBySeriesRequest">FilterBySeriesRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1FilterBySeriesResponse">FilterBySeriesResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Filters objects matching all points of the given track (works only on track type data). <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1FilterBySeriesResponse">FilterBySeriesResponse</a> </td>
        <td><a href="#a0a04108b75417e335df61fae04747929">filterBySeries</a> (const std::string \&tableName, const std::string \&viewName, const std::string \&trackId, const std::vector\< std::string > \&targetTrackIds, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Filters objects matching all points of the given track (works only on track type data). <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1FilterBySeriesResponse">FilterBySeriesResponse</a> & </td>
        <td><a href="#ad1319704a118df63b66e7762bf99e9a2">filterBySeries</a> (const std::string \&tableName, const std::string \&viewName, const std::string \&trackId, const std::vector\< std::string > \&targetTrackIds, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1FilterBySeriesResponse">FilterBySeriesResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Filters objects matching all points of the given track (works only on track type data). <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1FilterByStringResponse">FilterByStringResponse</a> </td>
        <td><a href="#a4c7a7acb22b8793a57a5c9162f7e063e">filterByString</a> (const <a href="/content/api/cpp/structgpudb_1_1FilterByStringRequest">FilterByStringRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Calculates which objects from a table or view match a string expression for the given string columns. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1FilterByStringResponse">FilterByStringResponse</a> & </td>
        <td><a href="#a2fbef5ccbedc476c240e83e1350a898a">filterByString</a> (const <a href="/content/api/cpp/structgpudb_1_1FilterByStringRequest">FilterByStringRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1FilterByStringResponse">FilterByStringResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Calculates which objects from a table or view match a string expression for the given string columns. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1FilterByStringResponse">FilterByStringResponse</a> </td>
        <td><a href="#a950c256cf401850944e641ab760f9e5e">filterByString</a> (const std::string \&tableName, const std::string \&viewName, const std::string \&expression, const std::string \&mode, const std::vector\< std::string > \&columnNames, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Calculates which objects from a table or view match a string expression for the given string columns. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1FilterByStringResponse">FilterByStringResponse</a> & </td>
        <td><a href="#abe5f7d81e26d9ae26b172fe2670eb41f">filterByString</a> (const std::string \&tableName, const std::string \&viewName, const std::string \&expression, const std::string \&mode, const std::vector\< std::string > \&columnNames, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1FilterByStringResponse">FilterByStringResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Calculates which objects from a table or view match a string expression for the given string columns. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1FilterByTableResponse">FilterByTableResponse</a> </td>
        <td><a href="#a5c433b2d7eecc3b3942dfa4b3a8a8439">filterByTable</a> (const <a href="/content/api/cpp/structgpudb_1_1FilterByTableRequest">FilterByTableRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Filters objects in one table based on objects in another table. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1FilterByTableResponse">FilterByTableResponse</a> & </td>
        <td><a href="#a8ba8e97be0cc690bb7d2e50a986006f7">filterByTable</a> (const <a href="/content/api/cpp/structgpudb_1_1FilterByTableRequest">FilterByTableRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1FilterByTableResponse">FilterByTableResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Filters objects in one table based on objects in another table. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1FilterByTableResponse">FilterByTableResponse</a> </td>
        <td><a href="#a5b1459e1faf37b5d66c404ba87a1a959">filterByTable</a> (const std::string \&tableName, const std::string \&viewName, const std::string \&columnName, const std::string \&sourceTableName, const std::string \&sourceTableColumnName, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Filters objects in one table based on objects in another table. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1FilterByTableResponse">FilterByTableResponse</a> & </td>
        <td><a href="#a05ba1ecb87eef74577e33e6638000855">filterByTable</a> (const std::string \&tableName, const std::string \&viewName, const std::string \&columnName, const std::string \&sourceTableName, const std::string \&sourceTableColumnName, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1FilterByTableResponse">FilterByTableResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Filters objects in one table based on objects in another table. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1FilterByValueResponse">FilterByValueResponse</a> </td>
        <td><a href="#adf1643ba8a5fb03eaf47c8991c004a4c">filterByValue</a> (const <a href="/content/api/cpp/structgpudb_1_1FilterByValueRequest">FilterByValueRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Calculates which objects from a table has a particular value for a particular column. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1FilterByValueResponse">FilterByValueResponse</a> & </td>
        <td><a href="#a5e7b729ac26c2847bb2d3d59d332d9e3">filterByValue</a> (const <a href="/content/api/cpp/structgpudb_1_1FilterByValueRequest">FilterByValueRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1FilterByValueResponse">FilterByValueResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Calculates which objects from a table has a particular value for a particular column. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1FilterByValueResponse">FilterByValueResponse</a> </td>
        <td><a href="#a38c7ac75e711488e45d6480b5081587b">filterByValue</a> (const std::string \&tableName, const std::string \&viewName, const bool isString, const double value, const std::string \&valueStr, const std::string \&columnName, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Calculates which objects from a table has a particular value for a particular column. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1FilterByValueResponse">FilterByValueResponse</a> & </td>
        <td><a href="#a7037257854419f4cd849349c908358af">filterByValue</a> (const std::string \&tableName, const std::string \&viewName, const bool isString, const double value, const std::string \&valueStr, const std::string \&columnName, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1FilterByValueResponse">FilterByValueResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Calculates which objects from a table has a particular value for a particular column. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1GetGraphEntitiesResponse">GetGraphEntitiesResponse</a> </td>
        <td><a href="#a6646fdaddf14aa7d9857ec0636fa204f">getGraphEntities</a> (const <a href="/content/api/cpp/structgpudb_1_1GetGraphEntitiesRequest">GetGraphEntitiesRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Retrieves node or edge entities from an existing graph, with pagination support via offset and limit. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1GetGraphEntitiesResponse">GetGraphEntitiesResponse</a> & </td>
        <td><a href="#a2ece66c08b4b6d9350f7d829b792ccec">getGraphEntities</a> (const <a href="/content/api/cpp/structgpudb_1_1GetGraphEntitiesRequest">GetGraphEntitiesRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1GetGraphEntitiesResponse">GetGraphEntitiesResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Retrieves node or edge entities from an existing graph, with pagination support via offset and limit. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1GetGraphEntitiesResponse">GetGraphEntitiesResponse</a> </td>
        <td><a href="#a6800299fb04843d1be5d5ffbd2a425f7">getGraphEntities</a> (const std::string \&graphName, const int64\_t offset, const int64\_t limit, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Retrieves node or edge entities from an existing graph, with pagination support via offset and limit. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1GetGraphEntitiesResponse">GetGraphEntitiesResponse</a> & </td>
        <td><a href="#a641d9be4063a18ae8970878abb94d0ed">getGraphEntities</a> (const std::string \&graphName, const int64\_t offset, const int64\_t limit, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1GetGraphEntitiesResponse">GetGraphEntitiesResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Retrieves node or edge entities from an existing graph, with pagination support via offset and limit. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1GetJobResponse">GetJobResponse</a> </td>
        <td><a href="#a0ff78cb10848a739067c5dbd0a052e05">getJob</a> (const <a href="/content/api/cpp/structgpudb_1_1GetJobRequest">GetJobRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Get the status and result of asynchronously running job. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1GetJobResponse">GetJobResponse</a> & </td>
        <td><a href="#a3075e357878ca48139bfc2c938ea7ea6">getJob</a> (const <a href="/content/api/cpp/structgpudb_1_1GetJobRequest">GetJobRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1GetJobResponse">GetJobResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Get the status and result of asynchronously running job. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1GetJobResponse">GetJobResponse</a> </td>
        <td><a href="#a8f46b312a6700634204dec278fe18b98">getJob</a> (const int64\_t jobId, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Get the status and result of asynchronously running job. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1GetJobResponse">GetJobResponse</a> & </td>
        <td><a href="#ab851aa12144cb49427033f0331b10391">getJob</a> (const int64\_t jobId, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1GetJobResponse">GetJobResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Get the status and result of asynchronously running job. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1RawGetRecordsResponse">RawGetRecordsResponse</a> </td>
        <td><a href="#afefae2f48831c864d2f19e27fbb2ad65">getRecordsRaw</a> (const <a href="/content/api/cpp/structgpudb_1_1GetRecordsRequest">GetRecordsRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Retrieves records from a given table, optionally filtered by an expression and/or sorted by a column. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1RawGetRecordsResponse">RawGetRecordsResponse</a> & </td>
        <td><a href="#a4d416d301bad8f60f2376499284a7d4e">getRecordsRaw</a> (const <a href="/content/api/cpp/structgpudb_1_1GetRecordsRequest">GetRecordsRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1RawGetRecordsResponse">RawGetRecordsResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Retrieves records from a given table, optionally filtered by an expression and/or sorted by a column. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>template\<typename TResponse> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsResponse">GetRecordsResponse</a>\< TResponse > </td>
        <td><a href="#a32de6c3fa89b56e5c573cf04bbbafabb">getRecords</a> (const <a href="/content/api/cpp/structgpudb_1_1GetRecordsRequest">GetRecordsRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Retrieves records from a given table, optionally filtered by an expression and/or sorted by a column. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>template\<typename TResponse> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsResponse">GetRecordsResponse</a>\< TResponse > & </td>
        <td><a href="#a2c704c2004c307792fd6883a1b6d7503">getRecords</a> (const <a href="/content/api/cpp/structgpudb_1_1GetRecordsRequest">GetRecordsRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1GetRecordsResponse">GetRecordsResponse</a>\< TResponse > \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Retrieves records from a given table, optionally filtered by an expression and/or sorted by a column. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>template\<typename TResponse> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsResponse">GetRecordsResponse</a>\< TResponse > </td>
        <td><a href="#a6b39d1540501defd2bdb03feed7928f8">getRecords</a> (const std::string \&tableName, const int64\_t offset, const int64\_t limit, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Retrieves records from a given table, optionally filtered by an expression and/or sorted by a column. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>template\<typename TResponse> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsResponse">GetRecordsResponse</a>\< TResponse > & </td>
        <td><a href="#a91126344a584c907b7265fb5048af6cc">getRecords</a> (const std::string \&tableName, const int64\_t offset, const int64\_t limit, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1GetRecordsResponse">GetRecordsResponse</a>\< TResponse > \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Retrieves records from a given table, optionally filtered by an expression and/or sorted by a column. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>template\<typename TResponse> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsResponse">GetRecordsResponse</a>\< TResponse > </td>
        <td><a href="#a107efac13be55b48d53e2d96a3bdff7a">getRecords</a> (const ::avro::ValidSchema \&schema\_, const <a href="/content/api/cpp/structgpudb_1_1GetRecordsRequest">GetRecordsRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Retrieves records from a given table, optionally filtered by an expression and/or sorted by a column. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>template\<typename TResponse> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsResponse">GetRecordsResponse</a>\< TResponse > </td>
        <td><a href="#a65a981945189ac5191f6ef8236736b18">getRecords</a> (const <a href="/content/api/cpp/classgpudb_1_1Type">Type</a> \&type\_, const <a href="/content/api/cpp/structgpudb_1_1GetRecordsRequest">GetRecordsRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Retrieves records from a given table, optionally filtered by an expression and/or sorted by a column. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>template\<typename TResponse> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsResponse">GetRecordsResponse</a>\< TResponse > & </td>
        <td><a href="#a82359502778b3d1f8f107021bea19eb0">getRecords</a> (const ::avro::ValidSchema \&schema\_, const <a href="/content/api/cpp/structgpudb_1_1GetRecordsRequest">GetRecordsRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1GetRecordsResponse">GetRecordsResponse</a>\< TResponse > \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Retrieves records from a given table, optionally filtered by an expression and/or sorted by a column. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>template\<typename TResponse> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsResponse">GetRecordsResponse</a>\< TResponse > & </td>
        <td><a href="#aac3d1e38fb24597f0576eaf224d0d843">getRecords</a> (const <a href="/content/api/cpp/classgpudb_1_1Type">Type</a> \&type\_, const <a href="/content/api/cpp/structgpudb_1_1GetRecordsRequest">GetRecordsRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1GetRecordsResponse">GetRecordsResponse</a>\< TResponse > \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Retrieves records from a given table, optionally filtered by an expression and/or sorted by a column. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>template\<typename TResponse> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsResponse">GetRecordsResponse</a>\< TResponse > </td>
        <td><a href="#a2343e4363db89e8d9af6c93984e17dd9">getRecords</a> (const ::avro::ValidSchema \&schema\_, const std::string \&tableName, const int64\_t offset, const int64\_t limit, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Retrieves records from a given table, optionally filtered by an expression and/or sorted by a column. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>template\<typename TResponse> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsResponse">GetRecordsResponse</a>\< TResponse > </td>
        <td><a href="#a7f3ab43aa42646aec1a2ac7bea148f9d">getRecords</a> (const <a href="/content/api/cpp/classgpudb_1_1Type">Type</a> \&type\_, const std::string \&tableName, const int64\_t offset, const int64\_t limit, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Retrieves records from a given table, optionally filtered by an expression and/or sorted by a column. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>template\<typename TResponse> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsResponse">GetRecordsResponse</a>\< TResponse > & </td>
        <td><a href="#a64e3d2d06072159f665db02159b1e1ca">getRecords</a> (const ::avro::ValidSchema \&schema\_, const std::string \&tableName, const int64\_t offset, const int64\_t limit, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1GetRecordsResponse">GetRecordsResponse</a>\< TResponse > \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Retrieves records from a given table, optionally filtered by an expression and/or sorted by a column. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>template\<typename TResponse> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsResponse">GetRecordsResponse</a>\< TResponse > & </td>
        <td><a href="#a99f0ecf8a11e028593aa7c9b222f94ce">getRecords</a> (const <a href="/content/api/cpp/classgpudb_1_1Type">Type</a> \&type\_, const std::string \&tableName, const int64\_t offset, const int64\_t limit, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1GetRecordsResponse">GetRecordsResponse</a>\< TResponse > \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Retrieves records from a given table, optionally filtered by an expression and/or sorted by a column. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1RawGetRecordsByColumnResponse">RawGetRecordsByColumnResponse</a> </td>
        <td><a href="#ab27ed9c87017701489bd2e2d8d9bdbc7">getRecordsByColumnRaw</a> (const <a href="/content/api/cpp/structgpudb_1_1GetRecordsByColumnRequest">GetRecordsByColumnRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>For a given table, retrieves the values from the requested column(s). <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1RawGetRecordsByColumnResponse">RawGetRecordsByColumnResponse</a> & </td>
        <td><a href="#ad3f6fcdabf549c813352cae5e37112ca">getRecordsByColumnRaw</a> (const <a href="/content/api/cpp/structgpudb_1_1GetRecordsByColumnRequest">GetRecordsByColumnRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1RawGetRecordsByColumnResponse">RawGetRecordsByColumnResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>For a given table, retrieves the values from the requested column(s). <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsByColumnResponse">GetRecordsByColumnResponse</a> </td>
        <td><a href="#aaf391f0f2e29974de30e9aa91dbed1ef">getRecordsByColumn</a> (const <a href="/content/api/cpp/structgpudb_1_1GetRecordsByColumnRequest">GetRecordsByColumnRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>For a given table, retrieves the values from the requested column(s). <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsByColumnResponse">GetRecordsByColumnResponse</a> & </td>
        <td><a href="#a2de02e5fe9cd6f92b139fd657a103a8b">getRecordsByColumn</a> (const <a href="/content/api/cpp/structgpudb_1_1GetRecordsByColumnRequest">GetRecordsByColumnRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1GetRecordsByColumnResponse">GetRecordsByColumnResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>For a given table, retrieves the values from the requested column(s). <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsByColumnResponse">GetRecordsByColumnResponse</a> </td>
        <td><a href="#a5557e7cbe07004a0f754cf3bb5e5c62b">getRecordsByColumn</a> (const std::string \&tableName, const std::vector\< std::string > \&columnNames, const int64\_t offset, const int64\_t limit, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>For a given table, retrieves the values from the requested column(s). <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsByColumnResponse">GetRecordsByColumnResponse</a> & </td>
        <td><a href="#a7985e0b6c1423c738ae4922714d20404">getRecordsByColumn</a> (const std::string \&tableName, const std::vector\< std::string > \&columnNames, const int64\_t offset, const int64\_t limit, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1GetRecordsByColumnResponse">GetRecordsByColumnResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>For a given table, retrieves the values from the requested column(s). <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1RawGetRecordsBySeriesResponse">RawGetRecordsBySeriesResponse</a> </td>
        <td><a href="#ad755a200d4461a7f999906a2a4695fa9">getRecordsBySeriesRaw</a> (const <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest">GetRecordsBySeriesRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Retrieves the complete series/track records from the given <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest#a95d1e31e27c1d040de81b0ac7bd0d5ea">worldTableName</a> based on the partial track information contained in the <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest#a841767ddf7d2fe03d6531fd9cc1e48f0">tableName</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1RawGetRecordsBySeriesResponse">RawGetRecordsBySeriesResponse</a> & </td>
        <td><a href="#a05f9b2f364e233b9c1f7fbb8080aeb09">getRecordsBySeriesRaw</a> (const <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest">GetRecordsBySeriesRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1RawGetRecordsBySeriesResponse">RawGetRecordsBySeriesResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Retrieves the complete series/track records from the given <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest#a95d1e31e27c1d040de81b0ac7bd0d5ea">worldTableName</a> based on the partial track information contained in the <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest#a841767ddf7d2fe03d6531fd9cc1e48f0">tableName</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>template\<typename TResponse> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesResponse">GetRecordsBySeriesResponse</a>\< TResponse > </td>
        <td><a href="#aa961a79a8cd249ffe176b84eae64b232">getRecordsBySeries</a> (const <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest">GetRecordsBySeriesRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Retrieves the complete series/track records from the given <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest#a95d1e31e27c1d040de81b0ac7bd0d5ea">worldTableName</a> based on the partial track information contained in the <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest#a841767ddf7d2fe03d6531fd9cc1e48f0">tableName</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>template\<typename TResponse> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesResponse">GetRecordsBySeriesResponse</a>\< TResponse > & </td>
        <td><a href="#a84b5e781d7c9bb6df27e18783077961c">getRecordsBySeries</a> (const <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest">GetRecordsBySeriesRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesResponse">GetRecordsBySeriesResponse</a>\< TResponse > \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Retrieves the complete series/track records from the given <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest#a95d1e31e27c1d040de81b0ac7bd0d5ea">worldTableName</a> based on the partial track information contained in the <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest#a841767ddf7d2fe03d6531fd9cc1e48f0">tableName</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>template\<typename TResponse> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesResponse">GetRecordsBySeriesResponse</a>\< TResponse > </td>
        <td><a href="#a9ba2f4912ef6f4cc2f52e93850de4824">getRecordsBySeries</a> (const std::string \&tableName, const std::string \&worldTableName, const int32\_t offset, const int32\_t limit, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Retrieves the complete series/track records from the given <span>worldTableName</span> based on the partial track information contained in the <span>tableName</span>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>template\<typename TResponse> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesResponse">GetRecordsBySeriesResponse</a>\< TResponse > & </td>
        <td><a href="#a0421cd2f9891fff85f049e76c93faf53">getRecordsBySeries</a> (const std::string \&tableName, const std::string \&worldTableName, const int32\_t offset, const int32\_t limit, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesResponse">GetRecordsBySeriesResponse</a>\< TResponse > \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Retrieves the complete series/track records from the given <span>worldTableName</span> based on the partial track information contained in the <span>tableName</span>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>template\<typename TResponse> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesResponse">GetRecordsBySeriesResponse</a>\< TResponse > </td>
        <td><a href="#a1e347a748f650f5fcd765a317767211c">getRecordsBySeries</a> (const ::avro::ValidSchema \&schema\_, const <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest">GetRecordsBySeriesRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Retrieves the complete series/track records from the given <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest#a95d1e31e27c1d040de81b0ac7bd0d5ea">worldTableName</a> based on the partial track information contained in the <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest#a841767ddf7d2fe03d6531fd9cc1e48f0">tableName</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>template\<typename TResponse> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesResponse">GetRecordsBySeriesResponse</a>\< TResponse > </td>
        <td><a href="#a259ec9a4402b0e87b8556722fdf803bb">getRecordsBySeries</a> (const <a href="/content/api/cpp/classgpudb_1_1Type">Type</a> \&type\_, const <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest">GetRecordsBySeriesRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Retrieves the complete series/track records from the given <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest#a95d1e31e27c1d040de81b0ac7bd0d5ea">worldTableName</a> based on the partial track information contained in the <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest#a841767ddf7d2fe03d6531fd9cc1e48f0">tableName</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>template\<typename TResponse> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesResponse">GetRecordsBySeriesResponse</a>\< TResponse > & </td>
        <td><a href="#a1f41c29a6f7612526b10b5f4b4016005">getRecordsBySeries</a> (const ::avro::ValidSchema \&schema\_, const <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest">GetRecordsBySeriesRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesResponse">GetRecordsBySeriesResponse</a>\< TResponse > \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Retrieves the complete series/track records from the given <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest#a95d1e31e27c1d040de81b0ac7bd0d5ea">worldTableName</a> based on the partial track information contained in the <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest#a841767ddf7d2fe03d6531fd9cc1e48f0">tableName</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>template\<typename TResponse> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesResponse">GetRecordsBySeriesResponse</a>\< TResponse > & </td>
        <td><a href="#a5028b0c27cc919a440c81c036e3ddf41">getRecordsBySeries</a> (const <a href="/content/api/cpp/classgpudb_1_1Type">Type</a> \&type\_, const <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest">GetRecordsBySeriesRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesResponse">GetRecordsBySeriesResponse</a>\< TResponse > \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Retrieves the complete series/track records from the given <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest#a95d1e31e27c1d040de81b0ac7bd0d5ea">worldTableName</a> based on the partial track information contained in the <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest#a841767ddf7d2fe03d6531fd9cc1e48f0">tableName</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>template\<typename TResponse> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesResponse">GetRecordsBySeriesResponse</a>\< TResponse > </td>
        <td><a href="#adbadeef2e1699ea4e5724e438c5efec9">getRecordsBySeries</a> (const ::avro::ValidSchema \&schema\_, const std::string \&tableName, const std::string \&worldTableName, const int32\_t offset, const int32\_t limit, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Retrieves the complete series/track records from the given <span>worldTableName</span> based on the partial track information contained in the <span>tableName</span>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>template\<typename TResponse> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesResponse">GetRecordsBySeriesResponse</a>\< TResponse > </td>
        <td><a href="#a9c776cbfb140d5a261926d7082e84c1d">getRecordsBySeries</a> (const <a href="/content/api/cpp/classgpudb_1_1Type">Type</a> \&type\_, const std::string \&tableName, const std::string \&worldTableName, const int32\_t offset, const int32\_t limit, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Retrieves the complete series/track records from the given <span>worldTableName</span> based on the partial track information contained in the <span>tableName</span>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>template\<typename TResponse> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesResponse">GetRecordsBySeriesResponse</a>\< TResponse > & </td>
        <td><a href="#a648995d977040e1fd4634461ad398050">getRecordsBySeries</a> (const ::avro::ValidSchema \&schema\_, const std::string \&tableName, const std::string \&worldTableName, const int32\_t offset, const int32\_t limit, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesResponse">GetRecordsBySeriesResponse</a>\< TResponse > \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Retrieves the complete series/track records from the given <span>worldTableName</span> based on the partial track information contained in the <span>tableName</span>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>template\<typename TResponse> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesResponse">GetRecordsBySeriesResponse</a>\< TResponse > & </td>
        <td><a href="#a41ccbfa4677bbce9629b3d8f793884d4">getRecordsBySeries</a> (const <a href="/content/api/cpp/classgpudb_1_1Type">Type</a> \&type\_, const std::string \&tableName, const std::string \&worldTableName, const int32\_t offset, const int32\_t limit, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesResponse">GetRecordsBySeriesResponse</a>\< TResponse > \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Retrieves the complete series/track records from the given <span>worldTableName</span> based on the partial track information contained in the <span>tableName</span>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1RawGetRecordsFromCollectionResponse">RawGetRecordsFromCollectionResponse</a> </td>
        <td><a href="#a15a7bd6a0d065b5528141f8e00a91305">getRecordsFromCollectionRaw</a> (const <a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionRequest">GetRecordsFromCollectionRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Retrieves records from a collection. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1RawGetRecordsFromCollectionResponse">RawGetRecordsFromCollectionResponse</a> & </td>
        <td><a href="#ae59716b524af9a3d0532c72d85580ced">getRecordsFromCollectionRaw</a> (const <a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionRequest">GetRecordsFromCollectionRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1RawGetRecordsFromCollectionResponse">RawGetRecordsFromCollectionResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Retrieves records from a collection. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>template\<typename TResponse> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionResponse">GetRecordsFromCollectionResponse</a>\< TResponse > </td>
        <td><a href="#ae32bea3bdbfef60b21d2fb7506439ca5">getRecordsFromCollection</a> (const <a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionRequest">GetRecordsFromCollectionRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Retrieves records from a collection. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>template\<typename TResponse> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionResponse">GetRecordsFromCollectionResponse</a>\< TResponse > & </td>
        <td><a href="#a15bca10aa1488dac3494f994c2ca5753">getRecordsFromCollection</a> (const <a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionRequest">GetRecordsFromCollectionRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionResponse">GetRecordsFromCollectionResponse</a>\< TResponse > \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Retrieves records from a collection. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>template\<typename TResponse> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionResponse">GetRecordsFromCollectionResponse</a>\< TResponse > </td>
        <td><a href="#ad07e8ca5da326049590fc62762c630a1">getRecordsFromCollection</a> (const std::string \&tableName, const int64\_t offset, const int64\_t limit, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Retrieves records from a collection. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>template\<typename TResponse> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionResponse">GetRecordsFromCollectionResponse</a>\< TResponse > & </td>
        <td><a href="#ac438b7fefc4616a82a996f7597be53cd">getRecordsFromCollection</a> (const std::string \&tableName, const int64\_t offset, const int64\_t limit, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionResponse">GetRecordsFromCollectionResponse</a>\< TResponse > \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Retrieves records from a collection. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>template\<typename TResponse> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionResponse">GetRecordsFromCollectionResponse</a>\< TResponse > </td>
        <td><a href="#a1ba5c0e420cec6f8947cd6dcd2fd815f">getRecordsFromCollection</a> (const ::avro::ValidSchema \&schema\_, const <a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionRequest">GetRecordsFromCollectionRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Retrieves records from a collection. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>template\<typename TResponse> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionResponse">GetRecordsFromCollectionResponse</a>\< TResponse > </td>
        <td><a href="#a36d0a8b40fe139b5889367a6cd4fb52e">getRecordsFromCollection</a> (const <a href="/content/api/cpp/classgpudb_1_1Type">Type</a> \&type\_, const <a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionRequest">GetRecordsFromCollectionRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Retrieves records from a collection. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>template\<typename TResponse> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionResponse">GetRecordsFromCollectionResponse</a>\< TResponse > & </td>
        <td><a href="#aacfa6bf43de67a468d40a0c6aa8b0f9e">getRecordsFromCollection</a> (const ::avro::ValidSchema \&schema\_, const <a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionRequest">GetRecordsFromCollectionRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionResponse">GetRecordsFromCollectionResponse</a>\< TResponse > \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Retrieves records from a collection. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>template\<typename TResponse> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionResponse">GetRecordsFromCollectionResponse</a>\< TResponse > & </td>
        <td><a href="#aca16e6eb9cd2c12afdd910b778cc8b25">getRecordsFromCollection</a> (const <a href="/content/api/cpp/classgpudb_1_1Type">Type</a> \&type\_, const <a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionRequest">GetRecordsFromCollectionRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionResponse">GetRecordsFromCollectionResponse</a>\< TResponse > \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Retrieves records from a collection. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>template\<typename TResponse> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionResponse">GetRecordsFromCollectionResponse</a>\< TResponse > </td>
        <td><a href="#ab6e252847329faf291bc90d214718650">getRecordsFromCollection</a> (const ::avro::ValidSchema \&schema\_, const std::string \&tableName, const int64\_t offset, const int64\_t limit, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Retrieves records from a collection. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>template\<typename TResponse> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionResponse">GetRecordsFromCollectionResponse</a>\< TResponse > </td>
        <td><a href="#a1459d3d7015e72a3d8b783a7984e737b">getRecordsFromCollection</a> (const <a href="/content/api/cpp/classgpudb_1_1Type">Type</a> \&type\_, const std::string \&tableName, const int64\_t offset, const int64\_t limit, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Retrieves records from a collection. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>template\<typename TResponse> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionResponse">GetRecordsFromCollectionResponse</a>\< TResponse > & </td>
        <td><a href="#a3297c7c58cca0a4e2b8cc76b1ffa18ad">getRecordsFromCollection</a> (const ::avro::ValidSchema \&schema\_, const std::string \&tableName, const int64\_t offset, const int64\_t limit, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionResponse">GetRecordsFromCollectionResponse</a>\< TResponse > \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Retrieves records from a collection. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>template\<typename TResponse> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionResponse">GetRecordsFromCollectionResponse</a>\< TResponse > & </td>
        <td><a href="#abd901e4bd4f9e2f1a4e54503b8fd44b2">getRecordsFromCollection</a> (const <a href="/content/api/cpp/classgpudb_1_1Type">Type</a> \&type\_, const std::string \&tableName, const int64\_t offset, const int64\_t limit, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionResponse">GetRecordsFromCollectionResponse</a>\< TResponse > \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Retrieves records from a collection. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1GrantPermissionResponse">GrantPermissionResponse</a> </td>
        <td><a href="#a9634c497d7035ee98062b6f92a63be8d">grantPermission</a> (const <a href="/content/api/cpp/structgpudb_1_1GrantPermissionRequest">GrantPermissionRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Grant user or role the specified permission on the specified object. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1GrantPermissionResponse">GrantPermissionResponse</a> & </td>
        <td><a href="#a8952ec4a4b6493b32acbe9b5e6a7959f">grantPermission</a> (const <a href="/content/api/cpp/structgpudb_1_1GrantPermissionRequest">GrantPermissionRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1GrantPermissionResponse">GrantPermissionResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Grant user or role the specified permission on the specified object. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1GrantPermissionResponse">GrantPermissionResponse</a> </td>
        <td><a href="#ad2439e67beadacbe234814ad9c4e4691">grantPermission</a> (const std::string \&principal, const std::string \&object, const std::string \&objectType, const std::string \&permission, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Grant user or role the specified permission on the specified object. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1GrantPermissionResponse">GrantPermissionResponse</a> & </td>
        <td><a href="#a13c6927f982fefb3149bbd625970e994">grantPermission</a> (const std::string \&principal, const std::string \&object, const std::string \&objectType, const std::string \&permission, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1GrantPermissionResponse">GrantPermissionResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Grant user or role the specified permission on the specified object. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1GrantPermissionCredentialResponse">GrantPermissionCredentialResponse</a> </td>
        <td><a href="#a5af24b8cecd2bbd61c1fb7e9725e33a8">grantPermissionCredential</a> (const <a href="/content/api/cpp/structgpudb_1_1GrantPermissionCredentialRequest">GrantPermissionCredentialRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Grants a <a href="/content/security/sec_concepts/#security-concepts-permissions-credential">credential-level permission</a> to a user or role. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1GrantPermissionCredentialResponse">GrantPermissionCredentialResponse</a> & </td>
        <td><a href="#a5e6ce0e2b63b4f558fc15a2ffbbd9be2">grantPermissionCredential</a> (const <a href="/content/api/cpp/structgpudb_1_1GrantPermissionCredentialRequest">GrantPermissionCredentialRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1GrantPermissionCredentialResponse">GrantPermissionCredentialResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Grants a <a href="/content/security/sec_concepts/#security-concepts-permissions-credential">credential-level permission</a> to a user or role. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1GrantPermissionCredentialResponse">GrantPermissionCredentialResponse</a> </td>
        <td><a href="#ab57fd01de61ce3a433bee4e63061a605">grantPermissionCredential</a> (const std::string \&name, const std::string \&permission, const std::string \&credentialName, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Grants a <a href="/content/security/sec_concepts/#security-concepts-permissions-credential">credential-level permission</a> to a user or role. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1GrantPermissionCredentialResponse">GrantPermissionCredentialResponse</a> & </td>
        <td><a href="#a4c9725405ce5877be0f5150a4cd5a916">grantPermissionCredential</a> (const std::string \&name, const std::string \&permission, const std::string \&credentialName, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1GrantPermissionCredentialResponse">GrantPermissionCredentialResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Grants a <a href="/content/security/sec_concepts/#security-concepts-permissions-credential">credential-level permission</a> to a user or role. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1GrantPermissionDatasourceResponse">GrantPermissionDatasourceResponse</a> </td>
        <td><a href="#a5ea6ea4a2af4895f3acf2131ffe36c56">grantPermissionDatasource</a> (const <a href="/content/api/cpp/structgpudb_1_1GrantPermissionDatasourceRequest">GrantPermissionDatasourceRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Grants a <a href="/content/concepts/data_sources/">data source</a> permission to a user or role. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1GrantPermissionDatasourceResponse">GrantPermissionDatasourceResponse</a> & </td>
        <td><a href="#a427ec3b80a4def2161784aa9e7371b00">grantPermissionDatasource</a> (const <a href="/content/api/cpp/structgpudb_1_1GrantPermissionDatasourceRequest">GrantPermissionDatasourceRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1GrantPermissionDatasourceResponse">GrantPermissionDatasourceResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Grants a <a href="/content/concepts/data_sources/">data source</a> permission to a user or role. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1GrantPermissionDatasourceResponse">GrantPermissionDatasourceResponse</a> </td>
        <td><a href="#ab404e2c7c283594278c84d22832ccfaf">grantPermissionDatasource</a> (const std::string \&name, const std::string \&permission, const std::string \&datasourceName, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Grants a <a href="/content/concepts/data_sources/">data source</a> permission to a user or role. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1GrantPermissionDatasourceResponse">GrantPermissionDatasourceResponse</a> & </td>
        <td><a href="#a131e77dc89bc9cebcb915c8b04e873eb">grantPermissionDatasource</a> (const std::string \&name, const std::string \&permission, const std::string \&datasourceName, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1GrantPermissionDatasourceResponse">GrantPermissionDatasourceResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Grants a <a href="/content/concepts/data_sources/">data source</a> permission to a user or role. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1GrantPermissionDirectoryResponse">GrantPermissionDirectoryResponse</a> </td>
        <td><a href="#aa02d37420e163a262aa02ac482c0a2fa">grantPermissionDirectory</a> (const <a href="/content/api/cpp/structgpudb_1_1GrantPermissionDirectoryRequest">GrantPermissionDirectoryRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Grants a <a href="/content/tools/kifs/">KiFS</a> directory-level permission to a user or role. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1GrantPermissionDirectoryResponse">GrantPermissionDirectoryResponse</a> & </td>
        <td><a href="#ac66d25d1962e021bc7c0813f5d106c46">grantPermissionDirectory</a> (const <a href="/content/api/cpp/structgpudb_1_1GrantPermissionDirectoryRequest">GrantPermissionDirectoryRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1GrantPermissionDirectoryResponse">GrantPermissionDirectoryResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Grants a <a href="/content/tools/kifs/">KiFS</a> directory-level permission to a user or role. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1GrantPermissionDirectoryResponse">GrantPermissionDirectoryResponse</a> </td>
        <td><a href="#ab075f1bfb3d056cc09fc5fa0dac49ed1">grantPermissionDirectory</a> (const std::string \&name, const std::string \&permission, const std::string \&directoryName, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Grants a <a href="/content/tools/kifs/">KiFS</a> directory-level permission to a user or role. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1GrantPermissionDirectoryResponse">GrantPermissionDirectoryResponse</a> & </td>
        <td><a href="#a738b0c8ec727a4ca7c4e00e9146650d2">grantPermissionDirectory</a> (const std::string \&name, const std::string \&permission, const std::string \&directoryName, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1GrantPermissionDirectoryResponse">GrantPermissionDirectoryResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Grants a <a href="/content/tools/kifs/">KiFS</a> directory-level permission to a user or role. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1GrantPermissionProcResponse">GrantPermissionProcResponse</a> </td>
        <td><a href="#ae1cd6282f2b962d6546030ef18f93ff9">grantPermissionProc</a> (const <a href="/content/api/cpp/structgpudb_1_1GrantPermissionProcRequest">GrantPermissionProcRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Grants a proc-level permission to a user or role. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1GrantPermissionProcResponse">GrantPermissionProcResponse</a> & </td>
        <td><a href="#ab737c77492222b5ce08c7c956e5d340e">grantPermissionProc</a> (const <a href="/content/api/cpp/structgpudb_1_1GrantPermissionProcRequest">GrantPermissionProcRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1GrantPermissionProcResponse">GrantPermissionProcResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Grants a proc-level permission to a user or role. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1GrantPermissionProcResponse">GrantPermissionProcResponse</a> </td>
        <td><a href="#a39578835ce1484d4a150898a1774f62d">grantPermissionProc</a> (const std::string \&name, const std::string \&permission, const std::string \&procName, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Grants a proc-level permission to a user or role. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1GrantPermissionProcResponse">GrantPermissionProcResponse</a> & </td>
        <td><a href="#ae76c509220ba69f3f36732ec77c77199">grantPermissionProc</a> (const std::string \&name, const std::string \&permission, const std::string \&procName, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1GrantPermissionProcResponse">GrantPermissionProcResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Grants a proc-level permission to a user or role. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1GrantPermissionSystemResponse">GrantPermissionSystemResponse</a> </td>
        <td><a href="#ac369cb52634167b30ce05c0f3a16cc53">grantPermissionSystem</a> (const <a href="/content/api/cpp/structgpudb_1_1GrantPermissionSystemRequest">GrantPermissionSystemRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Grants a system-level permission to a user or role. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1GrantPermissionSystemResponse">GrantPermissionSystemResponse</a> & </td>
        <td><a href="#ad059fd03ac708e02b8e161c70b70b88d">grantPermissionSystem</a> (const <a href="/content/api/cpp/structgpudb_1_1GrantPermissionSystemRequest">GrantPermissionSystemRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1GrantPermissionSystemResponse">GrantPermissionSystemResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Grants a system-level permission to a user or role. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1GrantPermissionSystemResponse">GrantPermissionSystemResponse</a> </td>
        <td><a href="#a690cdf000db0679b6955d10585398b84">grantPermissionSystem</a> (const std::string \&name, const std::string \&permission, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Grants a system-level permission to a user or role. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1GrantPermissionSystemResponse">GrantPermissionSystemResponse</a> & </td>
        <td><a href="#a4f2521179ba1025d1df0a280a9303835">grantPermissionSystem</a> (const std::string \&name, const std::string \&permission, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1GrantPermissionSystemResponse">GrantPermissionSystemResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Grants a system-level permission to a user or role. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1GrantPermissionTableResponse">GrantPermissionTableResponse</a> </td>
        <td><a href="#a7645484bba3b9b9cf2d0549fa9ea4a5e">grantPermissionTable</a> (const <a href="/content/api/cpp/structgpudb_1_1GrantPermissionTableRequest">GrantPermissionTableRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Grants a table-level permission to a user or role. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1GrantPermissionTableResponse">GrantPermissionTableResponse</a> & </td>
        <td><a href="#a6ac61f85670e122b14f4bdc6de033563">grantPermissionTable</a> (const <a href="/content/api/cpp/structgpudb_1_1GrantPermissionTableRequest">GrantPermissionTableRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1GrantPermissionTableResponse">GrantPermissionTableResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Grants a table-level permission to a user or role. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1GrantPermissionTableResponse">GrantPermissionTableResponse</a> </td>
        <td><a href="#a316e6277ca48b863d066a315e6e19f01">grantPermissionTable</a> (const std::string \&name, const std::string \&permission, const std::string \&tableName, const std::string \&filterExpression, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Grants a table-level permission to a user or role. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1GrantPermissionTableResponse">GrantPermissionTableResponse</a> & </td>
        <td><a href="#ab41217b1f8c629a915e0df1913e3257d">grantPermissionTable</a> (const std::string \&name, const std::string \&permission, const std::string \&tableName, const std::string \&filterExpression, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1GrantPermissionTableResponse">GrantPermissionTableResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Grants a table-level permission to a user or role. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1GrantRoleResponse">GrantRoleResponse</a> </td>
        <td><a href="#ade2d2cdb909e06802487b2045858fc11">grantRole</a> (const <a href="/content/api/cpp/structgpudb_1_1GrantRoleRequest">GrantRoleRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Grants membership in a role to a user or role. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1GrantRoleResponse">GrantRoleResponse</a> & </td>
        <td><a href="#ae7f09ce61485841d9aafdb2d0152b61a">grantRole</a> (const <a href="/content/api/cpp/structgpudb_1_1GrantRoleRequest">GrantRoleRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1GrantRoleResponse">GrantRoleResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Grants membership in a role to a user or role. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1GrantRoleResponse">GrantRoleResponse</a> </td>
        <td><a href="#a9983e28ef620839a6f823682bd82d7d3">grantRole</a> (const std::string \&role, const std::string \&member, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Grants membership in a role to a user or role. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1GrantRoleResponse">GrantRoleResponse</a> & </td>
        <td><a href="#a6b2b87f37e939d37af459304a4ac2d22">grantRole</a> (const std::string \&role, const std::string \&member, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1GrantRoleResponse">GrantRoleResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Grants membership in a role to a user or role. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1HasPermissionResponse">HasPermissionResponse</a> </td>
        <td><a href="#ad740516d31f0ac8d62a590aa2878a277">hasPermission</a> (const <a href="/content/api/cpp/structgpudb_1_1HasPermissionRequest">HasPermissionRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Checks if the specified user has the specified permission on the specified object. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1HasPermissionResponse">HasPermissionResponse</a> & </td>
        <td><a href="#aebb61f251c3e6b98ba7e548e8a29d725">hasPermission</a> (const <a href="/content/api/cpp/structgpudb_1_1HasPermissionRequest">HasPermissionRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1HasPermissionResponse">HasPermissionResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Checks if the specified user has the specified permission on the specified object. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1HasPermissionResponse">HasPermissionResponse</a> </td>
        <td><a href="#a1b210b587020332f624a3f593b06cd59">hasPermission</a> (const std::string \&principal, const std::string \&object, const std::string \&objectType, const std::string \&permission, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Checks if the specified user has the specified permission on the specified object. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1HasPermissionResponse">HasPermissionResponse</a> & </td>
        <td><a href="#ad4b2f3ea35b07dc86431bb1483ead30b">hasPermission</a> (const std::string \&principal, const std::string \&object, const std::string \&objectType, const std::string \&permission, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1HasPermissionResponse">HasPermissionResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Checks if the specified user has the specified permission on the specified object. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1HasProcResponse">HasProcResponse</a> </td>
        <td><a href="#a8fca6e2965ad9a737ede2c6df0ea1684">hasProc</a> (const <a href="/content/api/cpp/structgpudb_1_1HasProcRequest">HasProcRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Checks the existence of a proc with the given name. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1HasProcResponse">HasProcResponse</a> & </td>
        <td><a href="#a9e6b482a289a859bdc661c0c23349f6c">hasProc</a> (const <a href="/content/api/cpp/structgpudb_1_1HasProcRequest">HasProcRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1HasProcResponse">HasProcResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Checks the existence of a proc with the given name. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1HasProcResponse">HasProcResponse</a> </td>
        <td><a href="#a438632111406c853d6210addab7c764c">hasProc</a> (const std::string \&procName, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Checks the existence of a proc with the given name. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1HasProcResponse">HasProcResponse</a> & </td>
        <td><a href="#a4d178d98d1c5209df924b6c6a459b2ad">hasProc</a> (const std::string \&procName, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1HasProcResponse">HasProcResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Checks the existence of a proc with the given name. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1HasRoleResponse">HasRoleResponse</a> </td>
        <td><a href="#a9de0d2bb24bdfa17ea915c8c29ab9f06">hasRole</a> (const <a href="/content/api/cpp/structgpudb_1_1HasRoleRequest">HasRoleRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Checks if the specified user has the specified role. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1HasRoleResponse">HasRoleResponse</a> & </td>
        <td><a href="#a5b8c49a68512e098f534b4ad4345080e">hasRole</a> (const <a href="/content/api/cpp/structgpudb_1_1HasRoleRequest">HasRoleRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1HasRoleResponse">HasRoleResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Checks if the specified user has the specified role. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1HasRoleResponse">HasRoleResponse</a> </td>
        <td><a href="#ac09bb999e6f1d7e839949498beb2a0d7">hasRole</a> (const std::string \&principal, const std::string \&role, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Checks if the specified user has the specified role. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1HasRoleResponse">HasRoleResponse</a> & </td>
        <td><a href="#a11a614337a040e473f85b6dbd9b03cc2">hasRole</a> (const std::string \&principal, const std::string \&role, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1HasRoleResponse">HasRoleResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Checks if the specified user has the specified role. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1HasSchemaResponse">HasSchemaResponse</a> </td>
        <td><a href="#ad9239208a2646cbf0b1bd9bf4e1a0d50">hasSchema</a> (const <a href="/content/api/cpp/structgpudb_1_1HasSchemaRequest">HasSchemaRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Checks for the existence of a schema with the given name. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1HasSchemaResponse">HasSchemaResponse</a> & </td>
        <td><a href="#a52f028efcf36a5a95a9414f7f9fb7edc">hasSchema</a> (const <a href="/content/api/cpp/structgpudb_1_1HasSchemaRequest">HasSchemaRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1HasSchemaResponse">HasSchemaResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Checks for the existence of a schema with the given name. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1HasSchemaResponse">HasSchemaResponse</a> </td>
        <td><a href="#aca31db2984272fe8c75bfdde4f40cd0c">hasSchema</a> (const std::string \&schemaName, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Checks for the existence of a schema with the given name. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1HasSchemaResponse">HasSchemaResponse</a> & </td>
        <td><a href="#a691e59e90b1fa45c6611a48eab718be4">hasSchema</a> (const std::string \&schemaName, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1HasSchemaResponse">HasSchemaResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Checks for the existence of a schema with the given name. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1HasTableResponse">HasTableResponse</a> </td>
        <td><a href="#acba046e591d5e9cdb71dcc296a1a6587">hasTable</a> (const <a href="/content/api/cpp/structgpudb_1_1HasTableRequest">HasTableRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Checks for the existence of a table with the given name. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1HasTableResponse">HasTableResponse</a> & </td>
        <td><a href="#a4b9843b0949f80e4cbc339c926a9e7e9">hasTable</a> (const <a href="/content/api/cpp/structgpudb_1_1HasTableRequest">HasTableRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1HasTableResponse">HasTableResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Checks for the existence of a table with the given name. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1HasTableResponse">HasTableResponse</a> </td>
        <td><a href="#aac084e60db02e0e37e5070f8ff50d606">hasTable</a> (const std::string \&tableName, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Checks for the existence of a table with the given name. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1HasTableResponse">HasTableResponse</a> & </td>
        <td><a href="#a819aae2b606944d8b4aff38b4093e734">hasTable</a> (const std::string \&tableName, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1HasTableResponse">HasTableResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Checks for the existence of a table with the given name. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1HasTypeResponse">HasTypeResponse</a> </td>
        <td><a href="#a70f01970c1caaccd6cf17b208a980b50">hasType</a> (const <a href="/content/api/cpp/structgpudb_1_1HasTypeRequest">HasTypeRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Check for the existence of a type. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1HasTypeResponse">HasTypeResponse</a> & </td>
        <td><a href="#aded925491b917a966762252dabd03fd8">hasType</a> (const <a href="/content/api/cpp/structgpudb_1_1HasTypeRequest">HasTypeRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1HasTypeResponse">HasTypeResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Check for the existence of a type. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1HasTypeResponse">HasTypeResponse</a> </td>
        <td><a href="#a5bd2c473cda48e8ad94645326db866d1">hasType</a> (const std::string \&typeId, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Check for the existence of a type. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1HasTypeResponse">HasTypeResponse</a> & </td>
        <td><a href="#ab0b6cc8af193558e4b3ca0c3fa5ed78d">hasType</a> (const std::string \&typeId, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1HasTypeResponse">HasTypeResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Check for the existence of a type. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1InsertRecordsResponse">InsertRecordsResponse</a> </td>
        <td><a href="#a1ec81d92f949358379266d42ae12bae7">insertRecordsRaw</a> (const <a href="/content/api/cpp/structgpudb_1_1RawInsertRecordsRequest">RawInsertRecordsRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Adds multiple records to the specified table. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1InsertRecordsResponse">InsertRecordsResponse</a> & </td>
        <td><a href="#a9cd9f31f32e8aeacb99efecd5c23ffe7">insertRecordsRaw</a> (const <a href="/content/api/cpp/structgpudb_1_1RawInsertRecordsRequest">RawInsertRecordsRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1InsertRecordsResponse">InsertRecordsResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Adds multiple records to the specified table. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>template\<typename TRequest> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1InsertRecordsResponse">InsertRecordsResponse</a> </td>
        <td><a href="#ab6ab327611452cc777c159d202146997">insertRecords</a> (const <a href="/content/api/cpp/structgpudb_1_1InsertRecordsRequest">InsertRecordsRequest</a>\< TRequest > \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Adds multiple records to the specified table. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>template\<typename TRequest> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1InsertRecordsResponse">InsertRecordsResponse</a> & </td>
        <td><a href="#ac584d020987d1dbfa77b1bf6f32e8ebf">insertRecords</a> (const <a href="/content/api/cpp/structgpudb_1_1InsertRecordsRequest">InsertRecordsRequest</a>\< TRequest > \&request\_, <a href="/content/api/cpp/structgpudb_1_1InsertRecordsResponse">InsertRecordsResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Adds multiple records to the specified table. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>template\<typename TRequest> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1InsertRecordsResponse">InsertRecordsResponse</a> </td>
        <td><a href="#a1cbbfefa7a3d6b4570f1be6734a8d849">insertRecords</a> (const std::string \&tableName, const std::vector\< TRequest > \&data, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Adds multiple records to the specified table. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>template\<typename TRequest> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1InsertRecordsResponse">InsertRecordsResponse</a> & </td>
        <td><a href="#a19ca29162fd0ce0fe1993ff791bcca4f">insertRecords</a> (const std::string \&tableName, const std::vector\< TRequest > \&data, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1InsertRecordsResponse">InsertRecordsResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Adds multiple records to the specified table. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1InsertRecordsFromFilesResponse">InsertRecordsFromFilesResponse</a> </td>
        <td><a href="#a03fd9d3a6a56088c1ce707c642c9c736">insertRecordsFromFiles</a> (const <a href="/content/api/cpp/structgpudb_1_1InsertRecordsFromFilesRequest">InsertRecordsFromFilesRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Reads from one or more files and inserts the data into a new or existing table. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1InsertRecordsFromFilesResponse">InsertRecordsFromFilesResponse</a> & </td>
        <td><a href="#a3a8b0729508c7543c177436086334564">insertRecordsFromFiles</a> (const <a href="/content/api/cpp/structgpudb_1_1InsertRecordsFromFilesRequest">InsertRecordsFromFilesRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1InsertRecordsFromFilesResponse">InsertRecordsFromFilesResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Reads from one or more files and inserts the data into a new or existing table. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1InsertRecordsFromFilesResponse">InsertRecordsFromFilesResponse</a> </td>
        <td><a href="#a2a25d6161cbe8ecaa88bed607c04821b">insertRecordsFromFiles</a> (const std::string \&tableName, const std::vector\< std::string > \&filepaths, const std::map\< std::string, std::map\< std::string, std::string > > \&modifyColumns, const std::map\< std::string, std::string > \&createTableOptions, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Reads from one or more files and inserts the data into a new or existing table. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1InsertRecordsFromFilesResponse">InsertRecordsFromFilesResponse</a> & </td>
        <td><a href="#a8c0483195731de927d1628c231b421bf">insertRecordsFromFiles</a> (const std::string \&tableName, const std::vector\< std::string > \&filepaths, const std::map\< std::string, std::map\< std::string, std::string > > \&modifyColumns, const std::map\< std::string, std::string > \&createTableOptions, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1InsertRecordsFromFilesResponse">InsertRecordsFromFilesResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Reads from one or more files and inserts the data into a new or existing table. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1InsertRecordsFromPayloadResponse">InsertRecordsFromPayloadResponse</a> </td>
        <td><a href="#ac9ee5faa5ba7081d8c73e9d6526bde98">insertRecordsFromPayload</a> (const <a href="/content/api/cpp/structgpudb_1_1InsertRecordsFromPayloadRequest">InsertRecordsFromPayloadRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Reads from the given text-based or binary payload and inserts the data into a new or existing table. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1InsertRecordsFromPayloadResponse">InsertRecordsFromPayloadResponse</a> & </td>
        <td><a href="#a902abba0f676da7c34c3c5c3683ba37d">insertRecordsFromPayload</a> (const <a href="/content/api/cpp/structgpudb_1_1InsertRecordsFromPayloadRequest">InsertRecordsFromPayloadRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1InsertRecordsFromPayloadResponse">InsertRecordsFromPayloadResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Reads from the given text-based or binary payload and inserts the data into a new or existing table. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1InsertRecordsFromPayloadResponse">InsertRecordsFromPayloadResponse</a> </td>
        <td><a href="#adeb45ef2ffbd245618c1e8a23dfa2405">insertRecordsFromPayload</a> (const std::string \&tableName, const std::string \&dataText, const std::vector\< uint8\_t > \&dataBytes, const std::map\< std::string, std::map\< std::string, std::string > > \&modifyColumns, const std::map\< std::string, std::string > \&createTableOptions, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Reads from the given text-based or binary payload and inserts the data into a new or existing table. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1InsertRecordsFromPayloadResponse">InsertRecordsFromPayloadResponse</a> & </td>
        <td><a href="#a5857ec840451085103cec9ed3f96ea0c">insertRecordsFromPayload</a> (const std::string \&tableName, const std::string \&dataText, const std::vector\< uint8\_t > \&dataBytes, const std::map\< std::string, std::map\< std::string, std::string > > \&modifyColumns, const std::map\< std::string, std::string > \&createTableOptions, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1InsertRecordsFromPayloadResponse">InsertRecordsFromPayloadResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Reads from the given text-based or binary payload and inserts the data into a new or existing table. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1InsertRecordsFromQueryResponse">InsertRecordsFromQueryResponse</a> </td>
        <td><a href="#ab280346cc3e31d912f8becba8ddce40b">insertRecordsFromQuery</a> (const <a href="/content/api/cpp/structgpudb_1_1InsertRecordsFromQueryRequest">InsertRecordsFromQueryRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Computes remote query result and inserts the result data into a new or existing table. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1InsertRecordsFromQueryResponse">InsertRecordsFromQueryResponse</a> & </td>
        <td><a href="#aa2adafc8b425e0d820a624bef97140b9">insertRecordsFromQuery</a> (const <a href="/content/api/cpp/structgpudb_1_1InsertRecordsFromQueryRequest">InsertRecordsFromQueryRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1InsertRecordsFromQueryResponse">InsertRecordsFromQueryResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Computes remote query result and inserts the result data into a new or existing table. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1InsertRecordsFromQueryResponse">InsertRecordsFromQueryResponse</a> </td>
        <td><a href="#a489ffdaaa10e9059eaf4ff23cfd7e123">insertRecordsFromQuery</a> (const std::string \&tableName, const std::string \&remoteQuery, const std::map\< std::string, std::map\< std::string, std::string > > \&modifyColumns, const std::map\< std::string, std::string > \&createTableOptions, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Computes remote query result and inserts the result data into a new or existing table. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1InsertRecordsFromQueryResponse">InsertRecordsFromQueryResponse</a> & </td>
        <td><a href="#a5f9ff3451e098f6e68a11ddc4ddcfe7b">insertRecordsFromQuery</a> (const std::string \&tableName, const std::string \&remoteQuery, const std::map\< std::string, std::map\< std::string, std::string > > \&modifyColumns, const std::map\< std::string, std::string > \&createTableOptions, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1InsertRecordsFromQueryResponse">InsertRecordsFromQueryResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Computes remote query result and inserts the result data into a new or existing table. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1InsertRecordsRandomResponse">InsertRecordsRandomResponse</a> </td>
        <td><a href="#a5609aacb2f2c2a35c82db9f69747404a">insertRecordsRandom</a> (const <a href="/content/api/cpp/structgpudb_1_1InsertRecordsRandomRequest">InsertRecordsRandomRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Generates a specified number of random records and adds them to the given table. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1InsertRecordsRandomResponse">InsertRecordsRandomResponse</a> & </td>
        <td><a href="#a2731d20cecb1dc84074c01cd45ddb7a9">insertRecordsRandom</a> (const <a href="/content/api/cpp/structgpudb_1_1InsertRecordsRandomRequest">InsertRecordsRandomRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1InsertRecordsRandomResponse">InsertRecordsRandomResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Generates a specified number of random records and adds them to the given table. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1InsertRecordsRandomResponse">InsertRecordsRandomResponse</a> </td>
        <td><a href="#a88ab670876d6ac282d90baeb96478956">insertRecordsRandom</a> (const std::string \&tableName, const int64\_t count, const std::map\< std::string, std::map\< std::string, double > > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Generates a specified number of random records and adds them to the given table. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1InsertRecordsRandomResponse">InsertRecordsRandomResponse</a> & </td>
        <td><a href="#af2dfe3668aed5e4912b1f8feba700c37">insertRecordsRandom</a> (const std::string \&tableName, const int64\_t count, const std::map\< std::string, std::map\< std::string, double > > \&options, <a href="/content/api/cpp/structgpudb_1_1InsertRecordsRandomResponse">InsertRecordsRandomResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Generates a specified number of random records and adds them to the given table. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1InsertSymbolResponse">InsertSymbolResponse</a> </td>
        <td><a href="#a33ff57e8504882376321fa9a5537fedf">insertSymbol</a> (const <a href="/content/api/cpp/structgpudb_1_1InsertSymbolRequest">InsertSymbolRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Adds a symbol or icon (i.e. an image) to represent data points when data is rendered visually. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1InsertSymbolResponse">InsertSymbolResponse</a> & </td>
        <td><a href="#a859126a4b037a7689ae7b7a2ac742129">insertSymbol</a> (const <a href="/content/api/cpp/structgpudb_1_1InsertSymbolRequest">InsertSymbolRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1InsertSymbolResponse">InsertSymbolResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Adds a symbol or icon (i.e. an image) to represent data points when data is rendered visually. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1InsertSymbolResponse">InsertSymbolResponse</a> </td>
        <td><a href="#a15ce82e07d56b203892660f07d65c610">insertSymbol</a> (const std::string \&symbolId, const std::string \&symbolFormat, const std::vector\< uint8\_t > \&symbolData, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Adds a symbol or icon (i.e. an image) to represent data points when data is rendered visually. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1InsertSymbolResponse">InsertSymbolResponse</a> & </td>
        <td><a href="#aad297dd0e66db2d92e3a213b989a0040">insertSymbol</a> (const std::string \&symbolId, const std::string \&symbolFormat, const std::vector\< uint8\_t > \&symbolData, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1InsertSymbolResponse">InsertSymbolResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Adds a symbol or icon (i.e. an image) to represent data points when data is rendered visually. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1KillProcResponse">KillProcResponse</a> </td>
        <td><a href="#ac8fff6e61ada09d2fdb3bb336ccc321a">killProc</a> (const <a href="/content/api/cpp/structgpudb_1_1KillProcRequest">KillProcRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Kills a running proc instance. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1KillProcResponse">KillProcResponse</a> & </td>
        <td><a href="#a0ad300665d452250337bcac23674ca8c">killProc</a> (const <a href="/content/api/cpp/structgpudb_1_1KillProcRequest">KillProcRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1KillProcResponse">KillProcResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Kills a running proc instance. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1KillProcResponse">KillProcResponse</a> </td>
        <td><a href="#a8272ee33e4bfe2ef6c5d225a7f151ada">killProc</a> (const std::string \&runId, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Kills a running proc instance. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1KillProcResponse">KillProcResponse</a> & </td>
        <td><a href="#aa634787e5186e9266ac859a2ac344fcc">killProc</a> (const std::string \&runId, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1KillProcResponse">KillProcResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Kills a running proc instance. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1LockTableResponse">LockTableResponse</a> </td>
        <td><a href="#ae6ac44ea2b9603bbad231212560ab451">lockTable</a> (const <a href="/content/api/cpp/structgpudb_1_1LockTableRequest">LockTableRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Manages global access to a table's data. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1LockTableResponse">LockTableResponse</a> & </td>
        <td><a href="#a6f2620490cc2084a66dcfdad2ab3f65d">lockTable</a> (const <a href="/content/api/cpp/structgpudb_1_1LockTableRequest">LockTableRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1LockTableResponse">LockTableResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Manages global access to a table's data. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1LockTableResponse">LockTableResponse</a> </td>
        <td><a href="#a52f7405279172f1207c78fc5dae5b7ba">lockTable</a> (const std::string \&tableName, const std::string \&lockType, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Manages global access to a table's data. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1LockTableResponse">LockTableResponse</a> & </td>
        <td><a href="#a91fbe8cf1b51394ad50fa063020d9e5a">lockTable</a> (const std::string \&tableName, const std::string \&lockType, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1LockTableResponse">LockTableResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Manages global access to a table's data. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1MatchGraphResponse">MatchGraphResponse</a> </td>
        <td><a href="#aa906b4367c2f812aabd089ad7d0d8f3b">matchGraph</a> (const <a href="/content/api/cpp/structgpudb_1_1MatchGraphRequest">MatchGraphRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Matches a directed route implied by a given set of latitude/longitude points to an existing underlying road network graph using a given solution type. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1MatchGraphResponse">MatchGraphResponse</a> & </td>
        <td><a href="#ab7861deefa995b131fb4c5d093a7826d">matchGraph</a> (const <a href="/content/api/cpp/structgpudb_1_1MatchGraphRequest">MatchGraphRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1MatchGraphResponse">MatchGraphResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Matches a directed route implied by a given set of latitude/longitude points to an existing underlying road network graph using a given solution type. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1MatchGraphResponse">MatchGraphResponse</a> </td>
        <td><a href="#a4096961ee9d30e9c523568a5c238c379">matchGraph</a> (const std::string \&graphName, const std::vector\< std::string > \&samplePoints, const std::string \&solveMethod, const std::string \&solutionTable, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Matches a directed route implied by a given set of latitude/longitude points to an existing underlying road network graph using a given solution type. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1MatchGraphResponse">MatchGraphResponse</a> & </td>
        <td><a href="#aeb993c1264ec7a5f42202f699a978a95">matchGraph</a> (const std::string \&graphName, const std::vector\< std::string > \&samplePoints, const std::string \&solveMethod, const std::string \&solutionTable, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1MatchGraphResponse">MatchGraphResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Matches a directed route implied by a given set of latitude/longitude points to an existing underlying road network graph using a given solution type. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ModifyGraphResponse">ModifyGraphResponse</a> </td>
        <td><a href="#a912d185d316a02e1b1cb366ef352fbcf">modifyGraph</a> (const <a href="/content/api/cpp/structgpudb_1_1ModifyGraphRequest">ModifyGraphRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Update an existing graph network using given nodes, edges, weights, restrictions, and options. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ModifyGraphResponse">ModifyGraphResponse</a> & </td>
        <td><a href="#ae4cb6f77f809e3e948ea5dd1fc1edb3d">modifyGraph</a> (const <a href="/content/api/cpp/structgpudb_1_1ModifyGraphRequest">ModifyGraphRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1ModifyGraphResponse">ModifyGraphResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Update an existing graph network using given nodes, edges, weights, restrictions, and options. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ModifyGraphResponse">ModifyGraphResponse</a> </td>
        <td><a href="#afab27a20c1d067dff08ca9bd9c8bedf0">modifyGraph</a> (const std::string \&graphName, const std::vector\< std::string > \&nodes, const std::vector\< std::string > \&edges, const std::vector\< std::string > \&weights, const std::vector\< std::string > \&restrictions, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Update an existing graph network using given nodes, edges, weights, restrictions, and options. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ModifyGraphResponse">ModifyGraphResponse</a> & </td>
        <td><a href="#a174058fcfbf79c498610ab1d5efa3e76">modifyGraph</a> (const std::string \&graphName, const std::vector\< std::string > \&nodes, const std::vector\< std::string > \&edges, const std::vector\< std::string > \&weights, const std::vector\< std::string > \&restrictions, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1ModifyGraphResponse">ModifyGraphResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Update an existing graph network using given nodes, edges, weights, restrictions, and options. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1QueryGraphResponse">QueryGraphResponse</a> </td>
        <td><a href="#aa19b2032dbef0fd308b55202fcb738fa">queryGraph</a> (const <a href="/content/api/cpp/structgpudb_1_1QueryGraphRequest">QueryGraphRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Employs a topological query on a graph generated a-priori by <a href="#a4055b3b0cd047d5c78f8ab61350e1c4e">createGraph</a> and returns a list of adjacent edge(s) or node(s), also known as an adjacency list, depending on what's been provided to the endpoint; providing edges will return nodes and providing nodes will return edges. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1QueryGraphResponse">QueryGraphResponse</a> & </td>
        <td><a href="#a08bbe4ff8674e31412e17280c1bc783e">queryGraph</a> (const <a href="/content/api/cpp/structgpudb_1_1QueryGraphRequest">QueryGraphRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1QueryGraphResponse">QueryGraphResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Employs a topological query on a graph generated a-priori by <a href="#a4055b3b0cd047d5c78f8ab61350e1c4e">createGraph</a> and returns a list of adjacent edge(s) or node(s), also known as an adjacency list, depending on what's been provided to the endpoint; providing edges will return nodes and providing nodes will return edges. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1QueryGraphResponse">QueryGraphResponse</a> </td>
        <td><a href="#adc39e9e087081da5e5da059ccf682b34">queryGraph</a> (const std::string \&graphName, const std::vector\< std::string > \&queries, const std::vector\< std::string > \&restrictions, const std::string \&adjacencyTable, const int32\_t rings, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Employs a topological query on a graph generated a-priori by <a href="#a025f78582e1d24c590888a3d29e19f36">createGraph</a> and returns a list of adjacent edge(s) or node(s), also known as an adjacency list, depending on what's been provided to the endpoint; providing edges will return nodes and providing nodes will return edges. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1QueryGraphResponse">QueryGraphResponse</a> & </td>
        <td><a href="#a32d2c3902b783544cd574005eb34d075">queryGraph</a> (const std::string \&graphName, const std::vector\< std::string > \&queries, const std::vector\< std::string > \&restrictions, const std::string \&adjacencyTable, const int32\_t rings, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1QueryGraphResponse">QueryGraphResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Employs a topological query on a graph generated a-priori by <a href="#a025f78582e1d24c590888a3d29e19f36">createGraph</a> and returns a list of adjacent edge(s) or node(s), also known as an adjacency list, depending on what's been provided to the endpoint; providing edges will return nodes and providing nodes will return edges. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1RepartitionGraphResponse">RepartitionGraphResponse</a> </td>
        <td><a href="#ae8df406ae2ed789bb8763e5a94201b23">repartitionGraph</a> (const <a href="/content/api/cpp/structgpudb_1_1RepartitionGraphRequest">RepartitionGraphRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Rebalances an existing partitioned graph. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1RepartitionGraphResponse">RepartitionGraphResponse</a> & </td>
        <td><a href="#a61ad24358df749999a45542d99b11187">repartitionGraph</a> (const <a href="/content/api/cpp/structgpudb_1_1RepartitionGraphRequest">RepartitionGraphRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1RepartitionGraphResponse">RepartitionGraphResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Rebalances an existing partitioned graph. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1RepartitionGraphResponse">RepartitionGraphResponse</a> </td>
        <td><a href="#a441d50b3d621b8fa90607390992ee41b">repartitionGraph</a> (const std::string \&graphName, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Rebalances an existing partitioned graph. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1RepartitionGraphResponse">RepartitionGraphResponse</a> & </td>
        <td><a href="#a042f7cdf1d63a33582b06e74b03fbb89">repartitionGraph</a> (const std::string \&graphName, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1RepartitionGraphResponse">RepartitionGraphResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Rebalances an existing partitioned graph. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1RestoreBackupResponse">RestoreBackupResponse</a> </td>
        <td><a href="#ab84fbe6421108eedd42326a8fa9b3555">restoreBackup</a> (const <a href="/content/api/cpp/structgpudb_1_1RestoreBackupRequest">RestoreBackupRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Restores database objects from a <a href="/content/admin/backup_restore/#database-backup">backup</a> accessible via the <a href="/content/concepts/data_sources/">data source</a> specified by <a href="/content/api/cpp/structgpudb_1_1RestoreBackupRequest#a0be8cf0e9ceb5b55867028aea9500254">datasourceName</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1RestoreBackupResponse">RestoreBackupResponse</a> & </td>
        <td><a href="#a8beb2661d0dbc7ac6f449c13531673ab">restoreBackup</a> (const <a href="/content/api/cpp/structgpudb_1_1RestoreBackupRequest">RestoreBackupRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1RestoreBackupResponse">RestoreBackupResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Restores database objects from a <a href="/content/admin/backup_restore/#database-backup">backup</a> accessible via the <a href="/content/concepts/data_sources/">data source</a> specified by <a href="/content/api/cpp/structgpudb_1_1RestoreBackupRequest#a0be8cf0e9ceb5b55867028aea9500254">datasourceName</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1RestoreBackupResponse">RestoreBackupResponse</a> </td>
        <td><a href="#af9ffdf8b1766b6d85e3c436e616efc39">restoreBackup</a> (const std::string \&backupName, const std::map\< std::string, std::string > \&restoreObjectsMap, const std::string \&datasourceName, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Restores database objects from a <a href="/content/admin/backup_restore/#database-backup">backup</a> accessible via the <a href="/content/concepts/data_sources/">data source</a> specified by <span>datasourceName</span>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1RestoreBackupResponse">RestoreBackupResponse</a> & </td>
        <td><a href="#a621e2c752c1a5a1efdd550ac44bb159d">restoreBackup</a> (const std::string \&backupName, const std::map\< std::string, std::string > \&restoreObjectsMap, const std::string \&datasourceName, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1RestoreBackupResponse">RestoreBackupResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Restores database objects from a <a href="/content/admin/backup_restore/#database-backup">backup</a> accessible via the <a href="/content/concepts/data_sources/">data source</a> specified by <span>datasourceName</span>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1RevokePermissionResponse">RevokePermissionResponse</a> </td>
        <td><a href="#a23100aed98b997cef0abdae25f01a1d3">revokePermission</a> (const <a href="/content/api/cpp/structgpudb_1_1RevokePermissionRequest">RevokePermissionRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Revoke user or role the specified permission on the specified object. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1RevokePermissionResponse">RevokePermissionResponse</a> & </td>
        <td><a href="#a65316a4b8982cbe6423eb35ac39afb0e">revokePermission</a> (const <a href="/content/api/cpp/structgpudb_1_1RevokePermissionRequest">RevokePermissionRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1RevokePermissionResponse">RevokePermissionResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Revoke user or role the specified permission on the specified object. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1RevokePermissionResponse">RevokePermissionResponse</a> </td>
        <td><a href="#a55a1f3f0e5c95eb77a49e34b51ac9f09">revokePermission</a> (const std::string \&principal, const std::string \&object, const std::string \&objectType, const std::string \&permission, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Revoke user or role the specified permission on the specified object. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1RevokePermissionResponse">RevokePermissionResponse</a> & </td>
        <td><a href="#a058430d085cdaf8a5f29451bd31a0daf">revokePermission</a> (const std::string \&principal, const std::string \&object, const std::string \&objectType, const std::string \&permission, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1RevokePermissionResponse">RevokePermissionResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Revoke user or role the specified permission on the specified object. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1RevokePermissionCredentialResponse">RevokePermissionCredentialResponse</a> </td>
        <td><a href="#aa30344583dbc85d2c410b4b0051afad8">revokePermissionCredential</a> (const <a href="/content/api/cpp/structgpudb_1_1RevokePermissionCredentialRequest">RevokePermissionCredentialRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Revokes a <a href="/content/security/sec_concepts/#security-concepts-permissions-credential">credential-level permission</a> from a user or role. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1RevokePermissionCredentialResponse">RevokePermissionCredentialResponse</a> & </td>
        <td><a href="#af8a7c2d2e9fc43a3e5c340dab974c808">revokePermissionCredential</a> (const <a href="/content/api/cpp/structgpudb_1_1RevokePermissionCredentialRequest">RevokePermissionCredentialRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1RevokePermissionCredentialResponse">RevokePermissionCredentialResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Revokes a <a href="/content/security/sec_concepts/#security-concepts-permissions-credential">credential-level permission</a> from a user or role. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1RevokePermissionCredentialResponse">RevokePermissionCredentialResponse</a> </td>
        <td><a href="#afd28eb5a078e910ab075f8883527cd4d">revokePermissionCredential</a> (const std::string \&name, const std::string \&permission, const std::string \&credentialName, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Revokes a <a href="/content/security/sec_concepts/#security-concepts-permissions-credential">credential-level permission</a> from a user or role. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1RevokePermissionCredentialResponse">RevokePermissionCredentialResponse</a> & </td>
        <td><a href="#a06a757e504e5c3b3c454d92e794555ab">revokePermissionCredential</a> (const std::string \&name, const std::string \&permission, const std::string \&credentialName, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1RevokePermissionCredentialResponse">RevokePermissionCredentialResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Revokes a <a href="/content/security/sec_concepts/#security-concepts-permissions-credential">credential-level permission</a> from a user or role. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1RevokePermissionDatasourceResponse">RevokePermissionDatasourceResponse</a> </td>
        <td><a href="#a3d3fa1335f761ab3e7474e419aa3b6ee">revokePermissionDatasource</a> (const <a href="/content/api/cpp/structgpudb_1_1RevokePermissionDatasourceRequest">RevokePermissionDatasourceRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Revokes a <a href="/content/concepts/data_sources/">data source</a> permission from a user or role. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1RevokePermissionDatasourceResponse">RevokePermissionDatasourceResponse</a> & </td>
        <td><a href="#aca4dc8e22f74db9c59583d273bf95767">revokePermissionDatasource</a> (const <a href="/content/api/cpp/structgpudb_1_1RevokePermissionDatasourceRequest">RevokePermissionDatasourceRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1RevokePermissionDatasourceResponse">RevokePermissionDatasourceResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Revokes a <a href="/content/concepts/data_sources/">data source</a> permission from a user or role. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1RevokePermissionDatasourceResponse">RevokePermissionDatasourceResponse</a> </td>
        <td><a href="#abeb672e878e60f305a3ad973ea088914">revokePermissionDatasource</a> (const std::string \&name, const std::string \&permission, const std::string \&datasourceName, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Revokes a <a href="/content/concepts/data_sources/">data source</a> permission from a user or role. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1RevokePermissionDatasourceResponse">RevokePermissionDatasourceResponse</a> & </td>
        <td><a href="#a03c35a898ab1a5b1a89f26c9e6422d16">revokePermissionDatasource</a> (const std::string \&name, const std::string \&permission, const std::string \&datasourceName, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1RevokePermissionDatasourceResponse">RevokePermissionDatasourceResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Revokes a <a href="/content/concepts/data_sources/">data source</a> permission from a user or role. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1RevokePermissionDirectoryResponse">RevokePermissionDirectoryResponse</a> </td>
        <td><a href="#a5f793acdd5d6c5214db0c5e0aef29465">revokePermissionDirectory</a> (const <a href="/content/api/cpp/structgpudb_1_1RevokePermissionDirectoryRequest">RevokePermissionDirectoryRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Revokes a <a href="/content/tools/kifs/">KiFS</a> directory-level permission from a user or role. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1RevokePermissionDirectoryResponse">RevokePermissionDirectoryResponse</a> & </td>
        <td><a href="#a0bee5fd68f799452bac2a6b33e90d9af">revokePermissionDirectory</a> (const <a href="/content/api/cpp/structgpudb_1_1RevokePermissionDirectoryRequest">RevokePermissionDirectoryRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1RevokePermissionDirectoryResponse">RevokePermissionDirectoryResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Revokes a <a href="/content/tools/kifs/">KiFS</a> directory-level permission from a user or role. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1RevokePermissionDirectoryResponse">RevokePermissionDirectoryResponse</a> </td>
        <td><a href="#a19033c11cbb4b0e8e54d058b12c31dd3">revokePermissionDirectory</a> (const std::string \&name, const std::string \&permission, const std::string \&directoryName, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Revokes a <a href="/content/tools/kifs/">KiFS</a> directory-level permission from a user or role. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1RevokePermissionDirectoryResponse">RevokePermissionDirectoryResponse</a> & </td>
        <td><a href="#a06ecd2c905e1c4bab33ae360b6f070e1">revokePermissionDirectory</a> (const std::string \&name, const std::string \&permission, const std::string \&directoryName, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1RevokePermissionDirectoryResponse">RevokePermissionDirectoryResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Revokes a <a href="/content/tools/kifs/">KiFS</a> directory-level permission from a user or role. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1RevokePermissionProcResponse">RevokePermissionProcResponse</a> </td>
        <td><a href="#ac9da5fcbd5d8573eeb08c5638e62f73e">revokePermissionProc</a> (const <a href="/content/api/cpp/structgpudb_1_1RevokePermissionProcRequest">RevokePermissionProcRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Revokes a proc-level permission from a user or role. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1RevokePermissionProcResponse">RevokePermissionProcResponse</a> & </td>
        <td><a href="#a668adb81005a2404b184ccd7dcafae74">revokePermissionProc</a> (const <a href="/content/api/cpp/structgpudb_1_1RevokePermissionProcRequest">RevokePermissionProcRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1RevokePermissionProcResponse">RevokePermissionProcResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Revokes a proc-level permission from a user or role. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1RevokePermissionProcResponse">RevokePermissionProcResponse</a> </td>
        <td><a href="#a5cc3a06a6c54954a679dc234d20da3a2">revokePermissionProc</a> (const std::string \&name, const std::string \&permission, const std::string \&procName, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Revokes a proc-level permission from a user or role. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1RevokePermissionProcResponse">RevokePermissionProcResponse</a> & </td>
        <td><a href="#a21a9fb07c479f6bae03c991d16bd0253">revokePermissionProc</a> (const std::string \&name, const std::string \&permission, const std::string \&procName, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1RevokePermissionProcResponse">RevokePermissionProcResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Revokes a proc-level permission from a user or role. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1RevokePermissionSystemResponse">RevokePermissionSystemResponse</a> </td>
        <td><a href="#ad20db437d84c13c2ba812cb71b95d13f">revokePermissionSystem</a> (const <a href="/content/api/cpp/structgpudb_1_1RevokePermissionSystemRequest">RevokePermissionSystemRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Revokes a system-level permission from a user or role. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1RevokePermissionSystemResponse">RevokePermissionSystemResponse</a> & </td>
        <td><a href="#a3dae6f3c45ae998d48272c02fca55c05">revokePermissionSystem</a> (const <a href="/content/api/cpp/structgpudb_1_1RevokePermissionSystemRequest">RevokePermissionSystemRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1RevokePermissionSystemResponse">RevokePermissionSystemResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Revokes a system-level permission from a user or role. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1RevokePermissionSystemResponse">RevokePermissionSystemResponse</a> </td>
        <td><a href="#aeb38f6305ef46f6bb65ef2cc3d190d3c">revokePermissionSystem</a> (const std::string \&name, const std::string \&permission, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Revokes a system-level permission from a user or role. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1RevokePermissionSystemResponse">RevokePermissionSystemResponse</a> & </td>
        <td><a href="#a3c8f1d2213e21c184f7bfc88792cf89e">revokePermissionSystem</a> (const std::string \&name, const std::string \&permission, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1RevokePermissionSystemResponse">RevokePermissionSystemResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Revokes a system-level permission from a user or role. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1RevokePermissionTableResponse">RevokePermissionTableResponse</a> </td>
        <td><a href="#abaf044cc15bfdb39af48c3c7d838d4e6">revokePermissionTable</a> (const <a href="/content/api/cpp/structgpudb_1_1RevokePermissionTableRequest">RevokePermissionTableRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Revokes a table-level permission from a user or role. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1RevokePermissionTableResponse">RevokePermissionTableResponse</a> & </td>
        <td><a href="#a8d3b2f5c7e28677e5ea3c4be996dcabd">revokePermissionTable</a> (const <a href="/content/api/cpp/structgpudb_1_1RevokePermissionTableRequest">RevokePermissionTableRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1RevokePermissionTableResponse">RevokePermissionTableResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Revokes a table-level permission from a user or role. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1RevokePermissionTableResponse">RevokePermissionTableResponse</a> </td>
        <td><a href="#ac4183c48e168e0ce4d78c82f96d6adc3">revokePermissionTable</a> (const std::string \&name, const std::string \&permission, const std::string \&tableName, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Revokes a table-level permission from a user or role. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1RevokePermissionTableResponse">RevokePermissionTableResponse</a> & </td>
        <td><a href="#abf33298e271827ae006a41f25658968c">revokePermissionTable</a> (const std::string \&name, const std::string \&permission, const std::string \&tableName, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1RevokePermissionTableResponse">RevokePermissionTableResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Revokes a table-level permission from a user or role. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1RevokeRoleResponse">RevokeRoleResponse</a> </td>
        <td><a href="#af2ab5ebfb9d96023490305c680d6f923">revokeRole</a> (const <a href="/content/api/cpp/structgpudb_1_1RevokeRoleRequest">RevokeRoleRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Revokes membership in a role from a user or role. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1RevokeRoleResponse">RevokeRoleResponse</a> & </td>
        <td><a href="#a42fccf8d04bdd1dd09321e097d3ad67c">revokeRole</a> (const <a href="/content/api/cpp/structgpudb_1_1RevokeRoleRequest">RevokeRoleRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1RevokeRoleResponse">RevokeRoleResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Revokes membership in a role from a user or role. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1RevokeRoleResponse">RevokeRoleResponse</a> </td>
        <td><a href="#a82f2ac33256a97486b580e8a7b4d2d12">revokeRole</a> (const std::string \&role, const std::string \&member, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Revokes membership in a role from a user or role. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1RevokeRoleResponse">RevokeRoleResponse</a> & </td>
        <td><a href="#a965b7a7a9e82170d7b4859799d372ce8">revokeRole</a> (const std::string \&role, const std::string \&member, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1RevokeRoleResponse">RevokeRoleResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Revokes membership in a role from a user or role. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowBackupResponse">ShowBackupResponse</a> </td>
        <td><a href="#a34282710c81f1a106ac96da1e1ce4211">showBackup</a> (const <a href="/content/api/cpp/structgpudb_1_1ShowBackupRequest">ShowBackupRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Shows information about one or more <a href="/content/admin/backup_restore/#database-backup">backups</a> accessible via the <a href="/content/concepts/data_sources/">data source</a> specified by <a href="/content/api/cpp/structgpudb_1_1ShowBackupRequest#a4c53beb3d991fb36d95db8360588a455">datasourceName</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowBackupResponse">ShowBackupResponse</a> & </td>
        <td><a href="#a7164fd1c1db5357815a5465aadd5f8aa">showBackup</a> (const <a href="/content/api/cpp/structgpudb_1_1ShowBackupRequest">ShowBackupRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1ShowBackupResponse">ShowBackupResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Shows information about one or more <a href="/content/admin/backup_restore/#database-backup">backups</a> accessible via the <a href="/content/concepts/data_sources/">data source</a> specified by <a href="/content/api/cpp/structgpudb_1_1ShowBackupRequest#a4c53beb3d991fb36d95db8360588a455">datasourceName</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowBackupResponse">ShowBackupResponse</a> </td>
        <td><a href="#ac5bb47e7d77debb047c7069ece8a6bba">showBackup</a> (const std::string \&backupName, const std::string \&datasourceName, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Shows information about one or more <a href="/content/admin/backup_restore/#database-backup">backups</a> accessible via the <a href="/content/concepts/data_sources/">data source</a> specified by <span>datasourceName</span>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowBackupResponse">ShowBackupResponse</a> & </td>
        <td><a href="#afac647eceb0bf839b94ba9e4099a6ee0">showBackup</a> (const std::string \&backupName, const std::string \&datasourceName, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1ShowBackupResponse">ShowBackupResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Shows information about one or more <a href="/content/admin/backup_restore/#database-backup">backups</a> accessible via the <a href="/content/concepts/data_sources/">data source</a> specified by <span>datasourceName</span>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowCredentialResponse">ShowCredentialResponse</a> </td>
        <td><a href="#a8a6cc5b109352abc15c712cf43afcfd5">showCredential</a> (const <a href="/content/api/cpp/structgpudb_1_1ShowCredentialRequest">ShowCredentialRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Shows information about a specified <a href="/content/concepts/credentials/">credential</a> or all credentials. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowCredentialResponse">ShowCredentialResponse</a> & </td>
        <td><a href="#a8bebd7da393fc8b7171956ec6426962e">showCredential</a> (const <a href="/content/api/cpp/structgpudb_1_1ShowCredentialRequest">ShowCredentialRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1ShowCredentialResponse">ShowCredentialResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Shows information about a specified <a href="/content/concepts/credentials/">credential</a> or all credentials. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowCredentialResponse">ShowCredentialResponse</a> </td>
        <td><a href="#ae50bb1bf426256e47af58232466f6f44">showCredential</a> (const std::string \&credentialName, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Shows information about a specified <a href="/content/concepts/credentials/">credential</a> or all credentials. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowCredentialResponse">ShowCredentialResponse</a> & </td>
        <td><a href="#aaa932d90ebb6dc3d6510ae7932901dac">showCredential</a> (const std::string \&credentialName, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1ShowCredentialResponse">ShowCredentialResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Shows information about a specified <a href="/content/concepts/credentials/">credential</a> or all credentials. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowDatasinkResponse">ShowDatasinkResponse</a> </td>
        <td><a href="#a13af4020cdbe38c12188d1c8488c99aa">showDatasink</a> (const <a href="/content/api/cpp/structgpudb_1_1ShowDatasinkRequest">ShowDatasinkRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Shows information about a specified <a href="/content/concepts/data_sinks/">data sink</a> or all data sinks. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowDatasinkResponse">ShowDatasinkResponse</a> & </td>
        <td><a href="#a9832668f41ca574bbd5026124f5024d3">showDatasink</a> (const <a href="/content/api/cpp/structgpudb_1_1ShowDatasinkRequest">ShowDatasinkRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1ShowDatasinkResponse">ShowDatasinkResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Shows information about a specified <a href="/content/concepts/data_sinks/">data sink</a> or all data sinks. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowDatasinkResponse">ShowDatasinkResponse</a> </td>
        <td><a href="#a905e27980f40316043b75a662f2e9c84">showDatasink</a> (const std::string \&name, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Shows information about a specified <a href="/content/concepts/data_sinks/">data sink</a> or all data sinks. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowDatasinkResponse">ShowDatasinkResponse</a> & </td>
        <td><a href="#a270d824dd50f10b254489586d181e7dc">showDatasink</a> (const std::string \&name, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1ShowDatasinkResponse">ShowDatasinkResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Shows information about a specified <a href="/content/concepts/data_sinks/">data sink</a> or all data sinks. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowDatasourceResponse">ShowDatasourceResponse</a> </td>
        <td><a href="#a68037bb39be04e21f46e233a32e2bd5b">showDatasource</a> (const <a href="/content/api/cpp/structgpudb_1_1ShowDatasourceRequest">ShowDatasourceRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Shows information about a specified <a href="/content/concepts/data_sources/">data source</a> or all data sources. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowDatasourceResponse">ShowDatasourceResponse</a> & </td>
        <td><a href="#a15f7b88b3d480e2e189ccdfae7ee2fd5">showDatasource</a> (const <a href="/content/api/cpp/structgpudb_1_1ShowDatasourceRequest">ShowDatasourceRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1ShowDatasourceResponse">ShowDatasourceResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Shows information about a specified <a href="/content/concepts/data_sources/">data source</a> or all data sources. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowDatasourceResponse">ShowDatasourceResponse</a> </td>
        <td><a href="#a596fab35b766d506ddb9ad94c1330f1c">showDatasource</a> (const std::string \&name, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Shows information about a specified <a href="/content/concepts/data_sources/">data source</a> or all data sources. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowDatasourceResponse">ShowDatasourceResponse</a> & </td>
        <td><a href="#a835cc3144ea0d08f815948b9cba92528">showDatasource</a> (const std::string \&name, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1ShowDatasourceResponse">ShowDatasourceResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Shows information about a specified <a href="/content/concepts/data_sources/">data source</a> or all data sources. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowDirectoriesResponse">ShowDirectoriesResponse</a> </td>
        <td><a href="#a4938a2b931ab7710d13c4eb46caeb79b">showDirectories</a> (const <a href="/content/api/cpp/structgpudb_1_1ShowDirectoriesRequest">ShowDirectoriesRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Shows information about directories in <a href="/content/tools/kifs/">KiFS</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowDirectoriesResponse">ShowDirectoriesResponse</a> & </td>
        <td><a href="#a5d6437a5dac0f332d11129a27526c424">showDirectories</a> (const <a href="/content/api/cpp/structgpudb_1_1ShowDirectoriesRequest">ShowDirectoriesRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1ShowDirectoriesResponse">ShowDirectoriesResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Shows information about directories in <a href="/content/tools/kifs/">KiFS</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowDirectoriesResponse">ShowDirectoriesResponse</a> </td>
        <td><a href="#a9c29f706c737f08808675066fe0cb14a">showDirectories</a> (const std::string \&directoryName, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Shows information about directories in <a href="/content/tools/kifs/">KiFS</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowDirectoriesResponse">ShowDirectoriesResponse</a> & </td>
        <td><a href="#a72f8a16fa689331e831c4779b6ef3844">showDirectories</a> (const std::string \&directoryName, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1ShowDirectoriesResponse">ShowDirectoriesResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Shows information about directories in <a href="/content/tools/kifs/">KiFS</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowEnvironmentResponse">ShowEnvironmentResponse</a> </td>
        <td><a href="#ad2c3289e4d36b6d0278357e362354c35">showEnvironment</a> (const <a href="/content/api/cpp/structgpudb_1_1ShowEnvironmentRequest">ShowEnvironmentRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Shows information about a specified <a href="/content/concepts/udf/">user-defined function</a> (UDF) environment or all environments. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowEnvironmentResponse">ShowEnvironmentResponse</a> & </td>
        <td><a href="#a642110b2dfca287ef3f899ae69471648">showEnvironment</a> (const <a href="/content/api/cpp/structgpudb_1_1ShowEnvironmentRequest">ShowEnvironmentRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1ShowEnvironmentResponse">ShowEnvironmentResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Shows information about a specified <a href="/content/concepts/udf/">user-defined function</a> (UDF) environment or all environments. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowEnvironmentResponse">ShowEnvironmentResponse</a> </td>
        <td><a href="#a02c334c7050c5c8541543bffbb2c3dab">showEnvironment</a> (const std::string \&environmentName, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Shows information about a specified <a href="/content/concepts/udf/">user-defined function</a> (UDF) environment or all environments. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowEnvironmentResponse">ShowEnvironmentResponse</a> & </td>
        <td><a href="#aa373b15e4a0e973a55356bc2b6a2c0b8">showEnvironment</a> (const std::string \&environmentName, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1ShowEnvironmentResponse">ShowEnvironmentResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Shows information about a specified <a href="/content/concepts/udf/">user-defined function</a> (UDF) environment or all environments. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowFilesResponse">ShowFilesResponse</a> </td>
        <td><a href="#a25eed62c5697242506cc5e336925b45d">showFiles</a> (const <a href="/content/api/cpp/structgpudb_1_1ShowFilesRequest">ShowFilesRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Shows information about files in <a href="/content/tools/kifs/">KiFS</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowFilesResponse">ShowFilesResponse</a> & </td>
        <td><a href="#a16e25d4e91734847b87f3f1a44862f13">showFiles</a> (const <a href="/content/api/cpp/structgpudb_1_1ShowFilesRequest">ShowFilesRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1ShowFilesResponse">ShowFilesResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Shows information about files in <a href="/content/tools/kifs/">KiFS</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowFilesResponse">ShowFilesResponse</a> </td>
        <td><a href="#a96bb343ffbdcbfdfa09e2cb3d850b12f">showFiles</a> (const std::vector\< std::string > \&paths, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Shows information about files in <a href="/content/tools/kifs/">KiFS</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowFilesResponse">ShowFilesResponse</a> & </td>
        <td><a href="#a9f53bbe801f06691fd686533da8ec2d8">showFiles</a> (const std::vector\< std::string > \&paths, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1ShowFilesResponse">ShowFilesResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Shows information about files in <a href="/content/tools/kifs/">KiFS</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowGraphResponse">ShowGraphResponse</a> </td>
        <td><a href="#aa26104ece9a4825f8fd309470e2477ec">showGraph</a> (const <a href="/content/api/cpp/structgpudb_1_1ShowGraphRequest">ShowGraphRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Shows information and characteristics of graphs that exist on the graph server. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowGraphResponse">ShowGraphResponse</a> & </td>
        <td><a href="#afde5e9ee7e8f46468385d65999027797">showGraph</a> (const <a href="/content/api/cpp/structgpudb_1_1ShowGraphRequest">ShowGraphRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1ShowGraphResponse">ShowGraphResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Shows information and characteristics of graphs that exist on the graph server. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowGraphResponse">ShowGraphResponse</a> </td>
        <td><a href="#a9debdae46b9cb8ce19f782d73a958c51">showGraph</a> (const std::string \&graphName, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Shows information and characteristics of graphs that exist on the graph server. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowGraphResponse">ShowGraphResponse</a> & </td>
        <td><a href="#a88e042d9704eae6dae407957f0cf43b2">showGraph</a> (const std::string \&graphName, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1ShowGraphResponse">ShowGraphResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Shows information and characteristics of graphs that exist on the graph server. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowProcResponse">ShowProcResponse</a> </td>
        <td><a href="#ae7427428b2214adb5622e723382cb304">showProc</a> (const <a href="/content/api/cpp/structgpudb_1_1ShowProcRequest">ShowProcRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Shows information about a proc. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowProcResponse">ShowProcResponse</a> & </td>
        <td><a href="#a5061ef951ef0a4b8d987d3d2b7c83d57">showProc</a> (const <a href="/content/api/cpp/structgpudb_1_1ShowProcRequest">ShowProcRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1ShowProcResponse">ShowProcResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Shows information about a proc. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowProcResponse">ShowProcResponse</a> </td>
        <td><a href="#a4ff6de0d6b70a356a1995b973c9811dc">showProc</a> (const std::string \&procName, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Shows information about a proc. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowProcResponse">ShowProcResponse</a> & </td>
        <td><a href="#ae6068858a2038ed362689d6d360a058f">showProc</a> (const std::string \&procName, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1ShowProcResponse">ShowProcResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Shows information about a proc. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowProcStatusResponse">ShowProcStatusResponse</a> </td>
        <td><a href="#a1d460da9ead16a63d91e8a104805d0a6">showProcStatus</a> (const <a href="/content/api/cpp/structgpudb_1_1ShowProcStatusRequest">ShowProcStatusRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Shows the statuses of running or completed proc instances. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowProcStatusResponse">ShowProcStatusResponse</a> & </td>
        <td><a href="#a24b7a91e64544a630bba237a13278ced">showProcStatus</a> (const <a href="/content/api/cpp/structgpudb_1_1ShowProcStatusRequest">ShowProcStatusRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1ShowProcStatusResponse">ShowProcStatusResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Shows the statuses of running or completed proc instances. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowProcStatusResponse">ShowProcStatusResponse</a> </td>
        <td><a href="#a13497a80667b878cad9e5e6db04092d9">showProcStatus</a> (const std::string \&runId, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Shows the statuses of running or completed proc instances. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowProcStatusResponse">ShowProcStatusResponse</a> & </td>
        <td><a href="#ac60a93b49b3d2f94f229a9d0df2aa79b">showProcStatus</a> (const std::string \&runId, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1ShowProcStatusResponse">ShowProcStatusResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Shows the statuses of running or completed proc instances. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowResourceObjectsResponse">ShowResourceObjectsResponse</a> </td>
        <td><a href="#a88a53f3f53aea0fe34c7952f8ed1706b">showResourceObjects</a> (const <a href="/content/api/cpp/structgpudb_1_1ShowResourceObjectsRequest">ShowResourceObjectsRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Returns information about the internal sub-components (tiered objects) which use resources of the system. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowResourceObjectsResponse">ShowResourceObjectsResponse</a> & </td>
        <td><a href="#af5c1be74988aa37d3ad684559e7adcc5">showResourceObjects</a> (const <a href="/content/api/cpp/structgpudb_1_1ShowResourceObjectsRequest">ShowResourceObjectsRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1ShowResourceObjectsResponse">ShowResourceObjectsResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Returns information about the internal sub-components (tiered objects) which use resources of the system. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowResourceObjectsResponse">ShowResourceObjectsResponse</a> </td>
        <td><a href="#a7e822927bba455a02b789e548f61f683">showResourceObjects</a> (const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Returns information about the internal sub-components (tiered objects) which use resources of the system. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowResourceObjectsResponse">ShowResourceObjectsResponse</a> & </td>
        <td><a href="#aed2c3b3e3205862b58eca63e0af50856">showResourceObjects</a> (const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1ShowResourceObjectsResponse">ShowResourceObjectsResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Returns information about the internal sub-components (tiered objects) which use resources of the system. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowResourceStatisticsResponse">ShowResourceStatisticsResponse</a> </td>
        <td><a href="#a3fc3bd8bd184e925912ade256e84f9f7">showResourceStatistics</a> (const <a href="/content/api/cpp/structgpudb_1_1ShowResourceStatisticsRequest">ShowResourceStatisticsRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Requests various statistics for storage/memory tiers and resource groups. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowResourceStatisticsResponse">ShowResourceStatisticsResponse</a> & </td>
        <td><a href="#a8a63706033443ae53638d95e9e136d48">showResourceStatistics</a> (const <a href="/content/api/cpp/structgpudb_1_1ShowResourceStatisticsRequest">ShowResourceStatisticsRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1ShowResourceStatisticsResponse">ShowResourceStatisticsResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Requests various statistics for storage/memory tiers and resource groups. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowResourceStatisticsResponse">ShowResourceStatisticsResponse</a> </td>
        <td><a href="#a85c91091e33a01bb10426de8d53a34c5">showResourceStatistics</a> (const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Requests various statistics for storage/memory tiers and resource groups. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowResourceStatisticsResponse">ShowResourceStatisticsResponse</a> & </td>
        <td><a href="#ae3347291e4420eedba0bbd771b959e2b">showResourceStatistics</a> (const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1ShowResourceStatisticsResponse">ShowResourceStatisticsResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Requests various statistics for storage/memory tiers and resource groups. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowResourceGroupsResponse">ShowResourceGroupsResponse</a> </td>
        <td><a href="#a378c6b54b2b4795e17ba59fe12110633">showResourceGroups</a> (const <a href="/content/api/cpp/structgpudb_1_1ShowResourceGroupsRequest">ShowResourceGroupsRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Requests resource group properties. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowResourceGroupsResponse">ShowResourceGroupsResponse</a> & </td>
        <td><a href="#add609fa998cd62bb51ad9795c4e9f897">showResourceGroups</a> (const <a href="/content/api/cpp/structgpudb_1_1ShowResourceGroupsRequest">ShowResourceGroupsRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1ShowResourceGroupsResponse">ShowResourceGroupsResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Requests resource group properties. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowResourceGroupsResponse">ShowResourceGroupsResponse</a> </td>
        <td><a href="#a726aae68f00a46595368ee7f5a3f4ec9">showResourceGroups</a> (const std::vector\< std::string > \&names, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Requests resource group properties. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowResourceGroupsResponse">ShowResourceGroupsResponse</a> & </td>
        <td><a href="#a1181eebb9d511dd63c8c978476c8e89b">showResourceGroups</a> (const std::vector\< std::string > \&names, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1ShowResourceGroupsResponse">ShowResourceGroupsResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Requests resource group properties. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowSchemaResponse">ShowSchemaResponse</a> </td>
        <td><a href="#a1cc194756eebfcbf911f60598b55daed">showSchema</a> (const <a href="/content/api/cpp/structgpudb_1_1ShowSchemaRequest">ShowSchemaRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Retrieves information about a <a href="/content/concepts/schemas/">schema</a> (or all schemas), as specified in <a href="/content/api/cpp/structgpudb_1_1ShowSchemaRequest#ab426d3779701046c6ea78613c2593a35">schemaName</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowSchemaResponse">ShowSchemaResponse</a> & </td>
        <td><a href="#ad7de0c685fbf21daeea86231e8754ddc">showSchema</a> (const <a href="/content/api/cpp/structgpudb_1_1ShowSchemaRequest">ShowSchemaRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1ShowSchemaResponse">ShowSchemaResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Retrieves information about a <a href="/content/concepts/schemas/">schema</a> (or all schemas), as specified in <a href="/content/api/cpp/structgpudb_1_1ShowSchemaRequest#ab426d3779701046c6ea78613c2593a35">schemaName</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowSchemaResponse">ShowSchemaResponse</a> </td>
        <td><a href="#ab206730d8e790a566f5276653d609572">showSchema</a> (const std::string \&schemaName, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Retrieves information about a <a href="/content/concepts/schemas/">schema</a> (or all schemas), as specified in <span>schemaName</span>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowSchemaResponse">ShowSchemaResponse</a> & </td>
        <td><a href="#a77a202a439aa2b3af6f82368abf2fa34">showSchema</a> (const std::string \&schemaName, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1ShowSchemaResponse">ShowSchemaResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Retrieves information about a <a href="/content/concepts/schemas/">schema</a> (or all schemas), as specified in <span>schemaName</span>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowSecurityResponse">ShowSecurityResponse</a> </td>
        <td><a href="#a40c433cf19b0cc02dea2b197924e5a22">showSecurity</a> (const <a href="/content/api/cpp/structgpudb_1_1ShowSecurityRequest">ShowSecurityRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Shows security information relating to users and/or roles. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowSecurityResponse">ShowSecurityResponse</a> & </td>
        <td><a href="#ac04015d3b7c2003b2a428b29c5cdf47a">showSecurity</a> (const <a href="/content/api/cpp/structgpudb_1_1ShowSecurityRequest">ShowSecurityRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1ShowSecurityResponse">ShowSecurityResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Shows security information relating to users and/or roles. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowSecurityResponse">ShowSecurityResponse</a> </td>
        <td><a href="#acca9c93b40c72ff151c7d8abb60c59af">showSecurity</a> (const std::vector\< std::string > \&names, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Shows security information relating to users and/or roles. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowSecurityResponse">ShowSecurityResponse</a> & </td>
        <td><a href="#ab8545998de2f9115da768db51cabf7f7">showSecurity</a> (const std::vector\< std::string > \&names, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1ShowSecurityResponse">ShowSecurityResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Shows security information relating to users and/or roles. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowSqlProcResponse">ShowSqlProcResponse</a> </td>
        <td><a href="#af1e1e90f76a43c60220ad2ffa008f4af">showSqlProc</a> (const <a href="/content/api/cpp/structgpudb_1_1ShowSqlProcRequest">ShowSqlProcRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Shows information about SQL procedures, including the full definition of each requested procedure. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowSqlProcResponse">ShowSqlProcResponse</a> & </td>
        <td><a href="#a9dffef865f8df9bac7ed947e80d58c66">showSqlProc</a> (const <a href="/content/api/cpp/structgpudb_1_1ShowSqlProcRequest">ShowSqlProcRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1ShowSqlProcResponse">ShowSqlProcResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Shows information about SQL procedures, including the full definition of each requested procedure. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowSqlProcResponse">ShowSqlProcResponse</a> </td>
        <td><a href="#a13c04a3cae289ef769af2244f913e27c">showSqlProc</a> (const std::string \&procedureName, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Shows information about SQL procedures, including the full definition of each requested procedure. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowSqlProcResponse">ShowSqlProcResponse</a> & </td>
        <td><a href="#aff1be35f1f720165261c4128beaa9cae">showSqlProc</a> (const std::string \&procedureName, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1ShowSqlProcResponse">ShowSqlProcResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Shows information about SQL procedures, including the full definition of each requested procedure. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowStatisticsResponse">ShowStatisticsResponse</a> </td>
        <td><a href="#a9f383f90577358cd07abe30ddf79295f">showStatistics</a> (const <a href="/content/api/cpp/structgpudb_1_1ShowStatisticsRequest">ShowStatisticsRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Retrieves the collected column statistics for the specified table(s). <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowStatisticsResponse">ShowStatisticsResponse</a> & </td>
        <td><a href="#abc0302b8710c3ee9fe443f7ab5c57d22">showStatistics</a> (const <a href="/content/api/cpp/structgpudb_1_1ShowStatisticsRequest">ShowStatisticsRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1ShowStatisticsResponse">ShowStatisticsResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Retrieves the collected column statistics for the specified table(s). <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowStatisticsResponse">ShowStatisticsResponse</a> </td>
        <td><a href="#a718f8538f41b0877f1d3c998ec263bf9">showStatistics</a> (const std::vector\< std::string > \&tableNames, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Retrieves the collected column statistics for the specified table(s). <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowStatisticsResponse">ShowStatisticsResponse</a> & </td>
        <td><a href="#a7b33126532757e9abfabcd9fbdc8982d">showStatistics</a> (const std::vector\< std::string > \&tableNames, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1ShowStatisticsResponse">ShowStatisticsResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Retrieves the collected column statistics for the specified table(s). <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowSystemPropertiesResponse">ShowSystemPropertiesResponse</a> </td>
        <td><a href="#a84ab8280203e0c3868f29de4991685ac">showSystemProperties</a> (const <a href="/content/api/cpp/structgpudb_1_1ShowSystemPropertiesRequest">ShowSystemPropertiesRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Returns server configuration and version related information to the caller. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowSystemPropertiesResponse">ShowSystemPropertiesResponse</a> & </td>
        <td><a href="#aa352ba53bf874da1241d2ad175c7b7fd">showSystemProperties</a> (const <a href="/content/api/cpp/structgpudb_1_1ShowSystemPropertiesRequest">ShowSystemPropertiesRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1ShowSystemPropertiesResponse">ShowSystemPropertiesResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Returns server configuration and version related information to the caller. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowSystemPropertiesResponse">ShowSystemPropertiesResponse</a> </td>
        <td><a href="#a784bbdd03c35b32dbf2568f7bf46b27f">showSystemProperties</a> (const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Returns server configuration and version related information to the caller. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowSystemPropertiesResponse">ShowSystemPropertiesResponse</a> & </td>
        <td><a href="#aab5ac92b58d7dbe03522426356852b24">showSystemProperties</a> (const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1ShowSystemPropertiesResponse">ShowSystemPropertiesResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Returns server configuration and version related information to the caller. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowSystemStatusResponse">ShowSystemStatusResponse</a> </td>
        <td><a href="#abe9a7d6ea3fe0b154d73b86955db53cb">showSystemStatus</a> (const <a href="/content/api/cpp/structgpudb_1_1ShowSystemStatusRequest">ShowSystemStatusRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Provides server configuration and health related status to the caller. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowSystemStatusResponse">ShowSystemStatusResponse</a> & </td>
        <td><a href="#ad8ee4fa96d9c29267f56698dc165c2a3">showSystemStatus</a> (const <a href="/content/api/cpp/structgpudb_1_1ShowSystemStatusRequest">ShowSystemStatusRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1ShowSystemStatusResponse">ShowSystemStatusResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Provides server configuration and health related status to the caller. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowSystemStatusResponse">ShowSystemStatusResponse</a> </td>
        <td><a href="#a2cc190f96524c44227af5731319ad4e1">showSystemStatus</a> (const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Provides server configuration and health related status to the caller. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowSystemStatusResponse">ShowSystemStatusResponse</a> & </td>
        <td><a href="#acd8fa09150dd778c2890357d220c451f">showSystemStatus</a> (const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1ShowSystemStatusResponse">ShowSystemStatusResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Provides server configuration and health related status to the caller. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowSystemTimingResponse">ShowSystemTimingResponse</a> </td>
        <td><a href="#a98058f80289f0cb4fcc381db5f43a54f">showSystemTiming</a> (const <a href="/content/api/cpp/structgpudb_1_1ShowSystemTimingRequest">ShowSystemTimingRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Returns the last 100 database requests along with the request timing and internal job ID. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowSystemTimingResponse">ShowSystemTimingResponse</a> & </td>
        <td><a href="#abed19734233489426cb907a2ff00e40c">showSystemTiming</a> (const <a href="/content/api/cpp/structgpudb_1_1ShowSystemTimingRequest">ShowSystemTimingRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1ShowSystemTimingResponse">ShowSystemTimingResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Returns the last 100 database requests along with the request timing and internal job ID. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowSystemTimingResponse">ShowSystemTimingResponse</a> </td>
        <td><a href="#ae4f171b4c997ea2b72b898f436395e64">showSystemTiming</a> (const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Returns the last 100 database requests along with the request timing and internal job ID. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowSystemTimingResponse">ShowSystemTimingResponse</a> & </td>
        <td><a href="#abfc55faedf2820f296f12dab7b62cb55">showSystemTiming</a> (const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1ShowSystemTimingResponse">ShowSystemTimingResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Returns the last 100 database requests along with the request timing and internal job ID. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowTableResponse">ShowTableResponse</a> </td>
        <td><a href="#ae446b45c99e9b4afa26726bce8ad23cc">showTable</a> (const <a href="/content/api/cpp/structgpudb_1_1ShowTableRequest">ShowTableRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Retrieves detailed information about a table, view, or schema, specified in <a href="/content/api/cpp/structgpudb_1_1ShowTableRequest#a4b7e6b1e0720e0453914de2e455d9b8e">tableName</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowTableResponse">ShowTableResponse</a> & </td>
        <td><a href="#a7335f652dfe78271639dffd37424e279">showTable</a> (const <a href="/content/api/cpp/structgpudb_1_1ShowTableRequest">ShowTableRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1ShowTableResponse">ShowTableResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Retrieves detailed information about a table, view, or schema, specified in <a href="/content/api/cpp/structgpudb_1_1ShowTableRequest#a4b7e6b1e0720e0453914de2e455d9b8e">tableName</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowTableResponse">ShowTableResponse</a> </td>
        <td><a href="#a0ba64d599891431a9d2aff56dca5a9ab">showTable</a> (const std::string \&tableName, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Retrieves detailed information about a table, view, or schema, specified in <span>tableName</span>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowTableResponse">ShowTableResponse</a> & </td>
        <td><a href="#a9af84c2e52f527a087c8153eabb8ee89">showTable</a> (const std::string \&tableName, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1ShowTableResponse">ShowTableResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Retrieves detailed information about a table, view, or schema, specified in <span>tableName</span>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowTableMetadataResponse">ShowTableMetadataResponse</a> </td>
        <td><a href="#a8011e9d5df312e8f50583cc4b153dde8">showTableMetadata</a> (const <a href="/content/api/cpp/structgpudb_1_1ShowTableMetadataRequest">ShowTableMetadataRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Retrieves the user provided metadata for the specified tables. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowTableMetadataResponse">ShowTableMetadataResponse</a> & </td>
        <td><a href="#ab7bc6afc0682e126a425727d883ebbad">showTableMetadata</a> (const <a href="/content/api/cpp/structgpudb_1_1ShowTableMetadataRequest">ShowTableMetadataRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1ShowTableMetadataResponse">ShowTableMetadataResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Retrieves the user provided metadata for the specified tables. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowTableMetadataResponse">ShowTableMetadataResponse</a> </td>
        <td><a href="#ab1250090726533a5265355e7c0bff521">showTableMetadata</a> (const std::vector\< std::string > \&tableNames, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Retrieves the user provided metadata for the specified tables. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowTableMetadataResponse">ShowTableMetadataResponse</a> & </td>
        <td><a href="#a94dc914ac5b5e5634a95ff88b3902be2">showTableMetadata</a> (const std::vector\< std::string > \&tableNames, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1ShowTableMetadataResponse">ShowTableMetadataResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Retrieves the user provided metadata for the specified tables. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowTableMonitorsResponse">ShowTableMonitorsResponse</a> </td>
        <td><a href="#a1b9e0abd0e04244cff2813881f72615e">showTableMonitors</a> (const <a href="/content/api/cpp/structgpudb_1_1ShowTableMonitorsRequest">ShowTableMonitorsRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Show table monitors and their properties. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowTableMonitorsResponse">ShowTableMonitorsResponse</a> & </td>
        <td><a href="#a3bae1cd6313e43f990e4eb4a554f8a1d">showTableMonitors</a> (const <a href="/content/api/cpp/structgpudb_1_1ShowTableMonitorsRequest">ShowTableMonitorsRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1ShowTableMonitorsResponse">ShowTableMonitorsResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Show table monitors and their properties. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowTableMonitorsResponse">ShowTableMonitorsResponse</a> </td>
        <td><a href="#ad36ad1ac000458de39912ad045100bb4">showTableMonitors</a> (const std::vector\< std::string > \&monitorIds, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Show table monitors and their properties. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowTableMonitorsResponse">ShowTableMonitorsResponse</a> & </td>
        <td><a href="#ac78e4c6b00a6dc553affd5f6a7681c04">showTableMonitors</a> (const std::vector\< std::string > \&monitorIds, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1ShowTableMonitorsResponse">ShowTableMonitorsResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Show table monitors and their properties. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowTablesByTypeResponse">ShowTablesByTypeResponse</a> </td>
        <td><a href="#aa176b992328cb4ac634c06e9683f4120">showTablesByType</a> (const <a href="/content/api/cpp/structgpudb_1_1ShowTablesByTypeRequest">ShowTablesByTypeRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Gets names of the tables whose type matches the given criteria. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowTablesByTypeResponse">ShowTablesByTypeResponse</a> & </td>
        <td><a href="#a5d9dae6c5d5e405c5a3c802ac330db8d">showTablesByType</a> (const <a href="/content/api/cpp/structgpudb_1_1ShowTablesByTypeRequest">ShowTablesByTypeRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1ShowTablesByTypeResponse">ShowTablesByTypeResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Gets names of the tables whose type matches the given criteria. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowTablesByTypeResponse">ShowTablesByTypeResponse</a> </td>
        <td><a href="#ace4dedcb98f864f1dfdcd7e3901f5017">showTablesByType</a> (const std::string \&typeId, const std::string \&label, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Gets names of the tables whose type matches the given criteria. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowTablesByTypeResponse">ShowTablesByTypeResponse</a> & </td>
        <td><a href="#ab97b8f8e43007329fc0978ee9b179003">showTablesByType</a> (const std::string \&typeId, const std::string \&label, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1ShowTablesByTypeResponse">ShowTablesByTypeResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Gets names of the tables whose type matches the given criteria. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowTriggersResponse">ShowTriggersResponse</a> </td>
        <td><a href="#aa866be48a1507fae7b1f04cabb2dec7b">showTriggers</a> (const <a href="/content/api/cpp/structgpudb_1_1ShowTriggersRequest">ShowTriggersRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Retrieves information regarding the specified triggers or all existing triggers currently active. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowTriggersResponse">ShowTriggersResponse</a> & </td>
        <td><a href="#a056e32dfb35638f25ff6ce6209b64361">showTriggers</a> (const <a href="/content/api/cpp/structgpudb_1_1ShowTriggersRequest">ShowTriggersRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1ShowTriggersResponse">ShowTriggersResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Retrieves information regarding the specified triggers or all existing triggers currently active. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowTriggersResponse">ShowTriggersResponse</a> </td>
        <td><a href="#a1850c13a2596e38b3adb5b66f1019bdf">showTriggers</a> (const std::vector\< std::string > \&triggerIds, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Retrieves information regarding the specified triggers or all existing triggers currently active. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowTriggersResponse">ShowTriggersResponse</a> & </td>
        <td><a href="#a79726472baf60c0c5c4ed28c7e1d1c62">showTriggers</a> (const std::vector\< std::string > \&triggerIds, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1ShowTriggersResponse">ShowTriggersResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Retrieves information regarding the specified triggers or all existing triggers currently active. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowTypesResponse">ShowTypesResponse</a> </td>
        <td><a href="#a7e24fcb79c117b482b208c0ef5460a13">showTypes</a> (const <a href="/content/api/cpp/structgpudb_1_1ShowTypesRequest">ShowTypesRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Retrieves information for the specified data type ID or type label. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowTypesResponse">ShowTypesResponse</a> & </td>
        <td><a href="#ad04a5739c19607646621ffb136131e59">showTypes</a> (const <a href="/content/api/cpp/structgpudb_1_1ShowTypesRequest">ShowTypesRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1ShowTypesResponse">ShowTypesResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Retrieves information for the specified data type ID or type label. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowTypesResponse">ShowTypesResponse</a> </td>
        <td><a href="#af7d8d4d6feabebbcb4d876490e0189ec">showTypes</a> (const std::string \&typeId, const std::string \&label, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Retrieves information for the specified data type ID or type label. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowTypesResponse">ShowTypesResponse</a> & </td>
        <td><a href="#a51dafaa30b1649127b257efea07d8e6e">showTypes</a> (const std::string \&typeId, const std::string \&label, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1ShowTypesResponse">ShowTypesResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Retrieves information for the specified data type ID or type label. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowVideoResponse">ShowVideoResponse</a> </td>
        <td><a href="#a05a25ebc31d43eb7006d745e42ae3481">showVideo</a> (const <a href="/content/api/cpp/structgpudb_1_1ShowVideoRequest">ShowVideoRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Retrieves information about rendered videos. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowVideoResponse">ShowVideoResponse</a> & </td>
        <td><a href="#ae38f09ef1534eef8c6a6f750ef82746c">showVideo</a> (const <a href="/content/api/cpp/structgpudb_1_1ShowVideoRequest">ShowVideoRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1ShowVideoResponse">ShowVideoResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Retrieves information about rendered videos. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowVideoResponse">ShowVideoResponse</a> </td>
        <td><a href="#a476a58d5c29335a022ac949d8cee8a5c">showVideo</a> (const std::vector\< std::string > \&paths, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Retrieves information about rendered videos. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowVideoResponse">ShowVideoResponse</a> & </td>
        <td><a href="#a121311ac48c0d3816ea00df3dc39f079">showVideo</a> (const std::vector\< std::string > \&paths, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1ShowVideoResponse">ShowVideoResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Retrieves information about rendered videos. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowWalResponse">ShowWalResponse</a> </td>
        <td><a href="#ad5bf0a554a3e41a63719b512f4c202d9">showWal</a> (const <a href="/content/api/cpp/structgpudb_1_1ShowWalRequest">ShowWalRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Requests table write-ahead log (WAL) properties. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowWalResponse">ShowWalResponse</a> & </td>
        <td><a href="#a73d6e73702f1b0522b80a2ffd0f9d392">showWal</a> (const <a href="/content/api/cpp/structgpudb_1_1ShowWalRequest">ShowWalRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1ShowWalResponse">ShowWalResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Requests table write-ahead log (WAL) properties. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowWalResponse">ShowWalResponse</a> </td>
        <td><a href="#aa65d48578b33db8e6f809c4f33733767">showWal</a> (const std::vector\< std::string > \&tableNames, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Requests table write-ahead log (WAL) properties. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1ShowWalResponse">ShowWalResponse</a> & </td>
        <td><a href="#ae90a350f2c13f5f6528ca9c87b21c9b6">showWal</a> (const std::vector\< std::string > \&tableNames, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1ShowWalResponse">ShowWalResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Requests table write-ahead log (WAL) properties. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1SolveGraphResponse">SolveGraphResponse</a> </td>
        <td><a href="#a53c721cb54a46730bbc465ee3a4a6dc3">solveGraph</a> (const <a href="/content/api/cpp/structgpudb_1_1SolveGraphRequest">SolveGraphRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Solves an existing graph for a type of problem (e.g., shortest path, page rank, traveling salesman, etc.) using source nodes, destination nodes, and additional, optional weights and restrictions. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1SolveGraphResponse">SolveGraphResponse</a> & </td>
        <td><a href="#a0a3a244ab7b1ff59db92a225ac01c733">solveGraph</a> (const <a href="/content/api/cpp/structgpudb_1_1SolveGraphRequest">SolveGraphRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1SolveGraphResponse">SolveGraphResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Solves an existing graph for a type of problem (e.g., shortest path, page rank, traveling salesman, etc.) using source nodes, destination nodes, and additional, optional weights and restrictions. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1SolveGraphResponse">SolveGraphResponse</a> </td>
        <td><a href="#af09b181ad497eac4c7b759f55e612bce">solveGraph</a> (const std::string \&graphName, const std::vector\< std::string > \&weightsOnEdges, const std::vector\< std::string > \&restrictions, const std::string \&solverType, const std::vector\< std::string > \&sourceNodes, const std::vector\< std::string > \&destinationNodes, const std::string \&solutionTable, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Solves an existing graph for a type of problem (e.g., shortest path, page rank, traveling salesman, etc.) using source nodes, destination nodes, and additional, optional weights and restrictions. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1SolveGraphResponse">SolveGraphResponse</a> & </td>
        <td><a href="#a4fc28f54b6a27b284e37f62fe92abb61">solveGraph</a> (const std::string \&graphName, const std::vector\< std::string > \&weightsOnEdges, const std::vector\< std::string > \&restrictions, const std::string \&solverType, const std::vector\< std::string > \&sourceNodes, const std::vector\< std::string > \&destinationNodes, const std::string \&solutionTable, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1SolveGraphResponse">SolveGraphResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Solves an existing graph for a type of problem (e.g., shortest path, page rank, traveling salesman, etc.) using source nodes, destination nodes, and additional, optional weights and restrictions. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1UpdateRecordsResponse">UpdateRecordsResponse</a> </td>
        <td><a href="#afa5f0d470237751f291fc535cff990e7">updateRecordsRaw</a> (const <a href="/content/api/cpp/structgpudb_1_1RawUpdateRecordsRequest">RawUpdateRecordsRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Runs multiple predicate-based updates in a single call. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1UpdateRecordsResponse">UpdateRecordsResponse</a> & </td>
        <td><a href="#abc974f0c50ac67f437c2c388a91273d4">updateRecordsRaw</a> (const <a href="/content/api/cpp/structgpudb_1_1RawUpdateRecordsRequest">RawUpdateRecordsRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1UpdateRecordsResponse">UpdateRecordsResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Runs multiple predicate-based updates in a single call. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>template\<typename TRequest> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1UpdateRecordsResponse">UpdateRecordsResponse</a> </td>
        <td><a href="#a9db9f3f48674be912871065a523157bd">updateRecords</a> (const <a href="/content/api/cpp/structgpudb_1_1UpdateRecordsRequest">UpdateRecordsRequest</a>\< TRequest > \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Runs multiple predicate-based updates in a single call. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>template\<typename TRequest> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1UpdateRecordsResponse">UpdateRecordsResponse</a> & </td>
        <td><a href="#a4807b97a4e4bf7fc1c59f216850e17e8">updateRecords</a> (const <a href="/content/api/cpp/structgpudb_1_1UpdateRecordsRequest">UpdateRecordsRequest</a>\< TRequest > \&request\_, <a href="/content/api/cpp/structgpudb_1_1UpdateRecordsResponse">UpdateRecordsResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Runs multiple predicate-based updates in a single call. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>template\<typename TRequest> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1UpdateRecordsResponse">UpdateRecordsResponse</a> </td>
        <td><a href="#aa82b29b715fe503ada9587cd7ac8e5f7">updateRecords</a> (const std::string \&tableName, const std::vector\< std::string > \&expressions, const std::vector\< std::map\< std::string, boost::optional\< std::string > > > \&newValuesMaps, const std::vector\< TRequest > \&data, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Runs multiple predicate-based updates in a single call. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>template\<typename TRequest> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1UpdateRecordsResponse">UpdateRecordsResponse</a> & </td>
        <td><a href="#a6d725e31070f46da74ac0b24254711da">updateRecords</a> (const std::string \&tableName, const std::vector\< std::string > \&expressions, const std::vector\< std::map\< std::string, boost::optional\< std::string > > > \&newValuesMaps, const std::vector\< TRequest > \&data, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1UpdateRecordsResponse">UpdateRecordsResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Runs multiple predicate-based updates in a single call. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1UploadFilesResponse">UploadFilesResponse</a> </td>
        <td><a href="#abf858a844a619c04135d680ce9a2fe4c">uploadFiles</a> (const <a href="/content/api/cpp/structgpudb_1_1UploadFilesRequest">UploadFilesRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Uploads one or more files to <a href="/content/tools/kifs/">KiFS</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1UploadFilesResponse">UploadFilesResponse</a> & </td>
        <td><a href="#afcd36af3a42361e0ed7d8faaf8eef005">uploadFiles</a> (const <a href="/content/api/cpp/structgpudb_1_1UploadFilesRequest">UploadFilesRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1UploadFilesResponse">UploadFilesResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Uploads one or more files to <a href="/content/tools/kifs/">KiFS</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1UploadFilesResponse">UploadFilesResponse</a> </td>
        <td><a href="#a536c56e50bedb45ae384af8de3b6483a">uploadFiles</a> (const std::vector\< std::string > \&fileNames, const std::vector\< std::vector\< uint8\_t > > \&fileData, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Uploads one or more files to <a href="/content/tools/kifs/">KiFS</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1UploadFilesResponse">UploadFilesResponse</a> & </td>
        <td><a href="#a93bc72bce3e201e33b4a41ced2e514a4">uploadFiles</a> (const std::vector\< std::string > \&fileNames, const std::vector\< std::vector\< uint8\_t > > \&fileData, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1UploadFilesResponse">UploadFilesResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Uploads one or more files to <a href="/content/tools/kifs/">KiFS</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1UploadFilesFromurlResponse">UploadFilesFromurlResponse</a> </td>
        <td><a href="#ab62cc7f905247d940fd812c2d6a69f69">uploadFilesFromurl</a> (const <a href="/content/api/cpp/structgpudb_1_1UploadFilesFromurlRequest">UploadFilesFromurlRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Uploads one or more files to <a href="/content/tools/kifs/">KiFS</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1UploadFilesFromurlResponse">UploadFilesFromurlResponse</a> & </td>
        <td><a href="#a5add4bdb41a2fb23de1456566864b58c">uploadFilesFromurl</a> (const <a href="/content/api/cpp/structgpudb_1_1UploadFilesFromurlRequest">UploadFilesFromurlRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1UploadFilesFromurlResponse">UploadFilesFromurlResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Uploads one or more files to <a href="/content/tools/kifs/">KiFS</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1UploadFilesFromurlResponse">UploadFilesFromurlResponse</a> </td>
        <td><a href="#a8632d9278407bd6b2010f0bb50e5c4b9">uploadFilesFromurl</a> (const std::vector\< std::string > \&fileNames, const std::vector\< std::string > \&urls, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Uploads one or more files to <a href="/content/tools/kifs/">KiFS</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1UploadFilesFromurlResponse">UploadFilesFromurlResponse</a> & </td>
        <td><a href="#a7afbe9b58aca628f2d85a321c34c0a12">uploadFilesFromurl</a> (const std::vector\< std::string > \&fileNames, const std::vector\< std::string > \&urls, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1UploadFilesFromurlResponse">UploadFilesFromurlResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Uploads one or more files to <a href="/content/tools/kifs/">KiFS</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1VerifyBackupResponse">VerifyBackupResponse</a> </td>
        <td><a href="#af5f5b0c2a7e2038b7155c5c0cd9df915">verifyBackup</a> (const <a href="/content/api/cpp/structgpudb_1_1VerifyBackupRequest">VerifyBackupRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Inspects the requested database <a href="/content/admin/backup_restore/#database-backup">backup(s)</a> for conformity at the remote file store accessible via the <a href="/content/concepts/data_sources/">data source</a> specified by <a href="/content/api/cpp/structgpudb_1_1VerifyBackupRequest#a11a6275bcd3c4cb59398efd08ceaa24b">datasourceName</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1VerifyBackupResponse">VerifyBackupResponse</a> & </td>
        <td><a href="#a285a2814137c3c2bfb4b72f12f3821ca">verifyBackup</a> (const <a href="/content/api/cpp/structgpudb_1_1VerifyBackupRequest">VerifyBackupRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1VerifyBackupResponse">VerifyBackupResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Inspects the requested database <a href="/content/admin/backup_restore/#database-backup">backup(s)</a> for conformity at the remote file store accessible via the <a href="/content/concepts/data_sources/">data source</a> specified by <a href="/content/api/cpp/structgpudb_1_1VerifyBackupRequest#a11a6275bcd3c4cb59398efd08ceaa24b">datasourceName</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1VerifyBackupResponse">VerifyBackupResponse</a> </td>
        <td><a href="#a325cc59d8043c7103b453f94e822e341">verifyBackup</a> (const std::string \&backupName, const std::string \&datasourceName, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Inspects the requested database <a href="/content/admin/backup_restore/#database-backup">backup(s)</a> for conformity at the remote file store accessible via the <a href="/content/concepts/data_sources/">data source</a> specified by <span>datasourceName</span>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1VerifyBackupResponse">VerifyBackupResponse</a> & </td>
        <td><a href="#ac9214f0312c763965a52b68aa3c543d2">verifyBackup</a> (const std::string \&backupName, const std::string \&datasourceName, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1VerifyBackupResponse">VerifyBackupResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Inspects the requested database <a href="/content/admin/backup_restore/#database-backup">backup(s)</a> for conformity at the remote file store accessible via the <a href="/content/concepts/data_sources/">data source</a> specified by <span>datasourceName</span>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1VisualizeImageChartResponse">VisualizeImageChartResponse</a> </td>
        <td><a href="#a0bea9319cd2f5900e19533884300e13f">visualizeImageChart</a> (const <a href="/content/api/cpp/structgpudb_1_1VisualizeImageChartRequest">VisualizeImageChartRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Scatter plot is the only plot type currently supported. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1VisualizeImageChartResponse">VisualizeImageChartResponse</a> & </td>
        <td><a href="#ad7745a14c70622d3955074e6a0aa6891">visualizeImageChart</a> (const <a href="/content/api/cpp/structgpudb_1_1VisualizeImageChartRequest">VisualizeImageChartRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1VisualizeImageChartResponse">VisualizeImageChartResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Scatter plot is the only plot type currently supported. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1VisualizeImageChartResponse">VisualizeImageChartResponse</a> </td>
        <td><a href="#a20b374fed345959518ae9d1096be279b">visualizeImageChart</a> (const std::string \&tableName, const std::vector\< std::string > \&xColumnNames, const std::vector\< std::string > \&yColumnNames, const double minX, const double maxX, const double minY, const double maxY, const int32\_t width, const int32\_t height, const std::string \&bgColor, const std::map\< std::string, std::vector\< std::string > > \&styleOptions, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Scatter plot is the only plot type currently supported. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1VisualizeImageChartResponse">VisualizeImageChartResponse</a> & </td>
        <td><a href="#a80e96dec306141c781a60f3e0c7992ea">visualizeImageChart</a> (const std::string \&tableName, const std::vector\< std::string > \&xColumnNames, const std::vector\< std::string > \&yColumnNames, const double minX, const double maxX, const double minY, const double maxY, const int32\_t width, const int32\_t height, const std::string \&bgColor, const std::map\< std::string, std::vector\< std::string > > \&styleOptions, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1VisualizeImageChartResponse">VisualizeImageChartResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Scatter plot is the only plot type currently supported. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1VisualizeIsochroneResponse">VisualizeIsochroneResponse</a> </td>
        <td><a href="#ac318fcde27f507588dfb91ad77308c5f">visualizeIsochrone</a> (const <a href="/content/api/cpp/structgpudb_1_1VisualizeIsochroneRequest">VisualizeIsochroneRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Generate an image containing isolines for travel results using an existing graph. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1VisualizeIsochroneResponse">VisualizeIsochroneResponse</a> & </td>
        <td><a href="#a58538642cadb57489acbe03ce689d962">visualizeIsochrone</a> (const <a href="/content/api/cpp/structgpudb_1_1VisualizeIsochroneRequest">VisualizeIsochroneRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1VisualizeIsochroneResponse">VisualizeIsochroneResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Generate an image containing isolines for travel results using an existing graph. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1VisualizeIsochroneResponse">VisualizeIsochroneResponse</a> </td>
        <td><a href="#a04b488ae226bdc96633664a0bfcadbf3">visualizeIsochrone</a> (const std::string \&graphName, const std::string \&sourceNode, const double maxSolutionRadius, const std::vector\< std::string > \&weightsOnEdges, const std::vector\< std::string > \&restrictions, const int32\_t numLevels, const bool generateImage, const std::string \&levelsTable, const std::map\< std::string, std::string > \&styleOptions, const std::map\< std::string, std::string > \&solveOptions, const std::map\< std::string, std::string > \&contourOptions, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Generate an image containing isolines for travel results using an existing graph. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1VisualizeIsochroneResponse">VisualizeIsochroneResponse</a> & </td>
        <td><a href="#af3bd3855cefca33f965baebef3c366b1">visualizeIsochrone</a> (const std::string \&graphName, const std::string \&sourceNode, const double maxSolutionRadius, const std::vector\< std::string > \&weightsOnEdges, const std::vector\< std::string > \&restrictions, const int32\_t numLevels, const bool generateImage, const std::string \&levelsTable, const std::map\< std::string, std::string > \&styleOptions, const std::map\< std::string, std::string > \&solveOptions, const std::map\< std::string, std::string > \&contourOptions, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1VisualizeIsochroneResponse">VisualizeIsochroneResponse</a> \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Generate an image containing isolines for travel results using an existing graph. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>void </td>
        <td><a href="#a4f21b8f81c8ed7ff7b90d6b3d6261a16">addKnownType</a> (const std::string \&typeId, const avro::DecoderPtr \&decoder)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>template\<typename T> </td>
      </tr>

      <tr>
        <td>void </td>
        <td><a href="#ac07bd2d8483242e11a256cf07d5c0d58">addKnownType</a> (const std::string \&typeId)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>template\<typename T> </td>
      </tr>

      <tr>
        <td>void </td>
        <td><a href="#aab28e75da6b086ffe5c56adf3f6f165f">addKnownType</a> (const std::string \&typeId, const std::string \&schemaString)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>template\<typename T> </td>
      </tr>

      <tr>
        <td>void </td>
        <td><a href="#a20dd51b39fac65820cb87f17449c52ef">addKnownType</a> (const std::string \&typeId, const ::avro::ValidSchema \&schema)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>void </td>
        <td><a href="#a92320ecf0d3208eb4c9f4ccacd227181">addKnownTypeFromTable</a> (const std::string \&tableName, const avro::DecoderPtr \&decoder)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>template\<typename T> </td>
      </tr>

      <tr>
        <td>void </td>
        <td><a href="#a0947379b2104ab063ec6156177d3729e">addKnownTypeFromTable</a> (const std::string \&tableName)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>template\<typename T> </td>
      </tr>

      <tr>
        <td>void </td>
        <td><a href="#a7a9cafded65f3e76875e88bacedfcf01">addKnownTypeFromTable</a> (const std::string \&tableName, const std::string \&schemaString)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>template\<typename T> </td>
      </tr>

      <tr>
        <td>void </td>
        <td><a href="#ac5c6b76917a0e9692770db53dfce96de">addKnownTypeFromTable</a> (const std::string \&tableName, const ::avro::ValidSchema \&schema)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>template\<> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsResponse">GetRecordsResponse</a>\< boost::any > </td>
        <td><a href="#a204d2b665c241c66b952293d9d65ec38">getRecords</a> (const <a href="/content/api/cpp/structgpudb_1_1GetRecordsRequest">GetRecordsRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Retrieves records from a given table, optionally filtered by an expression and/or sorted by a column. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>template\<> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsResponse">GetRecordsResponse</a>\< boost::any > & </td>
        <td><a href="#afc3176fa3a92ad385f38d919715c66f8">getRecords</a> (const <a href="/content/api/cpp/structgpudb_1_1GetRecordsRequest">GetRecordsRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1GetRecordsResponse">GetRecordsResponse</a>\< boost::any > \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Retrieves records from a given table, optionally filtered by an expression and/or sorted by a column. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>template\<> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsResponse">GetRecordsResponse</a>\< boost::any > </td>
        <td><a href="#a107ec3b0e2c145dfa5d270a6b33e84dd">getRecords</a> (const std::string \&tableName, const int64\_t offset, const int64\_t limit, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Retrieves records from a given table, optionally filtered by an expression and/or sorted by a column. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>template\<> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsResponse">GetRecordsResponse</a>\< boost::any > & </td>
        <td><a href="#a8f7abc694bbb4922746cc565234cbe08">getRecords</a> (const std::string \&tableName, const int64\_t offset, const int64\_t limit, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1GetRecordsResponse">GetRecordsResponse</a>\< boost::any > \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Retrieves records from a given table, optionally filtered by an expression and/or sorted by a column. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>template\<> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesResponse">GetRecordsBySeriesResponse</a>\< boost::any > </td>
        <td><a href="#a5448180a122ebb057c93818e361042f2">getRecordsBySeries</a> (const <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest">GetRecordsBySeriesRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Retrieves the complete series/track records from the given <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest#a95d1e31e27c1d040de81b0ac7bd0d5ea">worldTableName</a> based on the partial track information contained in the <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest#a841767ddf7d2fe03d6531fd9cc1e48f0">tableName</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>template\<> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesResponse">GetRecordsBySeriesResponse</a>\< boost::any > & </td>
        <td><a href="#a4472cedbdb7c41b76b7469d845cf89bb">getRecordsBySeries</a> (const <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest">GetRecordsBySeriesRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesResponse">GetRecordsBySeriesResponse</a>\< boost::any > \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Retrieves the complete series/track records from the given <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest#a95d1e31e27c1d040de81b0ac7bd0d5ea">worldTableName</a> based on the partial track information contained in the <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest#a841767ddf7d2fe03d6531fd9cc1e48f0">tableName</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>template\<> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesResponse">GetRecordsBySeriesResponse</a>\< boost::any > </td>
        <td><a href="#a8b19920b585e87bcc6cfe6468f2eddb2">getRecordsBySeries</a> (const std::string \&tableName, const std::string \&worldTableName, const int32\_t offset, const int32\_t limit, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Retrieves the complete series/track records from the given <span>worldTableName</span> based on the partial track information contained in the <span>tableName</span>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>template\<> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesResponse">GetRecordsBySeriesResponse</a>\< boost::any > & </td>
        <td><a href="#aa7203f56d0aa4580270a3b957d80701f">getRecordsBySeries</a> (const std::string \&tableName, const std::string \&worldTableName, const int32\_t offset, const int32\_t limit, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesResponse">GetRecordsBySeriesResponse</a>\< boost::any > \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Retrieves the complete series/track records from the given <span>worldTableName</span> based on the partial track information contained in the <span>tableName</span>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>template\<> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionResponse">GetRecordsFromCollectionResponse</a>\< boost::any > </td>
        <td><a href="#aaa7b31e43eaf534a9a0965f5984d43ff">getRecordsFromCollection</a> (const <a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionRequest">GetRecordsFromCollectionRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Retrieves records from a collection. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>template\<> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionResponse">GetRecordsFromCollectionResponse</a>\< boost::any > & </td>
        <td><a href="#a7425d039e0e34fca7b910bcd958a30e5">getRecordsFromCollection</a> (const <a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionRequest">GetRecordsFromCollectionRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionResponse">GetRecordsFromCollectionResponse</a>\< boost::any > \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Retrieves records from a collection. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>template\<> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionResponse">GetRecordsFromCollectionResponse</a>\< boost::any > </td>
        <td><a href="#a2981090225cf80548a10e8d35ed3d8a4">getRecordsFromCollection</a> (const std::string \&tableName, const int64\_t offset, const int64\_t limit, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Retrieves records from a collection. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>template\<> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionResponse">GetRecordsFromCollectionResponse</a>\< boost::any > & </td>
        <td><a href="#a551401d018ca79303a27b3b504d2288a">getRecordsFromCollection</a> (const std::string \&tableName, const int64\_t offset, const int64\_t limit, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionResponse">GetRecordsFromCollectionResponse</a>\< boost::any > \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Retrieves records from a collection. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>template\<> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsResponse">GetRecordsResponse</a>\< boost::any > </td>
        <td><a href="#a204d2b665c241c66b952293d9d65ec38">getRecords</a> (const <a href="/content/api/cpp/structgpudb_1_1GetRecordsRequest">GetRecordsRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Retrieves records from a given table, optionally filtered by an expression and/or sorted by a column. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>template\<> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsResponse">GetRecordsResponse</a>\< boost::any > & </td>
        <td><a href="#afc3176fa3a92ad385f38d919715c66f8">getRecords</a> (const <a href="/content/api/cpp/structgpudb_1_1GetRecordsRequest">GetRecordsRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1GetRecordsResponse">GetRecordsResponse</a>\< boost::any > \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Retrieves records from a given table, optionally filtered by an expression and/or sorted by a column. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>template\<> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsResponse">GetRecordsResponse</a>\< boost::any > </td>
        <td><a href="#a107ec3b0e2c145dfa5d270a6b33e84dd">getRecords</a> (const std::string \&tableName, const int64\_t offset, const int64\_t limit, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Retrieves records from a given table, optionally filtered by an expression and/or sorted by a column. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>template\<> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsResponse">GetRecordsResponse</a>\< boost::any > & </td>
        <td><a href="#a8f7abc694bbb4922746cc565234cbe08">getRecords</a> (const std::string \&tableName, const int64\_t offset, const int64\_t limit, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1GetRecordsResponse">GetRecordsResponse</a>\< boost::any > \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Retrieves records from a given table, optionally filtered by an expression and/or sorted by a column. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>template\<> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesResponse">GetRecordsBySeriesResponse</a>\< boost::any > </td>
        <td><a href="#a5448180a122ebb057c93818e361042f2">getRecordsBySeries</a> (const <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest">GetRecordsBySeriesRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Retrieves the complete series/track records from the given <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest#a95d1e31e27c1d040de81b0ac7bd0d5ea">worldTableName</a> based on the partial track information contained in the <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest#a841767ddf7d2fe03d6531fd9cc1e48f0">tableName</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>template\<> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesResponse">GetRecordsBySeriesResponse</a>\< boost::any > & </td>
        <td><a href="#a4472cedbdb7c41b76b7469d845cf89bb">getRecordsBySeries</a> (const <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest">GetRecordsBySeriesRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesResponse">GetRecordsBySeriesResponse</a>\< boost::any > \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Retrieves the complete series/track records from the given <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest#a95d1e31e27c1d040de81b0ac7bd0d5ea">worldTableName</a> based on the partial track information contained in the <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest#a841767ddf7d2fe03d6531fd9cc1e48f0">tableName</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>template\<> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesResponse">GetRecordsBySeriesResponse</a>\< boost::any > </td>
        <td><a href="#a8b19920b585e87bcc6cfe6468f2eddb2">getRecordsBySeries</a> (const std::string \&tableName, const std::string \&worldTableName, const int32\_t offset, const int32\_t limit, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Retrieves the complete series/track records from the given <span>worldTableName</span> based on the partial track information contained in the <span>tableName</span>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>template\<> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesResponse">GetRecordsBySeriesResponse</a>\< boost::any > & </td>
        <td><a href="#aa7203f56d0aa4580270a3b957d80701f">getRecordsBySeries</a> (const std::string \&tableName, const std::string \&worldTableName, const int32\_t offset, const int32\_t limit, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesResponse">GetRecordsBySeriesResponse</a>\< boost::any > \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Retrieves the complete series/track records from the given <span>worldTableName</span> based on the partial track information contained in the <span>tableName</span>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>template\<> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionResponse">GetRecordsFromCollectionResponse</a>\< boost::any > </td>
        <td><a href="#aaa7b31e43eaf534a9a0965f5984d43ff">getRecordsFromCollection</a> (const <a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionRequest">GetRecordsFromCollectionRequest</a> \&request\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Retrieves records from a collection. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>template\<> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionResponse">GetRecordsFromCollectionResponse</a>\< boost::any > & </td>
        <td><a href="#a7425d039e0e34fca7b910bcd958a30e5">getRecordsFromCollection</a> (const <a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionRequest">GetRecordsFromCollectionRequest</a> \&request\_, <a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionResponse">GetRecordsFromCollectionResponse</a>\< boost::any > \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Retrieves records from a collection. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>template\<> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionResponse">GetRecordsFromCollectionResponse</a>\< boost::any > </td>
        <td><a href="#a2981090225cf80548a10e8d35ed3d8a4">getRecordsFromCollection</a> (const std::string \&tableName, const int64\_t offset, const int64\_t limit, const std::map\< std::string, std::string > \&options) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Retrieves records from a collection. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>template\<> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionResponse">GetRecordsFromCollectionResponse</a>\< boost::any > & </td>
        <td><a href="#a551401d018ca79303a27b3b504d2288a">getRecordsFromCollection</a> (const std::string \&tableName, const int64\_t offset, const int64\_t limit, const std::map\< std::string, std::string > \&options, <a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionResponse">GetRecordsFromCollectionResponse</a>\< boost::any > \&response\_) const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Retrieves records from a collection. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>
    </table>

    <table>
      <tr>
        <td>
          <h2> Static Public Member Functions</h2>
        </td>
      </tr>

      <tr>
        <td>static std::string </td>
        <td><a href="#aa43463a086aefafc7d123795fa543764">getApiVersion</a> ()</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>static std::string </td>
        <td><a href="#a3d9092f061ebd3e72c0f6f1db3709f6e">sanitizeUserAgentToken</a> (const std::string \&value)</td>
      </tr>

      <tr>
        <td> </td>
        <td>Sanitizes a token for use in the User-Agent header by replacing disallowed characters with underscores. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>
    </table>

    <table>
      <tr>
        <td>
          <h2> Static Public Attributes</h2>
        </td>
      </tr>

      <tr>
        <td>static const int64\_t </td>
        <td><a href="#a17cf9ebfe00819bb097974e7e489ed4c">END\_OF\_SET</a> = -9999</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>static const std::string </td>
        <td><a href="#abb07a4cacb0463c2ed1c90cfc55babe0">DB\_CONNECTION\_RESET\_ERROR\_MESSAGE</a></td>
      </tr>

      <tr>
        <td> </td>
        <td>Special error messages indicating that a connection failure happened (generally should trigger a high-availability failover if applicable) <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>static const std::string </td>
        <td><a href="#ac1195274295b2f4afb72b6ddeca3cd47">DB\_CONNECTION\_REFUSED\_ERROR\_MESSAGE</a></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>static const std::string </td>
        <td><a href="#a9aac43bdb59a1b520df4b93b45d6e5f6">DB\_EXITING\_ERROR\_MESSAGE</a></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>static const std::string </td>
        <td><a href="#a4adf3bf6a65b64377e0dd74c2bde116c">DB\_OFFLINE\_ERROR\_MESSAGE</a></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>static const std::string </td>
        <td><a href="#a7ec05fd685e80f87bca35fdc805dea9a">DB\_SYSTEM\_LIMITED\_ERROR\_MESSAGE</a></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>static const std::string </td>
        <td><a href="#a0fdffb69f3b093816535e116a873c2fc">DB\_HM\_OFFLINE\_ERROR\_MESSAGE</a></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>static const std::string </td>
        <td><a href="#aad94aa5b2c6962807f9f798a9121e85d">DB\_DRAINING\_HA\_QUEUE\_ERROR\_MESSAGE</a></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>static const std::string </td>
        <td><a href="#a9a2b0a48fee2096d6104a276c818a946">DB\_SHUTTING\_DOWN\_ERROR\_MESSAGE</a></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>static const std::string </td>
        <td><a href="#a6735918a5c9686b6961baa89f35d49ce">DB\_QUERY\_PLANNER\_ERROR\_MESSAGE</a></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>static const std::string </td>
        <td><a href="#a3d5f074e0926e6aee5e749b54ed0c651">HEADER\_AUTHORIZATION</a></td>
      </tr>

      <tr>
        <td> </td>
        <td>Headers used internally; MUST add each of them to PROTECTED\_HEADERS in the .cpp file. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>static const std::string </td>
        <td><a href="#a43a98d96248d5565df04e2d99cce0efb">HEADER\_CONTENT\_TYPE</a></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>static const std::string </td>
        <td><a href="#ac440e0e4cdde8ba0be2b595270a6ea38">HEADER\_CONTENT\_LENGTH</a></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>static const std::string </td>
        <td><a href="#a73c703169b362238b268caefcb381743">HEADER\_HA\_SYNC\_MODE</a></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>static const std::string </td>
        <td><a href="#afe0a7acb915810dfb74a31e4c786dcb4">HEADER\_USER\_AGENT</a></td>
      </tr>

      <tr>
        <td> </td>
      </tr>
    </table>

    <table>
      <tr>
        <td>
          <h2> Friends</h2>
        </td>
      </tr>

      <tr>
        <td>class </td>
        <td><a href="#af978370cd5d6f902b6e48caad00d1a30">FailbackPollerService</a></td>
      </tr>

      <tr>
        <td> </td>
      </tr>
    </table>

    <h2>Detailed Description</h2>

    <div>
      <p>Definition at line <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp#L59">59</a> of file <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">GPUdb.hpp</a>.</p>
    </div>

    <h2>Member Enumeration Documentation</h2>
    <h2><span><a href="#a37626bfbd9c5e1decfcd08d7851e6719">◆ </a></span>HASynchronicityMode</h2>

    <div>
      <div>
        <table>
          <tr>
            <td>enum <a href="#a37626bfbd9c5e1decfcd08d7851e6719">gpudb::GPUdb::HASynchronicityMode</a></td>
          </tr>
        </table>
      </div>

      <div>
        <p>A enumeration of high-availability synchronicity override modes. </p>

        <div>
          <div>See also</div>
          <div><a href="#a71ebc6d06dede4f22358d47abf91d66f" title="Sets the high-availability synchronization mode which will override the default mode.">setHASyncMode</a></div>
        </div>

        <table>
          <tr>
            <th>Enumerator</th>
          </tr>

          <tr>
            <td>DEFAULT </td>

            <td>
              <p>No override; defer to the HA process for synchronizing endpoints (which has different logic for different endpoints) </p>
            </td>
          </tr>

          <tr>
            <td>NONE </td>

            <td>
              <p>Explicitly do NOT replicate across the HA cluster. </p>
            </td>
          </tr>

          <tr>
            <td>SYNCHRONOUS </td>

            <td>
              <p>Synchronize all endpoint calls. </p>
            </td>
          </tr>

          <tr>
            <td>SYNCHRONOUS\_PARALLEL </td>

            <td>
              <p>Sends a http request directly to each cluster, executes the query locally, and waits for the response from each cluster. </p>
            </td>
          </tr>

          <tr>
            <td>ASYNCHRONOUS </td>

            <td>
              <p>Do NOT synchronize any endpoint call. </p>
            </td>
          </tr>

          <tr>
            <td>ASYNCHRONOUS\_PARALLEL </td>

            <td>
              <p>Queues a request to RMQ for each cluster, executes the query locally, and returns to the user. </p>
            </td>
          </tr>
        </table>

        <p>Definition at line <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp#L146">146</a> of file <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">GPUdb.hpp</a>.</p>
      </div>
    </div>

    <h2>Constructor & Destructor Documentation</h2>
    <h2><span><a href="#a4fba86159e87456ae7d24f89d9ad4ac3">◆ </a></span>GPUdb() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>gpudb::GPUdb::GPUdb </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/classgpudb_1_1HttpUrl">HttpUrl</a> &</td>
            <td><span><span>url</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const <a href="/content/api/cpp/classgpudb_1_1GPUdb_1_1Options">Options</a> &</td>
            <td><span><span>options</span></span><span> = </span><span><a href="/content/api/cpp/classgpudb_1_1GPUdb_1_1Options">Options</a>()</span> )</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Pass a single HttpURL and options to instantiate a <a href="/content/api/cpp/classgpudb_1_1GPUdb">GPUdb</a> object. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>url</td>
                <td>An HttpURL object containing the single host URL for the client. If no primary URL is specified via the options, the given URL will be used as the primary URL. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>An optional <a href="/content/api/cpp/classgpudb_1_1GPUdb_1_1Options">GPUdb::Options</a> object containing options, e.g. primary cluster URL, used to the create the <a href="/content/api/cpp/classgpudb_1_1GPUdb">GPUdb</a> object. </td>
              </tr>
            </table>
          </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a6b64b5387568345b97a16cbb75355544">◆ </a></span>GPUdb() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>gpudb::GPUdb::GPUdb </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>url</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const <a href="/content/api/cpp/classgpudb_1_1GPUdb_1_1Options">Options</a> &</td>
            <td><span><span>options</span></span><span> = </span><span><a href="/content/api/cpp/classgpudb_1_1GPUdb_1_1Options">Options</a>()</span> )</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Pass a single or multiple, comma-separated URLs as a string and optional options to instantiate a <a href="/content/api/cpp/classgpudb_1_1GPUdb">GPUdb</a> object. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>url</td>
                <td>An std::string containing the one host URL or a comma-separated string with multiple host URLs for the client. For example '<a href="http://172.42.40.1:9191,,http://172.42.40.2:9191'">[http://172.42.40.1:9191,,http://172.42.40.2:9191](http://172.42.40.1:9191,,http://172.42.40.2:9191)'</a>. If a single URL is given, and no primary URL is specified via the options, the given URL will be used as the primary URL. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>An optional <a href="/content/api/cpp/classgpudb_1_1GPUdb_1_1Options">GPUdb::Options</a> object containing options, e.g. primary cluster URL, used to the create the <a href="/content/api/cpp/classgpudb_1_1GPUdb">GPUdb</a> object. </td>
              </tr>
            </table>
          </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a4615d61b10db20286a0a8ebea681a2b8">◆ </a></span>GPUdb() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>gpudb::GPUdb::GPUdb </td>
            <td>(</td>
            <td>const std::vector\< <a href="/content/api/cpp/classgpudb_1_1HttpUrl">HttpUrl</a> > &</td>
            <td><span><span>urls</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const <a href="/content/api/cpp/classgpudb_1_1GPUdb_1_1Options">Options</a> &</td>
            <td><span><span>options</span></span><span> = </span><span><a href="/content/api/cpp/classgpudb_1_1GPUdb_1_1Options">Options</a>()</span> )</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Pass multiple HttpURLs and optional options to instantiate a <a href="/content/api/cpp/classgpudb_1_1GPUdb">GPUdb</a> object. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>urls</td>
                <td>The host URLs for the client. If a single URL is given, and no primary URL is specified via the options, the given URL will be used as the primary URL. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>An optional <a href="/content/api/cpp/classgpudb_1_1GPUdb_1_1Options">GPUdb::Options</a> object containing options, e.g. primary cluster URL, used to the create the <a href="/content/api/cpp/classgpudb_1_1GPUdb">GPUdb</a> object. </td>
              </tr>
            </table>
          </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#af29ae0379d62e6b54e8434631f834f5f">◆ </a></span>GPUdb() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>gpudb::GPUdb::GPUdb </td>
            <td>(</td>
            <td>const std::vector\< std::string > &</td>
            <td><span><span>urls</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const <a href="/content/api/cpp/classgpudb_1_1GPUdb_1_1Options">Options</a> &</td>
            <td><span><span>options</span></span><span> = </span><span><a href="/content/api/cpp/classgpudb_1_1GPUdb_1_1Options">Options</a>()</span> )</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Pass multiple strings, each containing a single URL, and optional options to instantiate a <a href="/content/api/cpp/classgpudb_1_1GPUdb">GPUdb</a> object. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>urls</td>
                <td>The host URLs for the client. Each string must contain a single valid URL. If a single URL is given, and no primary URL is specified via the options, the given URL will be used as the primary URL. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>An optional <a href="/content/api/cpp/classgpudb_1_1GPUdb_1_1Options">GPUdb::Options</a> object containing options, e.g. primary cluster URL, used to the create the <a href="/content/api/cpp/classgpudb_1_1GPUdb">GPUdb</a> object. </td>
              </tr>
            </table>
          </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#aefad1360e3a2d96860413a6f3c08a2ce">◆ </a></span>\~GPUdb()</h2>

    <div>
      <div>
        <table>
          <tr>
            <td>gpudb::GPUdb::\~GPUdb </td>
            <td>(</td>

            <td>
              <span>
                <span />
              </span>
            </td>

            <td>)</td>

            <td />
          </tr>
        </table>
      </div>

      <div>
        <p>Destructor. </p>
      </div>
    </div>

    <h2>Member Function Documentation</h2>
    <h2><span><a href="#a949cbb204510e4011233952fb00dc7f3">◆ </a></span>addHttpHeader()</h2>

    <div>
      <div>
        <table>
          <tr>
            <td>void gpudb::GPUdb::addHttpHeader </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>header</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>value</span></span> )</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Adds an HTTP header to the map of additional HTTP headers to send to <a href="/content/api/cpp/classgpudb_1_1GPUdb">GPUdb</a> with each request. </p>
        <p>If the header is already in the map, its value is replaced with the specified value. The user is not allowed to modify the following headers: </p>

        <ul>
          <li> Authorization </li>
          <li> Content-type </li>
          <li> Content-length </li>
          <li> ha\_sync\_mode </li>
        </ul>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>header</td>
                <td>the HTTP header </td>
              </tr>

              <tr>
                <td>value</td>
                <td>the value of the HTTP header</td>
              </tr>
            </table>
          </div>
        </div>

        <p>See <code><a href="#a9a05888d893e2ca984609b1a836ae5ba">getHttpHeaders()</a></code> See <code><a href="#a04da24e61fee753e76aea8519c2ddb0c">removeHttpHeader(const std::string&)</a></code> </p>
      </div>
    </div>

    <h2><span><a href="#ac07bd2d8483242e11a256cf07d5c0d58">◆ </a></span>addKnownType() <span>\[1/4]</span></h2>

    <div>
      <div>
        <div> template\<typename T> </div>

        <table>
          <tr>
            <td>
              <table>
                <tr>
                  <td>void gpudb::GPUdb::addKnownType </td>
                  <td>(</td>
                  <td>const std::string &</td>
                  <td><span><span>typeId</span></span></td>
                  <td>)</td>

                  <td />
                </tr>
              </table>
            </td>

            <td> <span><span>inline</span></span> </td>
          </tr>
        </table>
      </div>

      <div>
        <p>Definition at line <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp#L535">535</a> of file <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">GPUdb.hpp</a>.</p>
      </div>
    </div>

    <h2><span><a href="#a20dd51b39fac65820cb87f17449c52ef">◆ </a></span>addKnownType() <span>\[2/4]</span></h2>

    <div>
      <div>
        <div> template\<typename T> </div>

        <table>
          <tr>
            <td>
              <table>
                <tr>
                  <td>void gpudb::GPUdb::addKnownType </td>
                  <td>(</td>
                  <td>const std::string &</td>
                  <td><span><span>typeId</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const ::avro::ValidSchema &</td>
                  <td><span><span>schema</span></span> )</td>
                </tr>
              </table>
            </td>

            <td> <span><span>inline</span></span> </td>
          </tr>
        </table>
      </div>

      <div>
        <p>Definition at line <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp#L547">547</a> of file <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">GPUdb.hpp</a>.</p>
      </div>
    </div>

    <h2><span><a href="#a4f21b8f81c8ed7ff7b90d6b3d6261a16">◆ </a></span>addKnownType() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>void gpudb::GPUdb::addKnownType </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>typeId</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const avro::DecoderPtr &</td>
            <td><span><span>decoder</span></span> )</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#aab28e75da6b086ffe5c56adf3f6f165f">◆ </a></span>addKnownType() <span>\[4/4]</span></h2>

    <div>
      <div>
        <div> template\<typename T> </div>

        <table>
          <tr>
            <td>
              <table>
                <tr>
                  <td>void gpudb::GPUdb::addKnownType </td>
                  <td>(</td>
                  <td>const std::string &</td>
                  <td><span><span>typeId</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const std::string &</td>
                  <td><span><span>schemaString</span></span> )</td>
                </tr>
              </table>
            </td>

            <td> <span><span>inline</span></span> </td>
          </tr>
        </table>
      </div>

      <div>
        <p>Definition at line <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp#L541">541</a> of file <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">GPUdb.hpp</a>.</p>
      </div>
    </div>

    <h2><span><a href="#a0947379b2104ab063ec6156177d3729e">◆ </a></span>addKnownTypeFromTable() <span>\[1/4]</span></h2>

    <div>
      <div>
        <div> template\<typename T> </div>

        <table>
          <tr>
            <td>
              <table>
                <tr>
                  <td>void gpudb::GPUdb::addKnownTypeFromTable </td>
                  <td>(</td>
                  <td>const std::string &</td>
                  <td><span><span>tableName</span></span></td>
                  <td>)</td>

                  <td />
                </tr>
              </table>
            </td>

            <td> <span><span>inline</span></span> </td>
          </tr>
        </table>
      </div>

      <div>
        <p>Definition at line <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp#L555">555</a> of file <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">GPUdb.hpp</a>.</p>
      </div>
    </div>

    <h2><span><a href="#ac5c6b76917a0e9692770db53dfce96de">◆ </a></span>addKnownTypeFromTable() <span>\[2/4]</span></h2>

    <div>
      <div>
        <div> template\<typename T> </div>

        <table>
          <tr>
            <td>
              <table>
                <tr>
                  <td>void gpudb::GPUdb::addKnownTypeFromTable </td>
                  <td>(</td>
                  <td>const std::string &</td>
                  <td><span><span>tableName</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const ::avro::ValidSchema &</td>
                  <td><span><span>schema</span></span> )</td>
                </tr>
              </table>
            </td>

            <td> <span><span>inline</span></span> </td>
          </tr>
        </table>
      </div>

      <div>
        <p>Definition at line <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp#L567">567</a> of file <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">GPUdb.hpp</a>.</p>
      </div>
    </div>

    <h2><span><a href="#a92320ecf0d3208eb4c9f4ccacd227181">◆ </a></span>addKnownTypeFromTable() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>void gpudb::GPUdb::addKnownTypeFromTable </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const avro::DecoderPtr &</td>
            <td><span><span>decoder</span></span> )</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#a7a9cafded65f3e76875e88bacedfcf01">◆ </a></span>addKnownTypeFromTable() <span>\[4/4]</span></h2>

    <div>
      <div>
        <div> template\<typename T> </div>

        <table>
          <tr>
            <td>
              <table>
                <tr>
                  <td>void gpudb::GPUdb::addKnownTypeFromTable </td>
                  <td>(</td>
                  <td>const std::string &</td>
                  <td><span><span>tableName</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const std::string &</td>
                  <td><span><span>schemaString</span></span> )</td>
                </tr>
              </table>
            </td>

            <td> <span><span>inline</span></span> </td>
          </tr>
        </table>
      </div>

      <div>
        <p>Definition at line <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp#L561">561</a> of file <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">GPUdb.hpp</a>.</p>
      </div>
    </div>

    <h2><span><a href="#a9ea80722f2b7f5f7ade6fc07c8b33dc3">◆ </a></span>adminAddHost() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AdminAddHostResponse">AdminAddHostResponse</a> gpudb::GPUdb::adminAddHost </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1AdminAddHostRequest">AdminAddHostRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Adds a host to an existing cluster. </p>

        <div>
          <div>Attention</div>
          <div>This method should be used for on-premise deployments only.</div>
        </div>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AdminAddHostRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AdminAddHostResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#aca748a594f8d487df215d9154157e4da">◆ </a></span>adminAddHost() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AdminAddHostResponse">AdminAddHostResponse</a> & gpudb::GPUdb::adminAddHost </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1AdminAddHostRequest">AdminAddHostRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1AdminAddHostResponse">AdminAddHostResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Adds a host to an existing cluster. </p>

        <div>
          <div>Attention</div>
          <div>This method should be used for on-premise deployments only.</div>
        </div>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AdminAddHostRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AdminAddHostResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AdminAddHostResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ac9004ae1ab277c012171fc322245ebc6">◆ </a></span>adminAddHost() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AdminAddHostResponse">AdminAddHostResponse</a> gpudb::GPUdb::adminAddHost </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>hostAddress</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Adds a host to an existing cluster. </p>

        <div>
          <div>Attention</div>
          <div>This method should be used for on-premise deployments only.</div>
        </div>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>hostAddress</td>
                <td>IP address of the host that will be added to the cluster. This host must have installed the same version of Kinetica as the cluster to which it is being added. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a6b9c4a4f28ff350e583ebabdbb9ea9d0">admin\_add\_host\_dry\_run</a>: If set to <a href="/content/api/cpp/namespacegpudb#afe33956c9bcada52ea76e180fc6207c4">true</a>, only validation checks will be performed. No host is added. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#afe33956c9bcada52ea76e180fc6207c4">admin\_add\_host\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a1a027fc195451fec3d35f4d665d1d1d0">admin\_add\_host\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a1a027fc195451fec3d35f4d665d1d1d0">admin\_add\_host\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a9d5d5f4e173c940b5b47e5582e18604c">admin\_add\_host\_accepts\_failover</a>: If set to <a href="/content/api/cpp/namespacegpudb#afe33956c9bcada52ea76e180fc6207c4">true</a>, the host will accept processes (ranks, graph server, etc.) in the event of a failover on another node in the cluster. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#afe33956c9bcada52ea76e180fc6207c4">admin\_add\_host\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a1a027fc195451fec3d35f4d665d1d1d0">admin\_add\_host\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a1a027fc195451fec3d35f4d665d1d1d0">admin\_add\_host\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#ae458957af8c057509db05fa618d440a0">admin\_add\_host\_public\_address</a>: The publicly-accessible IP address for the host being added, typically specified for clients using multi-head operations. This setting is required if any other host(s) in the cluster specify a public address. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a54bc9ac75ad2fee1ec35f8d1bcbf871a">admin\_add\_host\_host\_manager\_public\_url</a>: The publicly-accessible full path URL to the host manager on the host being added, e.g., '<a href="http://172.123.45.67:9300'">[http://172.123.45.67:9300](http://172.123.45.67:9300)'</a>. The default host manager port can be found in the <a href="/content/install/shared/ports/">list of ports</a> used by Kinetica. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ab668ed4429090f5a90dd9d6b09cf7654">admin\_add\_host\_ram\_limit</a>: The desired RAM limit for the host being added, i.e. the sum of RAM usage for all processes on the host will not be able to exceed this value. Supported units: K (thousand), KB (kilobytes), M (million), MB (megabytes), G (billion), GB (gigabytes); if no unit is provided, the value is assumed to be in bytes. For example, if <a href="/content/api/cpp/namespacegpudb#ab668ed4429090f5a90dd9d6b09cf7654">ram\_limit</a> is set to 10M, the resulting RAM limit is 10 million bytes. Set <a href="/content/api/cpp/namespacegpudb#ab668ed4429090f5a90dd9d6b09cf7654">ram\_limit</a> to -1 to have no RAM limit. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a3cab389d3f406fd4ae5d4578e7d25458">admin\_add\_host\_gpus</a>: Comma-delimited list of GPU indices (starting at 1) that are eligible for running worker processes. If left blank, all GPUs on the host being added will be eligible. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AdminAddHostResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ada6bcf7fc6df22d912b33dba0459dd50">◆ </a></span>adminAddHost() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AdminAddHostResponse">AdminAddHostResponse</a> & gpudb::GPUdb::adminAddHost </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>hostAddress</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1AdminAddHostResponse">AdminAddHostResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Adds a host to an existing cluster. </p>

        <div>
          <div>Attention</div>
          <div>This method should be used for on-premise deployments only.</div>
        </div>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>hostAddress</td>
                <td>IP address of the host that will be added to the cluster. This host must have installed the same version of Kinetica as the cluster to which it is being added. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a6b9c4a4f28ff350e583ebabdbb9ea9d0">admin\_add\_host\_dry\_run</a>: If set to <a href="/content/api/cpp/namespacegpudb#afe33956c9bcada52ea76e180fc6207c4">true</a>, only validation checks will be performed. No host is added. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#afe33956c9bcada52ea76e180fc6207c4">admin\_add\_host\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a1a027fc195451fec3d35f4d665d1d1d0">admin\_add\_host\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a1a027fc195451fec3d35f4d665d1d1d0">admin\_add\_host\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a9d5d5f4e173c940b5b47e5582e18604c">admin\_add\_host\_accepts\_failover</a>: If set to <a href="/content/api/cpp/namespacegpudb#afe33956c9bcada52ea76e180fc6207c4">true</a>, the host will accept processes (ranks, graph server, etc.) in the event of a failover on another node in the cluster. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#afe33956c9bcada52ea76e180fc6207c4">admin\_add\_host\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a1a027fc195451fec3d35f4d665d1d1d0">admin\_add\_host\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a1a027fc195451fec3d35f4d665d1d1d0">admin\_add\_host\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#ae458957af8c057509db05fa618d440a0">admin\_add\_host\_public\_address</a>: The publicly-accessible IP address for the host being added, typically specified for clients using multi-head operations. This setting is required if any other host(s) in the cluster specify a public address. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a54bc9ac75ad2fee1ec35f8d1bcbf871a">admin\_add\_host\_host\_manager\_public\_url</a>: The publicly-accessible full path URL to the host manager on the host being added, e.g., '<a href="http://172.123.45.67:9300'">[http://172.123.45.67:9300](http://172.123.45.67:9300)'</a>. The default host manager port can be found in the <a href="/content/install/shared/ports/">list of ports</a> used by Kinetica. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ab668ed4429090f5a90dd9d6b09cf7654">admin\_add\_host\_ram\_limit</a>: The desired RAM limit for the host being added, i.e. the sum of RAM usage for all processes on the host will not be able to exceed this value. Supported units: K (thousand), KB (kilobytes), M (million), MB (megabytes), G (billion), GB (gigabytes); if no unit is provided, the value is assumed to be in bytes. For example, if <a href="/content/api/cpp/namespacegpudb#ab668ed4429090f5a90dd9d6b09cf7654">ram\_limit</a> is set to 10M, the resulting RAM limit is 10 million bytes. Set <a href="/content/api/cpp/namespacegpudb#ab668ed4429090f5a90dd9d6b09cf7654">ram\_limit</a> to -1 to have no RAM limit. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a3cab389d3f406fd4ae5d4578e7d25458">admin\_add\_host\_gpus</a>: Comma-delimited list of GPU indices (starting at 1) that are eligible for running worker processes. If left blank, all GPUs on the host being added will be eligible. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AdminAddHostResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AdminAddHostResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a6278c393c68970163b7af72e4504235b">◆ </a></span>adminAddRanks() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AdminAddRanksResponse">AdminAddRanksResponse</a> gpudb::GPUdb::adminAddRanks </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1AdminAddRanksRequest">AdminAddRanksRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Add one or more ranks to an existing Kinetica cluster. </p>
        <p>The new ranks will not contain any data initially (other than replicated tables) and will not be assigned any shards. To rebalance data and shards across the cluster, use <a href="#a12ddec404e39c247d808318977c10d6b">adminRebalance</a>.</p>
        <p>The database must be offline for this operation, see <a href="#a9458238afaafde877e568a92d45abb75">adminOffline</a></p>
        <p>For example, if attempting to add three new ranks (two ranks on host 172.123.45.67 and one rank on host 172.123.45.68) to a Kinetica cluster with additional configuration parameters:</p>

        <ul>
          <li><a href="/content/api/cpp/structgpudb_1_1AdminAddRanksRequest#a235f555606ba1872e1e7af726346d60b">hosts</a> would be an array including 172.123.45.67 in the first two indices (signifying two ranks being added to host 172.123.45.67) and 172.123.45.68 in the last index (signifying one rank being added to host 172.123.45.67)</li>
          <li><a href="/content/api/cpp/structgpudb_1_1AdminAddRanksRequest#a91781e9348c1f357bbaeb977b26a98e1">configParams</a> would be an array of maps, with each map corresponding to the ranks being added in <a href="/content/api/cpp/structgpudb_1_1AdminAddRanksRequest#a235f555606ba1872e1e7af726346d60b">hosts</a>. The key of each map would be the configuration parameter name and the value would be the parameter's value, e.g. '"rank.gpu":"1"'</li>
        </ul>

        <p>This endpoint's processing includes copying all replicated table data to the new rank(s) and therefore could take a long time. The API call may time out if run directly. It is recommended to run this endpoint asynchronously via <a href="#a02ef4c58e395bbf2c83325cf592397af">createJob</a>.</p>

        <div>
          <div>Attention</div>
          <div>This method should be used for on-premise deployments only.</div>
        </div>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AdminAddRanksRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AdminAddRanksResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a3b5ba83013930fff00da5112434edae2">◆ </a></span>adminAddRanks() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AdminAddRanksResponse">AdminAddRanksResponse</a> & gpudb::GPUdb::adminAddRanks </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1AdminAddRanksRequest">AdminAddRanksRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1AdminAddRanksResponse">AdminAddRanksResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Add one or more ranks to an existing Kinetica cluster. </p>
        <p>The new ranks will not contain any data initially (other than replicated tables) and will not be assigned any shards. To rebalance data and shards across the cluster, use <a href="#a12ddec404e39c247d808318977c10d6b">adminRebalance</a>.</p>
        <p>The database must be offline for this operation, see <a href="#a9458238afaafde877e568a92d45abb75">adminOffline</a></p>
        <p>For example, if attempting to add three new ranks (two ranks on host 172.123.45.67 and one rank on host 172.123.45.68) to a Kinetica cluster with additional configuration parameters:</p>

        <ul>
          <li><a href="/content/api/cpp/structgpudb_1_1AdminAddRanksRequest#a235f555606ba1872e1e7af726346d60b">hosts</a> would be an array including 172.123.45.67 in the first two indices (signifying two ranks being added to host 172.123.45.67) and 172.123.45.68 in the last index (signifying one rank being added to host 172.123.45.67)</li>
          <li><a href="/content/api/cpp/structgpudb_1_1AdminAddRanksRequest#a91781e9348c1f357bbaeb977b26a98e1">configParams</a> would be an array of maps, with each map corresponding to the ranks being added in <a href="/content/api/cpp/structgpudb_1_1AdminAddRanksRequest#a235f555606ba1872e1e7af726346d60b">hosts</a>. The key of each map would be the configuration parameter name and the value would be the parameter's value, e.g. '"rank.gpu":"1"'</li>
        </ul>

        <p>This endpoint's processing includes copying all replicated table data to the new rank(s) and therefore could take a long time. The API call may time out if run directly. It is recommended to run this endpoint asynchronously via <a href="#a02ef4c58e395bbf2c83325cf592397af">createJob</a>.</p>

        <div>
          <div>Attention</div>
          <div>This method should be used for on-premise deployments only.</div>
        </div>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AdminAddRanksRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AdminAddRanksResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AdminAddRanksResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a4164e525e3c2551fe489a0504dc5e41f">◆ </a></span>adminAddRanks() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AdminAddRanksResponse">AdminAddRanksResponse</a> gpudb::GPUdb::adminAddRanks </td>
            <td>(</td>
            <td>const std::vector\< std::string > &</td>
            <td><span><span>hosts</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< std::map\< std::string, std::string > > &</td>
            <td><span><span>configParams</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Add one or more ranks to an existing Kinetica cluster. </p>
        <p>The new ranks will not contain any data initially (other than replicated tables) and will not be assigned any shards. To rebalance data and shards across the cluster, use <a href="#a8abfc8309fa07276967c988d6f316390">adminRebalance</a>.</p>
        <p>The database must be offline for this operation, see <a href="#a4d36ee318372b12d061552af95a2910c">adminOffline</a></p>
        <p>For example, if attempting to add three new ranks (two ranks on host 172.123.45.67 and one rank on host 172.123.45.68) to a Kinetica cluster with additional configuration parameters:</p>

        <ul>
          <li><span>hosts</span> would be an array including 172.123.45.67 in the first two indices (signifying two ranks being added to host 172.123.45.67) and 172.123.45.68 in the last index (signifying one rank being added to host 172.123.45.67)</li>
          <li><span>configParams</span> would be an array of maps, with each map corresponding to the ranks being added in <span>hosts</span>. The key of each map would be the configuration parameter name and the value would be the parameter's value, e.g. '"rank.gpu":"1"'</li>
        </ul>

        <p>This endpoint's processing includes copying all replicated table data to the new rank(s) and therefore could take a long time. The API call may time out if run directly. It is recommended to run this endpoint asynchronously via <a href="#a2807b0831529b2f2e6fb554339670763">createJob</a>.</p>

        <div>
          <div>Attention</div>
          <div>This method should be used for on-premise deployments only.</div>
        </div>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>hosts</td>
                <td>Array of host IP addresses (matching a hostN.address from the gpudb.conf file), or host identifiers (e.g. 'host0' from the gpudb.conf file), on which to add ranks to the cluster. The hosts must already be in the cluster. If needed beforehand, to add a new host to the cluster use <a href="#ac9004ae1ab277c012171fc322245ebc6">adminAddHost</a>. Include the same entry as many times as there are ranks to add to the cluster, e.g., if two ranks on host 172.123.45.67 should be added, <span>hosts</span> could look like '\["172.123.45.67", "172.123.45.67"]'. All ranks will be added simultaneously, i.e. they're not added in the order of this array. Each entry in this array corresponds to the entry at the same index in the <span>configParams</span>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>configParams</td>
                <td>Array of maps containing configuration parameters to apply to the new ranks found in <span>hosts</span>. For example, '"rank.gpu":"2", "tier.ram.rank.limit":"10000000000"'. Currently, the available parameters are rank-specific parameters in the <a href="/content/config/#config-main-network">Network</a>, <a href="/content/config/#config-main-hardware">Hardware</a>, <a href="/content/config/#config-main-text-search">Text Search</a>, and <a href="/content/config/#config-main-ram-tier">RAM Tiered Storage</a> sections in the gpudb.conf file, with the key exception of the 'rankN.host' settings in the Network section that will be determined by <span>hosts</span> instead. Though many of these configuration parameters typically are affixed with 'rankN' in the gpudb.conf file (where N is the rank number), the 'N' should be omitted in <span>configParams</span> as the new rank number(s) are not allocated until the ranks have been added to the cluster. Each entry in this array corresponds to the entry at the same index in the <span>hosts</span>. This array must either be completely empty or have the same number of elements as the <span>hosts</span>. An empty <span>configParams</span> array will result in the new ranks being set with default parameters. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a0de2975076bb989ff78dcba20d5dffa7">admin\_add\_ranks\_dry\_run</a>: If <a href="/content/api/cpp/namespacegpudb#a44ef24a11304d580b4e98f46d1beea7d">true</a>, only validation checks will be performed. No ranks are added. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a44ef24a11304d580b4e98f46d1beea7d">admin\_add\_ranks\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a292a5b353184dc0b1e8385df128c0e0b">admin\_add\_ranks\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a292a5b353184dc0b1e8385df128c0e0b">admin\_add\_ranks\_false</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AdminAddRanksResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a258d7e96b65d4a7220414f26858d2be3">◆ </a></span>adminAddRanks() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AdminAddRanksResponse">AdminAddRanksResponse</a> & gpudb::GPUdb::adminAddRanks </td>
            <td>(</td>
            <td>const std::vector\< std::string > &</td>
            <td><span><span>hosts</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< std::map\< std::string, std::string > > &</td>
            <td><span><span>configParams</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1AdminAddRanksResponse">AdminAddRanksResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Add one or more ranks to an existing Kinetica cluster. </p>
        <p>The new ranks will not contain any data initially (other than replicated tables) and will not be assigned any shards. To rebalance data and shards across the cluster, use <a href="#a8abfc8309fa07276967c988d6f316390">adminRebalance</a>.</p>
        <p>The database must be offline for this operation, see <a href="#a4d36ee318372b12d061552af95a2910c">adminOffline</a></p>
        <p>For example, if attempting to add three new ranks (two ranks on host 172.123.45.67 and one rank on host 172.123.45.68) to a Kinetica cluster with additional configuration parameters:</p>

        <ul>
          <li><span>hosts</span> would be an array including 172.123.45.67 in the first two indices (signifying two ranks being added to host 172.123.45.67) and 172.123.45.68 in the last index (signifying one rank being added to host 172.123.45.67)</li>
          <li><span>configParams</span> would be an array of maps, with each map corresponding to the ranks being added in <span>hosts</span>. The key of each map would be the configuration parameter name and the value would be the parameter's value, e.g. '"rank.gpu":"1"'</li>
        </ul>

        <p>This endpoint's processing includes copying all replicated table data to the new rank(s) and therefore could take a long time. The API call may time out if run directly. It is recommended to run this endpoint asynchronously via <a href="#a2807b0831529b2f2e6fb554339670763">createJob</a>.</p>

        <div>
          <div>Attention</div>
          <div>This method should be used for on-premise deployments only.</div>
        </div>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>hosts</td>
                <td>Array of host IP addresses (matching a hostN.address from the gpudb.conf file), or host identifiers (e.g. 'host0' from the gpudb.conf file), on which to add ranks to the cluster. The hosts must already be in the cluster. If needed beforehand, to add a new host to the cluster use <a href="#ac9004ae1ab277c012171fc322245ebc6">adminAddHost</a>. Include the same entry as many times as there are ranks to add to the cluster, e.g., if two ranks on host 172.123.45.67 should be added, <span>hosts</span> could look like '\["172.123.45.67", "172.123.45.67"]'. All ranks will be added simultaneously, i.e. they're not added in the order of this array. Each entry in this array corresponds to the entry at the same index in the <span>configParams</span>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>configParams</td>
                <td>Array of maps containing configuration parameters to apply to the new ranks found in <span>hosts</span>. For example, '"rank.gpu":"2", "tier.ram.rank.limit":"10000000000"'. Currently, the available parameters are rank-specific parameters in the <a href="/content/config/#config-main-network">Network</a>, <a href="/content/config/#config-main-hardware">Hardware</a>, <a href="/content/config/#config-main-text-search">Text Search</a>, and <a href="/content/config/#config-main-ram-tier">RAM Tiered Storage</a> sections in the gpudb.conf file, with the key exception of the 'rankN.host' settings in the Network section that will be determined by <span>hosts</span> instead. Though many of these configuration parameters typically are affixed with 'rankN' in the gpudb.conf file (where N is the rank number), the 'N' should be omitted in <span>configParams</span> as the new rank number(s) are not allocated until the ranks have been added to the cluster. Each entry in this array corresponds to the entry at the same index in the <span>hosts</span>. This array must either be completely empty or have the same number of elements as the <span>hosts</span>. An empty <span>configParams</span> array will result in the new ranks being set with default parameters. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a0de2975076bb989ff78dcba20d5dffa7">admin\_add\_ranks\_dry\_run</a>: If <a href="/content/api/cpp/namespacegpudb#a44ef24a11304d580b4e98f46d1beea7d">true</a>, only validation checks will be performed. No ranks are added. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a44ef24a11304d580b4e98f46d1beea7d">admin\_add\_ranks\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a292a5b353184dc0b1e8385df128c0e0b">admin\_add\_ranks\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a292a5b353184dc0b1e8385df128c0e0b">admin\_add\_ranks\_false</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AdminAddRanksResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AdminAddRanksResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ac3888c404412d7e4095a5298fc985533">◆ </a></span>adminAlterHost() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AdminAlterHostResponse">AdminAlterHostResponse</a> gpudb::GPUdb::adminAlterHost </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1AdminAlterHostRequest">AdminAlterHostRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Alter properties on an existing host in the cluster. </p>
        <p>Currently, the only property that can be altered is a hosts ability to accept failover processes.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AdminAlterHostRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AdminAlterHostResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#abe8d5b26c89c904d69e47d350fbd8a99">◆ </a></span>adminAlterHost() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AdminAlterHostResponse">AdminAlterHostResponse</a> & gpudb::GPUdb::adminAlterHost </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1AdminAlterHostRequest">AdminAlterHostRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1AdminAlterHostResponse">AdminAlterHostResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Alter properties on an existing host in the cluster. </p>
        <p>Currently, the only property that can be altered is a hosts ability to accept failover processes.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AdminAlterHostRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AdminAlterHostResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AdminAlterHostResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a2c34940d8cd5b11c42c518cbb7417930">◆ </a></span>adminAlterHost() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AdminAlterHostResponse">AdminAlterHostResponse</a> gpudb::GPUdb::adminAlterHost </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>host</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Alter properties on an existing host in the cluster. </p>
        <p>Currently, the only property that can be altered is a hosts ability to accept failover processes.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>host</td>
                <td>Identifies the host this applies to. Can be the host address, or formatted as 'hostN' where N is the host number as specified in gpudb.conf. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a23200136ca0f3b8117145e3541da8846">admin\_alter\_host\_accepts\_failover</a>: If set to <a href="/content/api/cpp/namespacegpudb#a3205582cf2412cf631505da3f866093b">true</a>, the host will accept processes (ranks, graph server, etc.) in the event of a failover on another node in the cluster. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a3205582cf2412cf631505da3f866093b">admin\_alter\_host\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a51342d54993c89e9eccd38d4453dc920">admin\_alter\_host\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a51342d54993c89e9eccd38d4453dc920">admin\_alter\_host\_false</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AdminAlterHostResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a45ba2c611f5cdc0089013bcd2193fcfb">◆ </a></span>adminAlterHost() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AdminAlterHostResponse">AdminAlterHostResponse</a> & gpudb::GPUdb::adminAlterHost </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>host</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1AdminAlterHostResponse">AdminAlterHostResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Alter properties on an existing host in the cluster. </p>
        <p>Currently, the only property that can be altered is a hosts ability to accept failover processes.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>host</td>
                <td>Identifies the host this applies to. Can be the host address, or formatted as 'hostN' where N is the host number as specified in gpudb.conf. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a23200136ca0f3b8117145e3541da8846">admin\_alter\_host\_accepts\_failover</a>: If set to <a href="/content/api/cpp/namespacegpudb#a3205582cf2412cf631505da3f866093b">true</a>, the host will accept processes (ranks, graph server, etc.) in the event of a failover on another node in the cluster. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a3205582cf2412cf631505da3f866093b">admin\_alter\_host\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a51342d54993c89e9eccd38d4453dc920">admin\_alter\_host\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a51342d54993c89e9eccd38d4453dc920">admin\_alter\_host\_false</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AdminAlterHostResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AdminAlterHostResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#af95f74ccf4ec9a3810077befea1e6e86">◆ </a></span>adminAlterJobs() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AdminAlterJobsResponse">AdminAlterJobsResponse</a> gpudb::GPUdb::adminAlterJobs </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1AdminAlterJobsRequest">AdminAlterJobsRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Perform the requested action on a list of one or more job(s). </p>
        <p>Based on the type of job and the current state of execution, the action may not be successfully executed. The final result of the attempted actions for each specified job is returned in the status array of the response. See <a href="/content/admin/job_manager/">Job Manager</a> for more information.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AdminAlterJobsRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AdminAlterJobsResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ac3b3fd11929c45c6db6ab13204a8631c">◆ </a></span>adminAlterJobs() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AdminAlterJobsResponse">AdminAlterJobsResponse</a> & gpudb::GPUdb::adminAlterJobs </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1AdminAlterJobsRequest">AdminAlterJobsRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1AdminAlterJobsResponse">AdminAlterJobsResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Perform the requested action on a list of one or more job(s). </p>
        <p>Based on the type of job and the current state of execution, the action may not be successfully executed. The final result of the attempted actions for each specified job is returned in the status array of the response. See <a href="/content/admin/job_manager/">Job Manager</a> for more information.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AdminAlterJobsRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AdminAlterJobsResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AdminAlterJobsResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a8d37fe50a8c815751abf99299179230d">◆ </a></span>adminAlterJobs() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AdminAlterJobsResponse">AdminAlterJobsResponse</a> gpudb::GPUdb::adminAlterJobs </td>
            <td>(</td>
            <td>const std::vector\< int64\_t > &</td>
            <td><span><span>jobIds</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>action</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Perform the requested action on a list of one or more job(s). </p>
        <p>Based on the type of job and the current state of execution, the action may not be successfully executed. The final result of the attempted actions for each specified job is returned in the status array of the response. See <a href="/content/admin/job_manager/">Job Manager</a> for more information.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>jobIds</td>
                <td>Jobs to be modified. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>action</td>

                <td>
                  Action to be performed on the jobs specified by job\_ids. Supported values:

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a65c6972ef975ae9442aab91a435e7485">admin\_alter\_jobs\_cancel</a> </li>
                  </ul>
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a72711973455dc32381a65161aa98b08d">admin\_alter\_jobs\_job\_tag</a>: Job tag returned in call to create the job. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AdminAlterJobsResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#aabf2b9dd9f3b5c2092f2e81d5c583dd2">◆ </a></span>adminAlterJobs() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AdminAlterJobsResponse">AdminAlterJobsResponse</a> & gpudb::GPUdb::adminAlterJobs </td>
            <td>(</td>
            <td>const std::vector\< int64\_t > &</td>
            <td><span><span>jobIds</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>action</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1AdminAlterJobsResponse">AdminAlterJobsResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Perform the requested action on a list of one or more job(s). </p>
        <p>Based on the type of job and the current state of execution, the action may not be successfully executed. The final result of the attempted actions for each specified job is returned in the status array of the response. See <a href="/content/admin/job_manager/">Job Manager</a> for more information.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>jobIds</td>
                <td>Jobs to be modified. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>action</td>

                <td>
                  Action to be performed on the jobs specified by job\_ids. Supported values:

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a65c6972ef975ae9442aab91a435e7485">admin\_alter\_jobs\_cancel</a> </li>
                  </ul>
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a72711973455dc32381a65161aa98b08d">admin\_alter\_jobs\_job\_tag</a>: Job tag returned in call to create the job. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AdminAlterJobsResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AdminAlterJobsResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a4092aceb8e29ca9f38b123929c3c776f">◆ </a></span>adminBackupBegin() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AdminBackupBeginResponse">AdminBackupBeginResponse</a> gpudb::GPUdb::adminBackupBegin </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1AdminBackupBeginRequest">AdminBackupBeginRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Prepares the system for a backup by closing all open file handles after allowing current active jobs to complete. </p>
        <p>When the database is in backup mode, queries that result in a disk write operation will be blocked until backup mode has been completed by using <a href="#ad1118f4fdb299a57ee85740f7ee35665">adminBackupEnd</a>.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AdminBackupBeginRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AdminBackupBeginResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#aac26b7f613238faffeaac9d8e051b432">◆ </a></span>adminBackupBegin() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AdminBackupBeginResponse">AdminBackupBeginResponse</a> & gpudb::GPUdb::adminBackupBegin </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1AdminBackupBeginRequest">AdminBackupBeginRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1AdminBackupBeginResponse">AdminBackupBeginResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Prepares the system for a backup by closing all open file handles after allowing current active jobs to complete. </p>
        <p>When the database is in backup mode, queries that result in a disk write operation will be blocked until backup mode has been completed by using <a href="#ad1118f4fdb299a57ee85740f7ee35665">adminBackupEnd</a>.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AdminBackupBeginRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AdminBackupBeginResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AdminBackupBeginResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a16e7e1682f6d135480d1ca3f56338cf9">◆ </a></span>adminBackupBegin() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AdminBackupBeginResponse">AdminBackupBeginResponse</a> gpudb::GPUdb::adminBackupBegin </td>
            <td>(</td>
            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Prepares the system for a backup by closing all open file handles after allowing current active jobs to complete. </p>
        <p>When the database is in backup mode, queries that result in a disk write operation will be blocked until backup mode has been completed by using <a href="#a775ff2f501c87d680d6b70b7f995b7e4">adminBackupEnd</a>.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AdminBackupBeginResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a076206de88a2924e531a5b275f9336e9">◆ </a></span>adminBackupBegin() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AdminBackupBeginResponse">AdminBackupBeginResponse</a> & gpudb::GPUdb::adminBackupBegin </td>
            <td>(</td>
            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1AdminBackupBeginResponse">AdminBackupBeginResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Prepares the system for a backup by closing all open file handles after allowing current active jobs to complete. </p>
        <p>When the database is in backup mode, queries that result in a disk write operation will be blocked until backup mode has been completed by using <a href="#a775ff2f501c87d680d6b70b7f995b7e4">adminBackupEnd</a>.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AdminBackupBeginResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AdminBackupBeginResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ad1118f4fdb299a57ee85740f7ee35665">◆ </a></span>adminBackupEnd() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AdminBackupEndResponse">AdminBackupEndResponse</a> gpudb::GPUdb::adminBackupEnd </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1AdminBackupEndRequest">AdminBackupEndRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Restores the system to normal operating mode after a backup has completed, allowing any queries that were blocked to complete. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AdminBackupEndRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AdminBackupEndResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a5b8ab88d3ce73e818cd7808770e5a961">◆ </a></span>adminBackupEnd() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AdminBackupEndResponse">AdminBackupEndResponse</a> & gpudb::GPUdb::adminBackupEnd </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1AdminBackupEndRequest">AdminBackupEndRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1AdminBackupEndResponse">AdminBackupEndResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Restores the system to normal operating mode after a backup has completed, allowing any queries that were blocked to complete. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AdminBackupEndRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AdminBackupEndResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AdminBackupEndResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a775ff2f501c87d680d6b70b7f995b7e4">◆ </a></span>adminBackupEnd() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AdminBackupEndResponse">AdminBackupEndResponse</a> gpudb::GPUdb::adminBackupEnd </td>
            <td>(</td>
            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Restores the system to normal operating mode after a backup has completed, allowing any queries that were blocked to complete. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AdminBackupEndResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a028b158a620013afe734e98fea607aca">◆ </a></span>adminBackupEnd() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AdminBackupEndResponse">AdminBackupEndResponse</a> & gpudb::GPUdb::adminBackupEnd </td>
            <td>(</td>
            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1AdminBackupEndResponse">AdminBackupEndResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Restores the system to normal operating mode after a backup has completed, allowing any queries that were blocked to complete. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AdminBackupEndResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AdminBackupEndResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#abe3d7c0c7fc2acb14bdc22e030dee0b5">◆ </a></span>adminHaOffline() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AdminHaOfflineResponse">AdminHaOfflineResponse</a> gpudb::GPUdb::adminHaOffline </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1AdminHaOfflineRequest">AdminHaOfflineRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Pauses consumption of messages from other HA clusters to support data repair/recovery scenarios. </p>
        <p>In-flight queries may fail to replicate to other clusters in the ring when going offline.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AdminHaOfflineRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AdminHaOfflineResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#acfc2a6a92f7019a18768ffe9c91478d1">◆ </a></span>adminHaOffline() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AdminHaOfflineResponse">AdminHaOfflineResponse</a> & gpudb::GPUdb::adminHaOffline </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1AdminHaOfflineRequest">AdminHaOfflineRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1AdminHaOfflineResponse">AdminHaOfflineResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Pauses consumption of messages from other HA clusters to support data repair/recovery scenarios. </p>
        <p>In-flight queries may fail to replicate to other clusters in the ring when going offline.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AdminHaOfflineRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AdminHaOfflineResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AdminHaOfflineResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a95662cd408cd6e50c823e6c078b8a345">◆ </a></span>adminHaOffline() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AdminHaOfflineResponse">AdminHaOfflineResponse</a> gpudb::GPUdb::adminHaOffline </td>
            <td>(</td>
            <td>const bool</td>
            <td><span><span>offline</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Pauses consumption of messages from other HA clusters to support data repair/recovery scenarios. </p>
        <p>In-flight queries may fail to replicate to other clusters in the ring when going offline.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>offline</td>

                <td>
                  Set to true if desired state is offline. Supported values:

                  <ul>
                    <li> true </li>
                    <li> false </li>
                  </ul>
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AdminHaOfflineResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a50a1072291f97df14d3d7d42fb2650e2">◆ </a></span>adminHaOffline() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AdminHaOfflineResponse">AdminHaOfflineResponse</a> & gpudb::GPUdb::adminHaOffline </td>
            <td>(</td>
            <td>const bool</td>
            <td><span><span>offline</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1AdminHaOfflineResponse">AdminHaOfflineResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Pauses consumption of messages from other HA clusters to support data repair/recovery scenarios. </p>
        <p>In-flight queries may fail to replicate to other clusters in the ring when going offline.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>offline</td>

                <td>
                  Set to true if desired state is offline. Supported values:

                  <ul>
                    <li> true </li>
                    <li> false </li>
                  </ul>
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AdminHaOfflineResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AdminHaOfflineResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ad0294d27d194bc5658f20748db0e8b42">◆ </a></span>adminHaRefresh() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AdminHaRefreshResponse">AdminHaRefreshResponse</a> gpudb::GPUdb::adminHaRefresh </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1AdminHaRefreshRequest">AdminHaRefreshRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Restarts the HA processing on the given cluster as a mechanism of accepting breaking HA conf changes. </p>
        <p>Additionally the cluster is put into read-only while HA is restarting.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AdminHaRefreshRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AdminHaRefreshResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ae2ad6feac6e17483de4502ecc3114181">◆ </a></span>adminHaRefresh() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AdminHaRefreshResponse">AdminHaRefreshResponse</a> & gpudb::GPUdb::adminHaRefresh </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1AdminHaRefreshRequest">AdminHaRefreshRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1AdminHaRefreshResponse">AdminHaRefreshResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Restarts the HA processing on the given cluster as a mechanism of accepting breaking HA conf changes. </p>
        <p>Additionally the cluster is put into read-only while HA is restarting.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AdminHaRefreshRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AdminHaRefreshResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AdminHaRefreshResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a43b0255297e7c3a6e79d6a5eda88193a">◆ </a></span>adminHaRefresh() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AdminHaRefreshResponse">AdminHaRefreshResponse</a> gpudb::GPUdb::adminHaRefresh </td>
            <td>(</td>
            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Restarts the HA processing on the given cluster as a mechanism of accepting breaking HA conf changes. </p>
        <p>Additionally the cluster is put into read-only while HA is restarting.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AdminHaRefreshResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#abb440bd25cb86a5379cbb05ae403c917">◆ </a></span>adminHaRefresh() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AdminHaRefreshResponse">AdminHaRefreshResponse</a> & gpudb::GPUdb::adminHaRefresh </td>
            <td>(</td>
            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1AdminHaRefreshResponse">AdminHaRefreshResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Restarts the HA processing on the given cluster as a mechanism of accepting breaking HA conf changes. </p>
        <p>Additionally the cluster is put into read-only while HA is restarting.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AdminHaRefreshResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AdminHaRefreshResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a9458238afaafde877e568a92d45abb75">◆ </a></span>adminOffline() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AdminOfflineResponse">AdminOfflineResponse</a> gpudb::GPUdb::adminOffline </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1AdminOfflineRequest">AdminOfflineRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Take the system offline. </p>
        <p>When the system is offline, no user operations can be performed with the exception of a system shutdown.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AdminOfflineRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AdminOfflineResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a57f142409c09c17cf6b6db1018d28a86">◆ </a></span>adminOffline() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AdminOfflineResponse">AdminOfflineResponse</a> & gpudb::GPUdb::adminOffline </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1AdminOfflineRequest">AdminOfflineRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1AdminOfflineResponse">AdminOfflineResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Take the system offline. </p>
        <p>When the system is offline, no user operations can be performed with the exception of a system shutdown.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AdminOfflineRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AdminOfflineResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AdminOfflineResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a4d36ee318372b12d061552af95a2910c">◆ </a></span>adminOffline() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AdminOfflineResponse">AdminOfflineResponse</a> gpudb::GPUdb::adminOffline </td>
            <td>(</td>
            <td>const bool</td>
            <td><span><span>offline</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Take the system offline. </p>
        <p>When the system is offline, no user operations can be performed with the exception of a system shutdown.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>offline</td>

                <td>
                  Set to true if desired state is offline. Supported values:

                  <ul>
                    <li> true </li>
                    <li> false </li>
                  </ul>
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a48ad0bf32eb3b6518fb1ad33016a67cb">admin\_offline\_flush\_to\_disk</a>: Flush to disk when going offline. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a5568a4cf7f218648a3798addaf1428c7">admin\_offline\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a07fc9ef868a8baf4eef6f7a9eae1d52d">admin\_offline\_false</a> </li>
                      </ul>
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AdminOfflineResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a9287388ae6e705b7265529115fa564cb">◆ </a></span>adminOffline() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AdminOfflineResponse">AdminOfflineResponse</a> & gpudb::GPUdb::adminOffline </td>
            <td>(</td>
            <td>const bool</td>
            <td><span><span>offline</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1AdminOfflineResponse">AdminOfflineResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Take the system offline. </p>
        <p>When the system is offline, no user operations can be performed with the exception of a system shutdown.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>offline</td>

                <td>
                  Set to true if desired state is offline. Supported values:

                  <ul>
                    <li> true </li>
                    <li> false </li>
                  </ul>
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a48ad0bf32eb3b6518fb1ad33016a67cb">admin\_offline\_flush\_to\_disk</a>: Flush to disk when going offline. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a5568a4cf7f218648a3798addaf1428c7">admin\_offline\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a07fc9ef868a8baf4eef6f7a9eae1d52d">admin\_offline\_false</a> </li>
                      </ul>
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AdminOfflineResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AdminOfflineResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a12ddec404e39c247d808318977c10d6b">◆ </a></span>adminRebalance() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AdminRebalanceResponse">AdminRebalanceResponse</a> gpudb::GPUdb::adminRebalance </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1AdminRebalanceRequest">AdminRebalanceRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Rebalance the data in the cluster so that all nodes contain an equal number of records approximately and/or rebalance the shards to be equally distributed (as much as possible) across all the ranks. </p>
        <p>The database must be offline for this operation, see <a href="#a9458238afaafde877e568a92d45abb75">adminOffline</a></p>

        <ul>
          <li>If <a href="#a12ddec404e39c247d808318977c10d6b">adminRebalance</a> is invoked after a change is made to the cluster, e.g., a host was added or removed, <a href="/content/concepts/tables/#sharding">sharded data</a> will be evenly redistributed across the cluster by number of shards per rank while unsharded data will be redistributed across the cluster by data size per rank</li>
          <li>If <a href="#a12ddec404e39c247d808318977c10d6b">adminRebalance</a> is invoked at some point when unsharded data (a.k.a. <a href="/content/concepts/tables/#random-sharding">randomly-sharded</a>) in the cluster is unevenly distributed over time, sharded data will not move while unsharded data will be redistributed across the cluster by data size per rank</li>
        </ul>

        <p>NOTE: Replicated data will not move as a result of this call</p>
        <p>This endpoint's processing time depends on the amount of data in the system, thus the API call may time out if run directly. It is recommended to run this endpoint asynchronously via <a href="#a02ef4c58e395bbf2c83325cf592397af">createJob</a>.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AdminRebalanceRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AdminRebalanceResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a225313a061565fba218a4400e32bd6e9">◆ </a></span>adminRebalance() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AdminRebalanceResponse">AdminRebalanceResponse</a> & gpudb::GPUdb::adminRebalance </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1AdminRebalanceRequest">AdminRebalanceRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1AdminRebalanceResponse">AdminRebalanceResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Rebalance the data in the cluster so that all nodes contain an equal number of records approximately and/or rebalance the shards to be equally distributed (as much as possible) across all the ranks. </p>
        <p>The database must be offline for this operation, see <a href="#a9458238afaafde877e568a92d45abb75">adminOffline</a></p>

        <ul>
          <li>If <a href="#a12ddec404e39c247d808318977c10d6b">adminRebalance</a> is invoked after a change is made to the cluster, e.g., a host was added or removed, <a href="/content/concepts/tables/#sharding">sharded data</a> will be evenly redistributed across the cluster by number of shards per rank while unsharded data will be redistributed across the cluster by data size per rank</li>
          <li>If <a href="#a12ddec404e39c247d808318977c10d6b">adminRebalance</a> is invoked at some point when unsharded data (a.k.a. <a href="/content/concepts/tables/#random-sharding">randomly-sharded</a>) in the cluster is unevenly distributed over time, sharded data will not move while unsharded data will be redistributed across the cluster by data size per rank</li>
        </ul>

        <p>NOTE: Replicated data will not move as a result of this call</p>
        <p>This endpoint's processing time depends on the amount of data in the system, thus the API call may time out if run directly. It is recommended to run this endpoint asynchronously via <a href="#a02ef4c58e395bbf2c83325cf592397af">createJob</a>.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AdminRebalanceRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AdminRebalanceResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AdminRebalanceResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a8abfc8309fa07276967c988d6f316390">◆ </a></span>adminRebalance() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AdminRebalanceResponse">AdminRebalanceResponse</a> gpudb::GPUdb::adminRebalance </td>
            <td>(</td>
            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Rebalance the data in the cluster so that all nodes contain an equal number of records approximately and/or rebalance the shards to be equally distributed (as much as possible) across all the ranks. </p>
        <p>The database must be offline for this operation, see <a href="#a4d36ee318372b12d061552af95a2910c">adminOffline</a></p>

        <ul>
          <li>If <a href="#a8abfc8309fa07276967c988d6f316390">adminRebalance</a> is invoked after a change is made to the cluster, e.g., a host was added or removed, <a href="/content/concepts/tables/#sharding">sharded data</a> will be evenly redistributed across the cluster by number of shards per rank while unsharded data will be redistributed across the cluster by data size per rank</li>
          <li>If <a href="#a8abfc8309fa07276967c988d6f316390">adminRebalance</a> is invoked at some point when unsharded data (a.k.a. <a href="/content/concepts/tables/#random-sharding">randomly-sharded</a>) in the cluster is unevenly distributed over time, sharded data will not move while unsharded data will be redistributed across the cluster by data size per rank</li>
        </ul>

        <p>NOTE: Replicated data will not move as a result of this call</p>
        <p>This endpoint's processing time depends on the amount of data in the system, thus the API call may time out if run directly. It is recommended to run this endpoint asynchronously via <a href="#a2807b0831529b2f2e6fb554339670763">createJob</a>.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#aad19c9dbc992e925ba7c64427a3ea411">admin\_rebalance\_rebalance\_sharded\_data</a>: If <a href="/content/api/cpp/namespacegpudb#af06ee317b8efa9d21bcaf360c74eeb37">true</a>, <a href="/content/concepts/tables/#sharding">sharded data</a> will be rebalanced approximately equally across the cluster. Note that for clusters with large amounts of sharded data, this data transfer could be time consuming and result in delayed query responses. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#af06ee317b8efa9d21bcaf360c74eeb37">admin\_rebalance\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a0620989027a635c303f44b6f89cbad98">admin\_rebalance\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#af06ee317b8efa9d21bcaf360c74eeb37">admin\_rebalance\_true</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a6f0981e22d233d17c8582d9a71cdebcc">admin\_rebalance\_rebalance\_unsharded\_data</a>: If <a href="/content/api/cpp/namespacegpudb#af06ee317b8efa9d21bcaf360c74eeb37">true</a>, unsharded data (a.k.a. <a href="/content/concepts/tables/#random-sharding">randomly-sharded</a>) will be rebalanced approximately equally across the cluster. Note that for clusters with large amounts of unsharded data, this data transfer could be time consuming and result in delayed query responses. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#af06ee317b8efa9d21bcaf360c74eeb37">admin\_rebalance\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a0620989027a635c303f44b6f89cbad98">admin\_rebalance\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#af06ee317b8efa9d21bcaf360c74eeb37">admin\_rebalance\_true</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a418d45847bdb24ada6f38b355c004278">admin\_rebalance\_table\_includes</a>: Comma-separated list of unsharded table names to rebalance. Not applicable to sharded tables because they are always rebalanced. Cannot be used simultaneously with <a href="/content/api/cpp/namespacegpudb#afbf6fb4173234e573b086d8c2cfd4d7d">table\_excludes</a>. This parameter is ignored if <a href="/content/api/cpp/namespacegpudb#a6f0981e22d233d17c8582d9a71cdebcc">rebalance\_unsharded\_data</a> is <a href="/content/api/cpp/namespacegpudb#a0620989027a635c303f44b6f89cbad98">false</a>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#afbf6fb4173234e573b086d8c2cfd4d7d">admin\_rebalance\_table\_excludes</a>: Comma-separated list of unsharded table names to not rebalance. Not applicable to sharded tables because they are always rebalanced. Cannot be used simultaneously with <a href="/content/api/cpp/namespacegpudb#a418d45847bdb24ada6f38b355c004278">table\_includes</a>. This parameter is ignored if <a href="/content/api/cpp/namespacegpudb#a6f0981e22d233d17c8582d9a71cdebcc">rebalance\_unsharded\_data</a> is <a href="/content/api/cpp/namespacegpudb#a0620989027a635c303f44b6f89cbad98">false</a>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ae62f6ea41e2acf4444ea531530a49bf6">admin\_rebalance\_aggressiveness</a>: Influences how much data is moved at a time during rebalance. A higher <a href="/content/api/cpp/namespacegpudb#ae62f6ea41e2acf4444ea531530a49bf6">aggressiveness</a> will complete the rebalance faster. A lower <a href="/content/api/cpp/namespacegpudb#ae62f6ea41e2acf4444ea531530a49bf6">aggressiveness</a> will take longer but allow for better interleaving between the rebalance and other queries. Valid values are constants from 1 (lowest) to 10 (highest). The default value is '10'. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ae6433e60a2b8ba7c4f155212e8d1eb29">admin\_rebalance\_compact\_after\_rebalance</a>: Perform compaction of deleted records once the rebalance completes to reclaim memory and disk space. Default is <a href="/content/api/cpp/namespacegpudb#af06ee317b8efa9d21bcaf360c74eeb37">true</a>, unless <a href="/content/api/cpp/namespacegpudb#a3e18bc2f5dc73988f923a7e6ca228546">repair\_incorrectly\_sharded\_data</a> is set to <a href="/content/api/cpp/namespacegpudb#af06ee317b8efa9d21bcaf360c74eeb37">true</a>. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#af06ee317b8efa9d21bcaf360c74eeb37">admin\_rebalance\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a0620989027a635c303f44b6f89cbad98">admin\_rebalance\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#af06ee317b8efa9d21bcaf360c74eeb37">admin\_rebalance\_true</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a5fe14d7ad7823c108d68a4719fc6e4de">admin\_rebalance\_compact\_only</a>: If set to <a href="/content/api/cpp/namespacegpudb#af06ee317b8efa9d21bcaf360c74eeb37">true</a>, ignore rebalance options and attempt to perform compaction of deleted records to reclaim memory and disk space without rebalancing first. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#af06ee317b8efa9d21bcaf360c74eeb37">admin\_rebalance\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a0620989027a635c303f44b6f89cbad98">admin\_rebalance\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a0620989027a635c303f44b6f89cbad98">admin\_rebalance\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a3e18bc2f5dc73988f923a7e6ca228546">admin\_rebalance\_repair\_incorrectly\_sharded\_data</a>: Scans for any data sharded incorrectly and re-routes the data to the correct location. Only necessary if <a href="#a4651bd91e69f7a8aa697471fa7ddba31">adminVerifyDb</a> reports an error in sharding alignment. This can be done as part of a typical rebalance after expanding the cluster or in a standalone fashion when it is believed that data is sharded incorrectly somewhere in the cluster. Compaction will not be performed by default when this is enabled. If this option is set to <a href="/content/api/cpp/namespacegpudb#af06ee317b8efa9d21bcaf360c74eeb37">true</a>, the time necessary to rebalance and the memory used by the rebalance may increase. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#af06ee317b8efa9d21bcaf360c74eeb37">admin\_rebalance\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a0620989027a635c303f44b6f89cbad98">admin\_rebalance\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a0620989027a635c303f44b6f89cbad98">admin\_rebalance\_false</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AdminRebalanceResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a37e5e1f0651504eee56a0321a77b47c2">◆ </a></span>adminRebalance() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AdminRebalanceResponse">AdminRebalanceResponse</a> & gpudb::GPUdb::adminRebalance </td>
            <td>(</td>
            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1AdminRebalanceResponse">AdminRebalanceResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Rebalance the data in the cluster so that all nodes contain an equal number of records approximately and/or rebalance the shards to be equally distributed (as much as possible) across all the ranks. </p>
        <p>The database must be offline for this operation, see <a href="#a4d36ee318372b12d061552af95a2910c">adminOffline</a></p>

        <ul>
          <li>If <a href="#a8abfc8309fa07276967c988d6f316390">adminRebalance</a> is invoked after a change is made to the cluster, e.g., a host was added or removed, <a href="/content/concepts/tables/#sharding">sharded data</a> will be evenly redistributed across the cluster by number of shards per rank while unsharded data will be redistributed across the cluster by data size per rank</li>
          <li>If <a href="#a8abfc8309fa07276967c988d6f316390">adminRebalance</a> is invoked at some point when unsharded data (a.k.a. <a href="/content/concepts/tables/#random-sharding">randomly-sharded</a>) in the cluster is unevenly distributed over time, sharded data will not move while unsharded data will be redistributed across the cluster by data size per rank</li>
        </ul>

        <p>NOTE: Replicated data will not move as a result of this call</p>
        <p>This endpoint's processing time depends on the amount of data in the system, thus the API call may time out if run directly. It is recommended to run this endpoint asynchronously via <a href="#a2807b0831529b2f2e6fb554339670763">createJob</a>.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#aad19c9dbc992e925ba7c64427a3ea411">admin\_rebalance\_rebalance\_sharded\_data</a>: If <a href="/content/api/cpp/namespacegpudb#af06ee317b8efa9d21bcaf360c74eeb37">true</a>, <a href="/content/concepts/tables/#sharding">sharded data</a> will be rebalanced approximately equally across the cluster. Note that for clusters with large amounts of sharded data, this data transfer could be time consuming and result in delayed query responses. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#af06ee317b8efa9d21bcaf360c74eeb37">admin\_rebalance\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a0620989027a635c303f44b6f89cbad98">admin\_rebalance\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#af06ee317b8efa9d21bcaf360c74eeb37">admin\_rebalance\_true</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a6f0981e22d233d17c8582d9a71cdebcc">admin\_rebalance\_rebalance\_unsharded\_data</a>: If <a href="/content/api/cpp/namespacegpudb#af06ee317b8efa9d21bcaf360c74eeb37">true</a>, unsharded data (a.k.a. <a href="/content/concepts/tables/#random-sharding">randomly-sharded</a>) will be rebalanced approximately equally across the cluster. Note that for clusters with large amounts of unsharded data, this data transfer could be time consuming and result in delayed query responses. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#af06ee317b8efa9d21bcaf360c74eeb37">admin\_rebalance\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a0620989027a635c303f44b6f89cbad98">admin\_rebalance\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#af06ee317b8efa9d21bcaf360c74eeb37">admin\_rebalance\_true</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a418d45847bdb24ada6f38b355c004278">admin\_rebalance\_table\_includes</a>: Comma-separated list of unsharded table names to rebalance. Not applicable to sharded tables because they are always rebalanced. Cannot be used simultaneously with <a href="/content/api/cpp/namespacegpudb#afbf6fb4173234e573b086d8c2cfd4d7d">table\_excludes</a>. This parameter is ignored if <a href="/content/api/cpp/namespacegpudb#a6f0981e22d233d17c8582d9a71cdebcc">rebalance\_unsharded\_data</a> is <a href="/content/api/cpp/namespacegpudb#a0620989027a635c303f44b6f89cbad98">false</a>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#afbf6fb4173234e573b086d8c2cfd4d7d">admin\_rebalance\_table\_excludes</a>: Comma-separated list of unsharded table names to not rebalance. Not applicable to sharded tables because they are always rebalanced. Cannot be used simultaneously with <a href="/content/api/cpp/namespacegpudb#a418d45847bdb24ada6f38b355c004278">table\_includes</a>. This parameter is ignored if <a href="/content/api/cpp/namespacegpudb#a6f0981e22d233d17c8582d9a71cdebcc">rebalance\_unsharded\_data</a> is <a href="/content/api/cpp/namespacegpudb#a0620989027a635c303f44b6f89cbad98">false</a>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ae62f6ea41e2acf4444ea531530a49bf6">admin\_rebalance\_aggressiveness</a>: Influences how much data is moved at a time during rebalance. A higher <a href="/content/api/cpp/namespacegpudb#ae62f6ea41e2acf4444ea531530a49bf6">aggressiveness</a> will complete the rebalance faster. A lower <a href="/content/api/cpp/namespacegpudb#ae62f6ea41e2acf4444ea531530a49bf6">aggressiveness</a> will take longer but allow for better interleaving between the rebalance and other queries. Valid values are constants from 1 (lowest) to 10 (highest). The default value is '10'. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ae6433e60a2b8ba7c4f155212e8d1eb29">admin\_rebalance\_compact\_after\_rebalance</a>: Perform compaction of deleted records once the rebalance completes to reclaim memory and disk space. Default is <a href="/content/api/cpp/namespacegpudb#af06ee317b8efa9d21bcaf360c74eeb37">true</a>, unless <a href="/content/api/cpp/namespacegpudb#a3e18bc2f5dc73988f923a7e6ca228546">repair\_incorrectly\_sharded\_data</a> is set to <a href="/content/api/cpp/namespacegpudb#af06ee317b8efa9d21bcaf360c74eeb37">true</a>. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#af06ee317b8efa9d21bcaf360c74eeb37">admin\_rebalance\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a0620989027a635c303f44b6f89cbad98">admin\_rebalance\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#af06ee317b8efa9d21bcaf360c74eeb37">admin\_rebalance\_true</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a5fe14d7ad7823c108d68a4719fc6e4de">admin\_rebalance\_compact\_only</a>: If set to <a href="/content/api/cpp/namespacegpudb#af06ee317b8efa9d21bcaf360c74eeb37">true</a>, ignore rebalance options and attempt to perform compaction of deleted records to reclaim memory and disk space without rebalancing first. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#af06ee317b8efa9d21bcaf360c74eeb37">admin\_rebalance\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a0620989027a635c303f44b6f89cbad98">admin\_rebalance\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a0620989027a635c303f44b6f89cbad98">admin\_rebalance\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a3e18bc2f5dc73988f923a7e6ca228546">admin\_rebalance\_repair\_incorrectly\_sharded\_data</a>: Scans for any data sharded incorrectly and re-routes the data to the correct location. Only necessary if <a href="#a4651bd91e69f7a8aa697471fa7ddba31">adminVerifyDb</a> reports an error in sharding alignment. This can be done as part of a typical rebalance after expanding the cluster or in a standalone fashion when it is believed that data is sharded incorrectly somewhere in the cluster. Compaction will not be performed by default when this is enabled. If this option is set to <a href="/content/api/cpp/namespacegpudb#af06ee317b8efa9d21bcaf360c74eeb37">true</a>, the time necessary to rebalance and the memory used by the rebalance may increase. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#af06ee317b8efa9d21bcaf360c74eeb37">admin\_rebalance\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a0620989027a635c303f44b6f89cbad98">admin\_rebalance\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a0620989027a635c303f44b6f89cbad98">admin\_rebalance\_false</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AdminRebalanceResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AdminRebalanceResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#afc27231b396dfca335854fb0094d16e6">◆ </a></span>adminRemoveHost() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AdminRemoveHostResponse">AdminRemoveHostResponse</a> gpudb::GPUdb::adminRemoveHost </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1AdminRemoveHostRequest">AdminRemoveHostRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Removes a host from an existing cluster. </p>
        <p>If the host to be removed has any ranks running on it, the ranks must be removed using <a href="#af47d6fbc166de5aa113aacbd9cad9ca7">adminRemoveRanks</a> or manually switched over to a new host using <a href="#a2c4d8fe04dc3c5feb4e5e343889bddf8">adminSwitchover</a> prior to host removal. If the host to be removed has the graph server or SQL planner running on it, these must be manually switched over to a new host using <a href="#a2c4d8fe04dc3c5feb4e5e343889bddf8">adminSwitchover</a>.</p>

        <div>
          <div>Attention</div>
          <div>This method should be used for on-premise deployments only.</div>
        </div>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AdminRemoveHostRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AdminRemoveHostResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ac77e1ed2b6f9e9552b6187bf9553be5f">◆ </a></span>adminRemoveHost() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AdminRemoveHostResponse">AdminRemoveHostResponse</a> & gpudb::GPUdb::adminRemoveHost </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1AdminRemoveHostRequest">AdminRemoveHostRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1AdminRemoveHostResponse">AdminRemoveHostResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Removes a host from an existing cluster. </p>
        <p>If the host to be removed has any ranks running on it, the ranks must be removed using <a href="#af47d6fbc166de5aa113aacbd9cad9ca7">adminRemoveRanks</a> or manually switched over to a new host using <a href="#a2c4d8fe04dc3c5feb4e5e343889bddf8">adminSwitchover</a> prior to host removal. If the host to be removed has the graph server or SQL planner running on it, these must be manually switched over to a new host using <a href="#a2c4d8fe04dc3c5feb4e5e343889bddf8">adminSwitchover</a>.</p>

        <div>
          <div>Attention</div>
          <div>This method should be used for on-premise deployments only.</div>
        </div>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AdminRemoveHostRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AdminRemoveHostResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AdminRemoveHostResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ab4f8c2922e78db2407c488ce3388ebe3">◆ </a></span>adminRemoveHost() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AdminRemoveHostResponse">AdminRemoveHostResponse</a> gpudb::GPUdb::adminRemoveHost </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>host</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Removes a host from an existing cluster. </p>
        <p>If the host to be removed has any ranks running on it, the ranks must be removed using <a href="#a25fe31989868ca19f1e69c67dd67e3c0">adminRemoveRanks</a> or manually switched over to a new host using <a href="#a48a805373da1ea7f31119c18ead8750a">adminSwitchover</a> prior to host removal. If the host to be removed has the graph server or SQL planner running on it, these must be manually switched over to a new host using <a href="#a48a805373da1ea7f31119c18ead8750a">adminSwitchover</a>.</p>

        <div>
          <div>Attention</div>
          <div>This method should be used for on-premise deployments only.</div>
        </div>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>host</td>
                <td>Identifies the host this applies to. Can be the host address, or formatted as 'hostN' where N is the host number as specified in gpudb.conf. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#aa8697bd541887a40667747ceabd91198">admin\_remove\_host\_dry\_run</a>: If set to <a href="/content/api/cpp/namespacegpudb#a486c0f0df4eec1c3174ea18952fd2e0e">true</a>, only validation checks will be performed. No host is removed. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a486c0f0df4eec1c3174ea18952fd2e0e">admin\_remove\_host\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a72ff1372a511e0e43f83fbebe235f4da">admin\_remove\_host\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a72ff1372a511e0e43f83fbebe235f4da">admin\_remove\_host\_false</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AdminRemoveHostResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a6a88a2a737e8b825f3c201e806346b8f">◆ </a></span>adminRemoveHost() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AdminRemoveHostResponse">AdminRemoveHostResponse</a> & gpudb::GPUdb::adminRemoveHost </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>host</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1AdminRemoveHostResponse">AdminRemoveHostResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Removes a host from an existing cluster. </p>
        <p>If the host to be removed has any ranks running on it, the ranks must be removed using <a href="#a25fe31989868ca19f1e69c67dd67e3c0">adminRemoveRanks</a> or manually switched over to a new host using <a href="#a48a805373da1ea7f31119c18ead8750a">adminSwitchover</a> prior to host removal. If the host to be removed has the graph server or SQL planner running on it, these must be manually switched over to a new host using <a href="#a48a805373da1ea7f31119c18ead8750a">adminSwitchover</a>.</p>

        <div>
          <div>Attention</div>
          <div>This method should be used for on-premise deployments only.</div>
        </div>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>host</td>
                <td>Identifies the host this applies to. Can be the host address, or formatted as 'hostN' where N is the host number as specified in gpudb.conf. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#aa8697bd541887a40667747ceabd91198">admin\_remove\_host\_dry\_run</a>: If set to <a href="/content/api/cpp/namespacegpudb#a486c0f0df4eec1c3174ea18952fd2e0e">true</a>, only validation checks will be performed. No host is removed. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a486c0f0df4eec1c3174ea18952fd2e0e">admin\_remove\_host\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a72ff1372a511e0e43f83fbebe235f4da">admin\_remove\_host\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a72ff1372a511e0e43f83fbebe235f4da">admin\_remove\_host\_false</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AdminRemoveHostResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AdminRemoveHostResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#af47d6fbc166de5aa113aacbd9cad9ca7">◆ </a></span>adminRemoveRanks() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AdminRemoveRanksResponse">AdminRemoveRanksResponse</a> gpudb::GPUdb::adminRemoveRanks </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1AdminRemoveRanksRequest">AdminRemoveRanksRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Remove one or more ranks from an existing Kinetica cluster. </p>
        <p>All data will be rebalanced to other ranks before the rank(s) is removed unless the <a href="/content/api/cpp/namespacegpudb#a0546b285a079b4c847ef24789b7466df">rebalance\_sharded\_data</a> or <a href="/content/api/cpp/namespacegpudb#a314220f1f065de6daae02c1a756ee98f">rebalance\_unsharded\_data</a> parameters are set to <a href="/content/api/cpp/namespacegpudb#abd6ae1c29538868f683c3682ca3f197b">false</a> in the <a href="/content/api/cpp/structgpudb_1_1AdminRemoveRanksRequest#a11f8dcac1d2fd5d158e5b4c9ce8add19">options</a>, in which case the corresponding <a href="/content/concepts/tables/#sharding">sharded data</a> and/or unsharded data (a.k.a. <a href="/content/concepts/tables/#random-sharding">randomly-sharded</a>) will be deleted.</p>
        <p>The database must be offline for this operation, see <a href="#a9458238afaafde877e568a92d45abb75">adminOffline</a></p>
        <p>This endpoint's processing time depends on the amount of data in the system, thus the API call may time out if run directly. It is recommended to run this endpoint asynchronously via <a href="#a02ef4c58e395bbf2c83325cf592397af">createJob</a>.</p>

        <div>
          <div>Attention</div>
          <div>This method should be used for on-premise deployments only.</div>
        </div>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AdminRemoveRanksRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AdminRemoveRanksResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a96f6705e2aa15bb8a9276b900dfb75af">◆ </a></span>adminRemoveRanks() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AdminRemoveRanksResponse">AdminRemoveRanksResponse</a> & gpudb::GPUdb::adminRemoveRanks </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1AdminRemoveRanksRequest">AdminRemoveRanksRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1AdminRemoveRanksResponse">AdminRemoveRanksResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Remove one or more ranks from an existing Kinetica cluster. </p>
        <p>All data will be rebalanced to other ranks before the rank(s) is removed unless the <a href="/content/api/cpp/namespacegpudb#a0546b285a079b4c847ef24789b7466df">rebalance\_sharded\_data</a> or <a href="/content/api/cpp/namespacegpudb#a314220f1f065de6daae02c1a756ee98f">rebalance\_unsharded\_data</a> parameters are set to <a href="/content/api/cpp/namespacegpudb#abd6ae1c29538868f683c3682ca3f197b">false</a> in the <a href="/content/api/cpp/structgpudb_1_1AdminRemoveRanksRequest#a11f8dcac1d2fd5d158e5b4c9ce8add19">options</a>, in which case the corresponding <a href="/content/concepts/tables/#sharding">sharded data</a> and/or unsharded data (a.k.a. <a href="/content/concepts/tables/#random-sharding">randomly-sharded</a>) will be deleted.</p>
        <p>The database must be offline for this operation, see <a href="#a9458238afaafde877e568a92d45abb75">adminOffline</a></p>
        <p>This endpoint's processing time depends on the amount of data in the system, thus the API call may time out if run directly. It is recommended to run this endpoint asynchronously via <a href="#a02ef4c58e395bbf2c83325cf592397af">createJob</a>.</p>

        <div>
          <div>Attention</div>
          <div>This method should be used for on-premise deployments only.</div>
        </div>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AdminRemoveRanksRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AdminRemoveRanksResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AdminRemoveRanksResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a25fe31989868ca19f1e69c67dd67e3c0">◆ </a></span>adminRemoveRanks() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AdminRemoveRanksResponse">AdminRemoveRanksResponse</a> gpudb::GPUdb::adminRemoveRanks </td>
            <td>(</td>
            <td>const std::vector\< std::string > &</td>
            <td><span><span>ranks</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Remove one or more ranks from an existing Kinetica cluster. </p>
        <p>All data will be rebalanced to other ranks before the rank(s) is removed unless the <a href="/content/api/cpp/namespacegpudb#a0546b285a079b4c847ef24789b7466df">rebalance\_sharded\_data</a> or <a href="/content/api/cpp/namespacegpudb#a314220f1f065de6daae02c1a756ee98f">rebalance\_unsharded\_data</a> parameters are set to <a href="/content/api/cpp/namespacegpudb#abd6ae1c29538868f683c3682ca3f197b">false</a> in the <span>options</span>, in which case the corresponding <a href="/content/concepts/tables/#sharding">sharded data</a> and/or unsharded data (a.k.a. <a href="/content/concepts/tables/#random-sharding">randomly-sharded</a>) will be deleted.</p>
        <p>The database must be offline for this operation, see <a href="#a4d36ee318372b12d061552af95a2910c">adminOffline</a></p>
        <p>This endpoint's processing time depends on the amount of data in the system, thus the API call may time out if run directly. It is recommended to run this endpoint asynchronously via <a href="#a2807b0831529b2f2e6fb554339670763">createJob</a>.</p>

        <div>
          <div>Attention</div>
          <div>This method should be used for on-premise deployments only.</div>
        </div>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>ranks</td>
                <td>Each array value designates one or more ranks to remove from the cluster. Values can be formatted as 'rankN' for a specific rank, 'hostN' (from the gpudb.conf file) to remove all ranks on that host, or the host IP address (hostN.address from the gpub.conf file) which also removes all ranks on that host. Rank 0 (the head rank) cannot be removed (but can be moved to another host using <a href="#a48a805373da1ea7f31119c18ead8750a">adminSwitchover</a>). At least one worker rank must be left in the cluster after the operation. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a0546b285a079b4c847ef24789b7466df">admin\_remove\_ranks\_rebalance\_sharded\_data</a>: If <a href="/content/api/cpp/namespacegpudb#aa3848331c75e8f304de305fda7bfe584">true</a>, <a href="/content/concepts/tables/#sharding">sharded data</a> will be rebalanced approximately equally across the cluster. Note that for clusters with large amounts of sharded data, this data transfer could be time consuming and result in delayed query responses. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#aa3848331c75e8f304de305fda7bfe584">admin\_remove\_ranks\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#abd6ae1c29538868f683c3682ca3f197b">admin\_remove\_ranks\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#aa3848331c75e8f304de305fda7bfe584">admin\_remove\_ranks\_true</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a314220f1f065de6daae02c1a756ee98f">admin\_remove\_ranks\_rebalance\_unsharded\_data</a>: If <a href="/content/api/cpp/namespacegpudb#aa3848331c75e8f304de305fda7bfe584">true</a>, unsharded data (a.k.a. <a href="/content/concepts/tables/#random-sharding">randomly-sharded</a>) will be rebalanced approximately equally across the cluster. Note that for clusters with large amounts of unsharded data, this data transfer could be time consuming and result in delayed query responses. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#aa3848331c75e8f304de305fda7bfe584">admin\_remove\_ranks\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#abd6ae1c29538868f683c3682ca3f197b">admin\_remove\_ranks\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#aa3848331c75e8f304de305fda7bfe584">admin\_remove\_ranks\_true</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#ae195a601cd7c0a760fe753d9b53d463f">admin\_remove\_ranks\_aggressiveness</a>: Influences how much data is moved at a time during rebalance. A higher <a href="/content/api/cpp/namespacegpudb#ae195a601cd7c0a760fe753d9b53d463f">aggressiveness</a> will complete the rebalance faster. A lower <a href="/content/api/cpp/namespacegpudb#ae195a601cd7c0a760fe753d9b53d463f">aggressiveness</a> will take longer but allow for better interleaving between the rebalance and other queries. Valid values are constants from 1 (lowest) to 10 (highest). The default value is '10'. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AdminRemoveRanksResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#add72201686c919180950f7b44d144631">◆ </a></span>adminRemoveRanks() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AdminRemoveRanksResponse">AdminRemoveRanksResponse</a> & gpudb::GPUdb::adminRemoveRanks </td>
            <td>(</td>
            <td>const std::vector\< std::string > &</td>
            <td><span><span>ranks</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1AdminRemoveRanksResponse">AdminRemoveRanksResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Remove one or more ranks from an existing Kinetica cluster. </p>
        <p>All data will be rebalanced to other ranks before the rank(s) is removed unless the <a href="/content/api/cpp/namespacegpudb#a0546b285a079b4c847ef24789b7466df">rebalance\_sharded\_data</a> or <a href="/content/api/cpp/namespacegpudb#a314220f1f065de6daae02c1a756ee98f">rebalance\_unsharded\_data</a> parameters are set to <a href="/content/api/cpp/namespacegpudb#abd6ae1c29538868f683c3682ca3f197b">false</a> in the <span>options</span>, in which case the corresponding <a href="/content/concepts/tables/#sharding">sharded data</a> and/or unsharded data (a.k.a. <a href="/content/concepts/tables/#random-sharding">randomly-sharded</a>) will be deleted.</p>
        <p>The database must be offline for this operation, see <a href="#a4d36ee318372b12d061552af95a2910c">adminOffline</a></p>
        <p>This endpoint's processing time depends on the amount of data in the system, thus the API call may time out if run directly. It is recommended to run this endpoint asynchronously via <a href="#a2807b0831529b2f2e6fb554339670763">createJob</a>.</p>

        <div>
          <div>Attention</div>
          <div>This method should be used for on-premise deployments only.</div>
        </div>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>ranks</td>
                <td>Each array value designates one or more ranks to remove from the cluster. Values can be formatted as 'rankN' for a specific rank, 'hostN' (from the gpudb.conf file) to remove all ranks on that host, or the host IP address (hostN.address from the gpub.conf file) which also removes all ranks on that host. Rank 0 (the head rank) cannot be removed (but can be moved to another host using <a href="#a48a805373da1ea7f31119c18ead8750a">adminSwitchover</a>). At least one worker rank must be left in the cluster after the operation. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a0546b285a079b4c847ef24789b7466df">admin\_remove\_ranks\_rebalance\_sharded\_data</a>: If <a href="/content/api/cpp/namespacegpudb#aa3848331c75e8f304de305fda7bfe584">true</a>, <a href="/content/concepts/tables/#sharding">sharded data</a> will be rebalanced approximately equally across the cluster. Note that for clusters with large amounts of sharded data, this data transfer could be time consuming and result in delayed query responses. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#aa3848331c75e8f304de305fda7bfe584">admin\_remove\_ranks\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#abd6ae1c29538868f683c3682ca3f197b">admin\_remove\_ranks\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#aa3848331c75e8f304de305fda7bfe584">admin\_remove\_ranks\_true</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a314220f1f065de6daae02c1a756ee98f">admin\_remove\_ranks\_rebalance\_unsharded\_data</a>: If <a href="/content/api/cpp/namespacegpudb#aa3848331c75e8f304de305fda7bfe584">true</a>, unsharded data (a.k.a. <a href="/content/concepts/tables/#random-sharding">randomly-sharded</a>) will be rebalanced approximately equally across the cluster. Note that for clusters with large amounts of unsharded data, this data transfer could be time consuming and result in delayed query responses. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#aa3848331c75e8f304de305fda7bfe584">admin\_remove\_ranks\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#abd6ae1c29538868f683c3682ca3f197b">admin\_remove\_ranks\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#aa3848331c75e8f304de305fda7bfe584">admin\_remove\_ranks\_true</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#ae195a601cd7c0a760fe753d9b53d463f">admin\_remove\_ranks\_aggressiveness</a>: Influences how much data is moved at a time during rebalance. A higher <a href="/content/api/cpp/namespacegpudb#ae195a601cd7c0a760fe753d9b53d463f">aggressiveness</a> will complete the rebalance faster. A lower <a href="/content/api/cpp/namespacegpudb#ae195a601cd7c0a760fe753d9b53d463f">aggressiveness</a> will take longer but allow for better interleaving between the rebalance and other queries. Valid values are constants from 1 (lowest) to 10 (highest). The default value is '10'. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AdminRemoveRanksResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AdminRemoveRanksResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#adedd21391e4301a79aca49f95e18a3c9">◆ </a></span>adminRepairTable() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AdminRepairTableResponse">AdminRepairTableResponse</a> gpudb::GPUdb::adminRepairTable </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1AdminRepairTableRequest">AdminRepairTableRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Manually repair a corrupted table. </p>
        <p>Returns information about affected tables.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AdminRepairTableRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AdminRepairTableResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a2b2b59214a68e36d7781038f9dba1cdb">◆ </a></span>adminRepairTable() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AdminRepairTableResponse">AdminRepairTableResponse</a> & gpudb::GPUdb::adminRepairTable </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1AdminRepairTableRequest">AdminRepairTableRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1AdminRepairTableResponse">AdminRepairTableResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Manually repair a corrupted table. </p>
        <p>Returns information about affected tables.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AdminRepairTableRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AdminRepairTableResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AdminRepairTableResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a7cc3c26f1ed85ae3f55d77dc0c034a0e">◆ </a></span>adminRepairTable() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AdminRepairTableResponse">AdminRepairTableResponse</a> gpudb::GPUdb::adminRepairTable </td>
            <td>(</td>
            <td>const std::vector\< std::string > &</td>
            <td><span><span>tableNames</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>tableTypes</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Manually repair a corrupted table. </p>
        <p>Returns information about affected tables.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableNames</td>
                <td>List of tables to query. An asterisk returns all tables. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>tableTypes</td>
                <td>ID of the type per table. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a4bada1b9469a0cd397de7fe5e555d585">admin\_repair\_table\_repair\_policy</a>: Corrective action to take. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a4fe6545f048aa4870400a0c09c00fb7f">admin\_repair\_table\_delete\_chunks</a>: Deletes any corrupted chunks. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a62e3c8da051c7ade51a6d8d2843836cd">admin\_repair\_table\_shrink\_columns</a>: Shrinks corrupted chunks to the shortest column. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#af345373cc94482fba61976ee8b11f41a">admin\_repair\_table\_replay\_wal</a>: Manually invokes write-ahead log (WAL) replay on the table. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ab89a7837f586b9b6a7cfea294f36e284">admin\_repair\_table\_alter\_table</a>: Reset columns modification after incomplete alter column. </li>
                      </ul>
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ad9086c3e62d17a48fef4d21172b9b642">admin\_repair\_table\_verify\_all</a>: If <a href="/content/api/cpp/namespacegpudb#ab920a046b0fcb2c47b02262a0fd3c4a4">false</a> only table chunk data already known to be corrupted will be repaired. Otherwise the database will perform a full table scan to check for correctness. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ab4fc473dc98a532e863323eed0eca559">admin\_repair\_table\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ab920a046b0fcb2c47b02262a0fd3c4a4">admin\_repair\_table\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ab920a046b0fcb2c47b02262a0fd3c4a4">admin\_repair\_table\_false</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AdminRepairTableResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a110ae4c3ec9cbc81402621acf5068da5">◆ </a></span>adminRepairTable() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AdminRepairTableResponse">AdminRepairTableResponse</a> & gpudb::GPUdb::adminRepairTable </td>
            <td>(</td>
            <td>const std::vector\< std::string > &</td>
            <td><span><span>tableNames</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>tableTypes</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1AdminRepairTableResponse">AdminRepairTableResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Manually repair a corrupted table. </p>
        <p>Returns information about affected tables.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableNames</td>
                <td>List of tables to query. An asterisk returns all tables. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>tableTypes</td>
                <td>ID of the type per table. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a4bada1b9469a0cd397de7fe5e555d585">admin\_repair\_table\_repair\_policy</a>: Corrective action to take. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a4fe6545f048aa4870400a0c09c00fb7f">admin\_repair\_table\_delete\_chunks</a>: Deletes any corrupted chunks. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a62e3c8da051c7ade51a6d8d2843836cd">admin\_repair\_table\_shrink\_columns</a>: Shrinks corrupted chunks to the shortest column. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#af345373cc94482fba61976ee8b11f41a">admin\_repair\_table\_replay\_wal</a>: Manually invokes write-ahead log (WAL) replay on the table. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ab89a7837f586b9b6a7cfea294f36e284">admin\_repair\_table\_alter\_table</a>: Reset columns modification after incomplete alter column. </li>
                      </ul>
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ad9086c3e62d17a48fef4d21172b9b642">admin\_repair\_table\_verify\_all</a>: If <a href="/content/api/cpp/namespacegpudb#ab920a046b0fcb2c47b02262a0fd3c4a4">false</a> only table chunk data already known to be corrupted will be repaired. Otherwise the database will perform a full table scan to check for correctness. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ab4fc473dc98a532e863323eed0eca559">admin\_repair\_table\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ab920a046b0fcb2c47b02262a0fd3c4a4">admin\_repair\_table\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ab920a046b0fcb2c47b02262a0fd3c4a4">admin\_repair\_table\_false</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AdminRepairTableResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AdminRepairTableResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a2fe86f445de71617b057707c7a50d5d8">◆ </a></span>adminSendAlert() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AdminSendAlertResponse">AdminSendAlertResponse</a> gpudb::GPUdb::adminSendAlert </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1AdminSendAlertRequest">AdminSendAlertRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Sends a user generated alert to the monitoring system. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AdminSendAlertRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AdminSendAlertResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a04d636efab58468abad5981c37d54f1e">◆ </a></span>adminSendAlert() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AdminSendAlertResponse">AdminSendAlertResponse</a> & gpudb::GPUdb::adminSendAlert </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1AdminSendAlertRequest">AdminSendAlertRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1AdminSendAlertResponse">AdminSendAlertResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Sends a user generated alert to the monitoring system. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AdminSendAlertRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AdminSendAlertResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AdminSendAlertResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ad3c6c09c9e78dfdbe68f75b09fe7ba80">◆ </a></span>adminSendAlert() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AdminSendAlertResponse">AdminSendAlertResponse</a> gpudb::GPUdb::adminSendAlert </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>message</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>label</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>logLevel</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Sends a user generated alert to the monitoring system. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>message</td>
                <td>Alert message body. The default value is ''. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>label</td>
                <td>Label to add to alert message. The default value is ''. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>logLevel</td>

                <td>
                  Alert message logging criteria. Supported values:

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#ab1c232389963064b7a0cdda81bb2f2c7">admin\_send\_alert\_fatal</a> </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a69e3d93f492695a187ea025ff87985a0">admin\_send\_alert\_error</a> </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a8f200da02050727dc257e5c85180b0d6">admin\_send\_alert\_warn</a> </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ac7dfedf5c675e448bfc4301ab000d7f3">admin\_send\_alert\_info</a> </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a9826bfcf16037bf9c3cf2c9e0fd5a3cf">admin\_send\_alert\_debug</a> </li>
                  </ul>
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AdminSendAlertResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#aa31faecc97bf8c1ccaf916c07a8c80c0">◆ </a></span>adminSendAlert() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AdminSendAlertResponse">AdminSendAlertResponse</a> & gpudb::GPUdb::adminSendAlert </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>message</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>label</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>logLevel</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1AdminSendAlertResponse">AdminSendAlertResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Sends a user generated alert to the monitoring system. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>message</td>
                <td>Alert message body. The default value is ''. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>label</td>
                <td>Label to add to alert message. The default value is ''. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>logLevel</td>

                <td>
                  Alert message logging criteria. Supported values:

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#ab1c232389963064b7a0cdda81bb2f2c7">admin\_send\_alert\_fatal</a> </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a69e3d93f492695a187ea025ff87985a0">admin\_send\_alert\_error</a> </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a8f200da02050727dc257e5c85180b0d6">admin\_send\_alert\_warn</a> </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ac7dfedf5c675e448bfc4301ab000d7f3">admin\_send\_alert\_info</a> </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a9826bfcf16037bf9c3cf2c9e0fd5a3cf">admin\_send\_alert\_debug</a> </li>
                  </ul>
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AdminSendAlertResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AdminSendAlertResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#aa089f0e3ed5c9c02279eb96ac08ef332">◆ </a></span>adminShowAlerts() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AdminShowAlertsResponse">AdminShowAlertsResponse</a> gpudb::GPUdb::adminShowAlerts </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1AdminShowAlertsRequest">AdminShowAlertsRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Requests a list of the most recent alerts. </p>
        <p>Returns lists of alert data, including timestamp and type.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AdminShowAlertsRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AdminShowAlertsResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a4e548f403acb088b49eeefecf1255ee3">◆ </a></span>adminShowAlerts() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AdminShowAlertsResponse">AdminShowAlertsResponse</a> & gpudb::GPUdb::adminShowAlerts </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1AdminShowAlertsRequest">AdminShowAlertsRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1AdminShowAlertsResponse">AdminShowAlertsResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Requests a list of the most recent alerts. </p>
        <p>Returns lists of alert data, including timestamp and type.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AdminShowAlertsRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AdminShowAlertsResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AdminShowAlertsResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a20dcafad2c17506babc2c89204723066">◆ </a></span>adminShowAlerts() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AdminShowAlertsResponse">AdminShowAlertsResponse</a> gpudb::GPUdb::adminShowAlerts </td>
            <td>(</td>
            <td>const int32\_t</td>
            <td><span><span>numAlerts</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Requests a list of the most recent alerts. </p>
        <p>Returns lists of alert data, including timestamp and type.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>numAlerts</td>
                <td>Number of most recent alerts to request. The response will include up to <span>numAlerts</span> depending on how many alerts there are in the system. A value of 0 returns all stored alerts. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AdminShowAlertsResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ac276578f3cb6b5959e7d47d54b408542">◆ </a></span>adminShowAlerts() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AdminShowAlertsResponse">AdminShowAlertsResponse</a> & gpudb::GPUdb::adminShowAlerts </td>
            <td>(</td>
            <td>const int32\_t</td>
            <td><span><span>numAlerts</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1AdminShowAlertsResponse">AdminShowAlertsResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Requests a list of the most recent alerts. </p>
        <p>Returns lists of alert data, including timestamp and type.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>numAlerts</td>
                <td>Number of most recent alerts to request. The response will include up to <span>numAlerts</span> depending on how many alerts there are in the system. A value of 0 returns all stored alerts. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AdminShowAlertsResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AdminShowAlertsResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#aa11e77cd54b2d748b261fccbb9508765">◆ </a></span>adminShowClusterOperations() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AdminShowClusterOperationsResponse">AdminShowClusterOperationsResponse</a> gpudb::GPUdb::adminShowClusterOperations </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1AdminShowClusterOperationsRequest">AdminShowClusterOperationsRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Requests the detailed status of the current operation (by default) or a prior cluster operation specified by <a href="/content/api/cpp/structgpudb_1_1AdminShowClusterOperationsRequest#ac6af84e10bd8b42efba940403e60583a">historyIndex</a>. </p>
        <p>Returns details on the requested cluster operation.</p>
        <p>The response will also indicate how many cluster operations are stored in the history.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AdminShowClusterOperationsRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AdminShowClusterOperationsResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a94884d8e6fd62a9b323eece3fceb919d">◆ </a></span>adminShowClusterOperations() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AdminShowClusterOperationsResponse">AdminShowClusterOperationsResponse</a> & gpudb::GPUdb::adminShowClusterOperations </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1AdminShowClusterOperationsRequest">AdminShowClusterOperationsRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1AdminShowClusterOperationsResponse">AdminShowClusterOperationsResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Requests the detailed status of the current operation (by default) or a prior cluster operation specified by <a href="/content/api/cpp/structgpudb_1_1AdminShowClusterOperationsRequest#ac6af84e10bd8b42efba940403e60583a">historyIndex</a>. </p>
        <p>Returns details on the requested cluster operation.</p>
        <p>The response will also indicate how many cluster operations are stored in the history.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AdminShowClusterOperationsRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AdminShowClusterOperationsResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AdminShowClusterOperationsResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a291cba4486c80a01e6f7b50b22a10a23">◆ </a></span>adminShowClusterOperations() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AdminShowClusterOperationsResponse">AdminShowClusterOperationsResponse</a> gpudb::GPUdb::adminShowClusterOperations </td>
            <td>(</td>
            <td>const int32\_t</td>
            <td><span><span>historyIndex</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Requests the detailed status of the current operation (by default) or a prior cluster operation specified by <span>historyIndex</span>. </p>
        <p>Returns details on the requested cluster operation.</p>
        <p>The response will also indicate how many cluster operations are stored in the history.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>historyIndex</td>
                <td>Indicates which cluster operation to retrieve. Use 0 for the most recent. The default value is 0. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AdminShowClusterOperationsResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a2f774e54ed3366000d893ac707c586c9">◆ </a></span>adminShowClusterOperations() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AdminShowClusterOperationsResponse">AdminShowClusterOperationsResponse</a> & gpudb::GPUdb::adminShowClusterOperations </td>
            <td>(</td>
            <td>const int32\_t</td>
            <td><span><span>historyIndex</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1AdminShowClusterOperationsResponse">AdminShowClusterOperationsResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Requests the detailed status of the current operation (by default) or a prior cluster operation specified by <span>historyIndex</span>. </p>
        <p>Returns details on the requested cluster operation.</p>
        <p>The response will also indicate how many cluster operations are stored in the history.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>historyIndex</td>
                <td>Indicates which cluster operation to retrieve. Use 0 for the most recent. The default value is 0. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AdminShowClusterOperationsResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AdminShowClusterOperationsResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a1a878c279cea5c797d9ba2059fc359ae">◆ </a></span>adminShowJobs() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AdminShowJobsResponse">AdminShowJobsResponse</a> gpudb::GPUdb::adminShowJobs </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1AdminShowJobsRequest">AdminShowJobsRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Get a list of the current jobs in <a href="/content/api/cpp/classgpudb_1_1GPUdb">GPUdb</a>. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AdminShowJobsRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AdminShowJobsResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ab3936c03c0c0f5da6a4741c2b00f3133">◆ </a></span>adminShowJobs() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AdminShowJobsResponse">AdminShowJobsResponse</a> & gpudb::GPUdb::adminShowJobs </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1AdminShowJobsRequest">AdminShowJobsRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1AdminShowJobsResponse">AdminShowJobsResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Get a list of the current jobs in <a href="/content/api/cpp/classgpudb_1_1GPUdb">GPUdb</a>. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AdminShowJobsRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AdminShowJobsResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AdminShowJobsResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a0ca888e77117b227a6da7af58bbb64b7">◆ </a></span>adminShowJobs() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AdminShowJobsResponse">AdminShowJobsResponse</a> gpudb::GPUdb::adminShowJobs </td>
            <td>(</td>
            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Get a list of the current jobs in <a href="/content/api/cpp/classgpudb_1_1GPUdb">GPUdb</a>. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a8852afec028c0685681d6ee167a122ee">admin\_show\_jobs\_show\_async\_jobs</a>: If <a href="/content/api/cpp/namespacegpudb#aea2061b4d5051df0abbe6fdef57824ef">true</a>, then the completed async jobs are also included in the response. By default, once the async jobs are completed they are no longer included in the jobs list. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#aea2061b4d5051df0abbe6fdef57824ef">admin\_show\_jobs\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a1579c6a2b1addb06a9f6fb5cb5660443">admin\_show\_jobs\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a1579c6a2b1addb06a9f6fb5cb5660443">admin\_show\_jobs\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ad3e0351356b84289e6cb04b8dd128eff">admin\_show\_jobs\_show\_worker\_info</a>: If <a href="/content/api/cpp/namespacegpudb#aea2061b4d5051df0abbe6fdef57824ef">true</a>, then information is also returned from worker ranks. By default only status from the head rank is returned. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#aea2061b4d5051df0abbe6fdef57824ef">admin\_show\_jobs\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a1579c6a2b1addb06a9f6fb5cb5660443">admin\_show\_jobs\_false</a> </li>
                      </ul>
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AdminShowJobsResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#aa5763f88ff54e01cca9e7f52230c4680">◆ </a></span>adminShowJobs() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AdminShowJobsResponse">AdminShowJobsResponse</a> & gpudb::GPUdb::adminShowJobs </td>
            <td>(</td>
            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1AdminShowJobsResponse">AdminShowJobsResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Get a list of the current jobs in <a href="/content/api/cpp/classgpudb_1_1GPUdb">GPUdb</a>. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a8852afec028c0685681d6ee167a122ee">admin\_show\_jobs\_show\_async\_jobs</a>: If <a href="/content/api/cpp/namespacegpudb#aea2061b4d5051df0abbe6fdef57824ef">true</a>, then the completed async jobs are also included in the response. By default, once the async jobs are completed they are no longer included in the jobs list. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#aea2061b4d5051df0abbe6fdef57824ef">admin\_show\_jobs\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a1579c6a2b1addb06a9f6fb5cb5660443">admin\_show\_jobs\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a1579c6a2b1addb06a9f6fb5cb5660443">admin\_show\_jobs\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ad3e0351356b84289e6cb04b8dd128eff">admin\_show\_jobs\_show\_worker\_info</a>: If <a href="/content/api/cpp/namespacegpudb#aea2061b4d5051df0abbe6fdef57824ef">true</a>, then information is also returned from worker ranks. By default only status from the head rank is returned. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#aea2061b4d5051df0abbe6fdef57824ef">admin\_show\_jobs\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a1579c6a2b1addb06a9f6fb5cb5660443">admin\_show\_jobs\_false</a> </li>
                      </ul>
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AdminShowJobsResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AdminShowJobsResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a2be5c9f06b420c8506042cf997881f5f">◆ </a></span>adminShowShards() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AdminShowShardsResponse">AdminShowShardsResponse</a> gpudb::GPUdb::adminShowShards </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1AdminShowShardsRequest">AdminShowShardsRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Show the mapping of shards to the corresponding rank and tom. </p>
        <p>The response message contains list of 16384 (total number of shards in the system) Rank and TOM numbers corresponding to each shard.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AdminShowShardsRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AdminShowShardsResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a7a7df0301c8d4bba30e10c5a4a9262fa">◆ </a></span>adminShowShards() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AdminShowShardsResponse">AdminShowShardsResponse</a> & gpudb::GPUdb::adminShowShards </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1AdminShowShardsRequest">AdminShowShardsRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1AdminShowShardsResponse">AdminShowShardsResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Show the mapping of shards to the corresponding rank and tom. </p>
        <p>The response message contains list of 16384 (total number of shards in the system) Rank and TOM numbers corresponding to each shard.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AdminShowShardsRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AdminShowShardsResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AdminShowShardsResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#aece0b9daf988f3907f63182816d341ef">◆ </a></span>adminShowShards() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AdminShowShardsResponse">AdminShowShardsResponse</a> gpudb::GPUdb::adminShowShards </td>
            <td>(</td>
            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Show the mapping of shards to the corresponding rank and tom. </p>
        <p>The response message contains list of 16384 (total number of shards in the system) Rank and TOM numbers corresponding to each shard.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AdminShowShardsResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a16118ffb6ba2825aeb6fa2cd09e71430">◆ </a></span>adminShowShards() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AdminShowShardsResponse">AdminShowShardsResponse</a> & gpudb::GPUdb::adminShowShards </td>
            <td>(</td>
            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1AdminShowShardsResponse">AdminShowShardsResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Show the mapping of shards to the corresponding rank and tom. </p>
        <p>The response message contains list of 16384 (total number of shards in the system) Rank and TOM numbers corresponding to each shard.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AdminShowShardsResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AdminShowShardsResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a6a4b1b30ce919c660ef04f11e7b24b5c">◆ </a></span>adminShutdown() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AdminShutdownResponse">AdminShutdownResponse</a> gpudb::GPUdb::adminShutdown </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1AdminShutdownRequest">AdminShutdownRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Exits the database server application. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AdminShutdownRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AdminShutdownResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#abc3a6fe9fb271905c4136afb676cc71a">◆ </a></span>adminShutdown() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AdminShutdownResponse">AdminShutdownResponse</a> & gpudb::GPUdb::adminShutdown </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1AdminShutdownRequest">AdminShutdownRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1AdminShutdownResponse">AdminShutdownResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Exits the database server application. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AdminShutdownRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AdminShutdownResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AdminShutdownResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a523a65e0fd292d5f76222153d213f08a">◆ </a></span>adminShutdown() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AdminShutdownResponse">AdminShutdownResponse</a> gpudb::GPUdb::adminShutdown </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>exitType</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>authorization</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Exits the database server application. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>exitType</td>
                <td>Reserved for future use. User can pass an empty string. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>authorization</td>
                <td>No longer used. User can pass an empty string. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AdminShutdownResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a32b32667fb7d9d45a2b0db686ae82ee6">◆ </a></span>adminShutdown() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AdminShutdownResponse">AdminShutdownResponse</a> & gpudb::GPUdb::adminShutdown </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>exitType</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>authorization</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1AdminShutdownResponse">AdminShutdownResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Exits the database server application. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>exitType</td>
                <td>Reserved for future use. User can pass an empty string. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>authorization</td>
                <td>No longer used. User can pass an empty string. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AdminShutdownResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AdminShutdownResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a2c4d8fe04dc3c5feb4e5e343889bddf8">◆ </a></span>adminSwitchover() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AdminSwitchoverResponse">AdminSwitchoverResponse</a> gpudb::GPUdb::adminSwitchover </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1AdminSwitchoverRequest">AdminSwitchoverRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Manually switch over one or more processes to another host. </p>
        <p>Individual ranks or entire hosts may be moved to another host.</p>

        <div>
          <div>Attention</div>
          <div>This method should be used for on-premise deployments only.</div>
        </div>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AdminSwitchoverRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AdminSwitchoverResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a2d0d5e334a3de21e3794c94494d4a4c9">◆ </a></span>adminSwitchover() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AdminSwitchoverResponse">AdminSwitchoverResponse</a> & gpudb::GPUdb::adminSwitchover </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1AdminSwitchoverRequest">AdminSwitchoverRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1AdminSwitchoverResponse">AdminSwitchoverResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Manually switch over one or more processes to another host. </p>
        <p>Individual ranks or entire hosts may be moved to another host.</p>

        <div>
          <div>Attention</div>
          <div>This method should be used for on-premise deployments only.</div>
        </div>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AdminSwitchoverRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AdminSwitchoverResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AdminSwitchoverResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a48a805373da1ea7f31119c18ead8750a">◆ </a></span>adminSwitchover() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AdminSwitchoverResponse">AdminSwitchoverResponse</a> gpudb::GPUdb::adminSwitchover </td>
            <td>(</td>
            <td>const std::vector\< std::string > &</td>
            <td><span><span>processes</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< std::string > &</td>
            <td><span><span>destinations</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Manually switch over one or more processes to another host. </p>
        <p>Individual ranks or entire hosts may be moved to another host.</p>

        <div>
          <div>Attention</div>
          <div>This method should be used for on-premise deployments only.</div>
        </div>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>processes</td>
                <td>Indicates the process identifier to switch over to another host. <a href="/content/api/cpp/classgpudb_1_1GPUdb_1_1Options">Options</a> are 'hostN' and 'rankN' where 'N' corresponds to the number associated with a host or rank in the <a href="/content/config/#config-main-network">Network</a> section of the gpudb.conf file; e.g., 'host\[N].address' or 'rank\[N].host'. If 'hostN' is provided, all processes on that host will be moved to another host. Each entry in this array will be switched over to the corresponding host entry at the same index in <span>destinations</span>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>destinations</td>
                <td>Indicates to which host to switch over each corresponding process given in <span>processes</span>. Each index must be specified as 'hostN' where 'N' corresponds to the number associated with a host or rank in the <a href="/content/config/#config-main-network">Network</a> section of the gpudb.conf file; e.g., 'host\[N].address'. Each entry in this array will receive the corresponding process entry at the same index in <span>processes</span>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#acd3f534dccc021ffcc5aafeee1cfc902">admin\_switchover\_dry\_run</a>: If set to <a href="/content/api/cpp/namespacegpudb#a925dd1792a5d66c16430da2ca9b80f3d">true</a>, only validation checks will be performed. Nothing is switched over. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a925dd1792a5d66c16430da2ca9b80f3d">admin\_switchover\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a9a9e59d6e159b9ebb9724dc5e5dc63cc">admin\_switchover\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a9a9e59d6e159b9ebb9724dc5e5dc63cc">admin\_switchover\_false</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AdminSwitchoverResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a3809c13a0fefaf894419355760f09e5e">◆ </a></span>adminSwitchover() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AdminSwitchoverResponse">AdminSwitchoverResponse</a> & gpudb::GPUdb::adminSwitchover </td>
            <td>(</td>
            <td>const std::vector\< std::string > &</td>
            <td><span><span>processes</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< std::string > &</td>
            <td><span><span>destinations</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1AdminSwitchoverResponse">AdminSwitchoverResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Manually switch over one or more processes to another host. </p>
        <p>Individual ranks or entire hosts may be moved to another host.</p>

        <div>
          <div>Attention</div>
          <div>This method should be used for on-premise deployments only.</div>
        </div>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>processes</td>
                <td>Indicates the process identifier to switch over to another host. <a href="/content/api/cpp/classgpudb_1_1GPUdb_1_1Options">Options</a> are 'hostN' and 'rankN' where 'N' corresponds to the number associated with a host or rank in the <a href="/content/config/#config-main-network">Network</a> section of the gpudb.conf file; e.g., 'host\[N].address' or 'rank\[N].host'. If 'hostN' is provided, all processes on that host will be moved to another host. Each entry in this array will be switched over to the corresponding host entry at the same index in <span>destinations</span>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>destinations</td>
                <td>Indicates to which host to switch over each corresponding process given in <span>processes</span>. Each index must be specified as 'hostN' where 'N' corresponds to the number associated with a host or rank in the <a href="/content/config/#config-main-network">Network</a> section of the gpudb.conf file; e.g., 'host\[N].address'. Each entry in this array will receive the corresponding process entry at the same index in <span>processes</span>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#acd3f534dccc021ffcc5aafeee1cfc902">admin\_switchover\_dry\_run</a>: If set to <a href="/content/api/cpp/namespacegpudb#a925dd1792a5d66c16430da2ca9b80f3d">true</a>, only validation checks will be performed. Nothing is switched over. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a925dd1792a5d66c16430da2ca9b80f3d">admin\_switchover\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a9a9e59d6e159b9ebb9724dc5e5dc63cc">admin\_switchover\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a9a9e59d6e159b9ebb9724dc5e5dc63cc">admin\_switchover\_false</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AdminSwitchoverResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AdminSwitchoverResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ac2abe130ad4178e02001d86b4874e856">◆ </a></span>adminVerifyDb() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AdminVerifyDbResponse">AdminVerifyDbResponse</a> gpudb::GPUdb::adminVerifyDb </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1AdminVerifyDbRequest">AdminVerifyDbRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Verify database is in a consistent state. </p>
        <p>When inconsistencies or errors are found, the verified\_ok flag in the response is set to false and the list of errors found is provided in the error\_list.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AdminVerifyDbRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AdminVerifyDbResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a11a512b0c386adcd95d328d971f8ea3f">◆ </a></span>adminVerifyDb() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AdminVerifyDbResponse">AdminVerifyDbResponse</a> & gpudb::GPUdb::adminVerifyDb </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1AdminVerifyDbRequest">AdminVerifyDbRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1AdminVerifyDbResponse">AdminVerifyDbResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Verify database is in a consistent state. </p>
        <p>When inconsistencies or errors are found, the verified\_ok flag in the response is set to false and the list of errors found is provided in the error\_list.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AdminVerifyDbRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AdminVerifyDbResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AdminVerifyDbResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a4651bd91e69f7a8aa697471fa7ddba31">◆ </a></span>adminVerifyDb() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AdminVerifyDbResponse">AdminVerifyDbResponse</a> gpudb::GPUdb::adminVerifyDb </td>
            <td>(</td>
            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Verify database is in a consistent state. </p>
        <p>When inconsistencies or errors are found, the verified\_ok flag in the response is set to false and the list of errors found is provided in the error\_list.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a84b05b245acd65978f3eaf80b7ce1975">admin\_verify\_db\_rebuild\_on\_error</a>: \[DEPRECATED] Use the Rebuild DB feature of GAdmin instead. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad3d267d4d815f1c947a22c9c12b41969">admin\_verify\_db\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aec66aab332a42a917556a31ace8f958c">admin\_verify\_db\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#aec66aab332a42a917556a31ace8f958c">admin\_verify\_db\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a2f38ccb4151bcf241851fa30116f69e5">admin\_verify\_db\_verify\_nulls</a>: When <a href="/content/api/cpp/namespacegpudb#ad3d267d4d815f1c947a22c9c12b41969">true</a>, verifies that null values are set to zero. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad3d267d4d815f1c947a22c9c12b41969">admin\_verify\_db\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aec66aab332a42a917556a31ace8f958c">admin\_verify\_db\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#aec66aab332a42a917556a31ace8f958c">admin\_verify\_db\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#aeab1dbdba6dc054ae372f268f47d2b5a">admin\_verify\_db\_verify\_persist</a>: When <a href="/content/api/cpp/namespacegpudb#ad3d267d4d815f1c947a22c9c12b41969">true</a>, persistent objects will be compared against their state in memory and workers will be checked for orphaned table data in persist. To check for orphaned worker data, either set <a href="/content/api/cpp/namespacegpudb#a5deb16f1c1ae3d60d2e61ccb258b4f41">concurrent\_safe</a> in <span>options</span> to <a href="/content/api/cpp/namespacegpudb#ad3d267d4d815f1c947a22c9c12b41969">true</a> or place the database offline. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad3d267d4d815f1c947a22c9c12b41969">admin\_verify\_db\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aec66aab332a42a917556a31ace8f958c">admin\_verify\_db\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#aec66aab332a42a917556a31ace8f958c">admin\_verify\_db\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a5deb16f1c1ae3d60d2e61ccb258b4f41">admin\_verify\_db\_concurrent\_safe</a>: When <a href="/content/api/cpp/namespacegpudb#ad3d267d4d815f1c947a22c9c12b41969">true</a>, allows this endpoint to be run safely with other concurrent database operations. Other operations may be slower while this is running. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad3d267d4d815f1c947a22c9c12b41969">admin\_verify\_db\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aec66aab332a42a917556a31ace8f958c">admin\_verify\_db\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ad3d267d4d815f1c947a22c9c12b41969">admin\_verify\_db\_true</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#aeceb23ae2dabb7c363a438cbbcee80b1">admin\_verify\_db\_verify\_rank0</a>: If <a href="/content/api/cpp/namespacegpudb#ad3d267d4d815f1c947a22c9c12b41969">true</a>, compare rank0 table metadata against workers' metadata. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad3d267d4d815f1c947a22c9c12b41969">admin\_verify\_db\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aec66aab332a42a917556a31ace8f958c">admin\_verify\_db\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#aec66aab332a42a917556a31ace8f958c">admin\_verify\_db\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ab35d54c59415714be083e0413bc973f2">admin\_verify\_db\_delete\_orphaned\_tables</a>: If <a href="/content/api/cpp/namespacegpudb#ad3d267d4d815f1c947a22c9c12b41969">true</a>, orphaned table directories found on workers for which there is no corresponding metadata will be deleted. It is recommended to run this while the database is offline OR set <a href="/content/api/cpp/namespacegpudb#a5deb16f1c1ae3d60d2e61ccb258b4f41">concurrent\_safe</a> in <span>options</span> to <a href="/content/api/cpp/namespacegpudb#ad3d267d4d815f1c947a22c9c12b41969">true</a>. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad3d267d4d815f1c947a22c9c12b41969">admin\_verify\_db\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aec66aab332a42a917556a31ace8f958c">admin\_verify\_db\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#aec66aab332a42a917556a31ace8f958c">admin\_verify\_db\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a503a9bd289e5aff62cfb89fd825fdab7">admin\_verify\_db\_verify\_orphaned\_tables\_only</a>: If <a href="/content/api/cpp/namespacegpudb#ad3d267d4d815f1c947a22c9c12b41969">true</a>, only the presence of orphaned table directories will be checked, all persistence and table consistency checks will be skipped. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad3d267d4d815f1c947a22c9c12b41969">admin\_verify\_db\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aec66aab332a42a917556a31ace8f958c">admin\_verify\_db\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#aec66aab332a42a917556a31ace8f958c">admin\_verify\_db\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a897e19c37c4606b8958cf13d8ec36c6d">admin\_verify\_db\_table\_includes</a>: Comma-separated list of table names to include when verifying table consistency on wokers. Cannot be used simultaneously with <a href="/content/api/cpp/namespacegpudb#a5d284f122b01040fb7e5a482c92ea0e3">table\_excludes</a>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a5d284f122b01040fb7e5a482c92ea0e3">admin\_verify\_db\_table\_excludes</a>: Comma-separated list of table names to exclude when verifying table consistency on wokers. Cannot be used simultaneously with <a href="/content/api/cpp/namespacegpudb#a897e19c37c4606b8958cf13d8ec36c6d">table\_includes</a>. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AdminVerifyDbResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a8c581db10e112cbd00bc2e48fcc065e5">◆ </a></span>adminVerifyDb() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AdminVerifyDbResponse">AdminVerifyDbResponse</a> & gpudb::GPUdb::adminVerifyDb </td>
            <td>(</td>
            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1AdminVerifyDbResponse">AdminVerifyDbResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Verify database is in a consistent state. </p>
        <p>When inconsistencies or errors are found, the verified\_ok flag in the response is set to false and the list of errors found is provided in the error\_list.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a84b05b245acd65978f3eaf80b7ce1975">admin\_verify\_db\_rebuild\_on\_error</a>: \[DEPRECATED] Use the Rebuild DB feature of GAdmin instead. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad3d267d4d815f1c947a22c9c12b41969">admin\_verify\_db\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aec66aab332a42a917556a31ace8f958c">admin\_verify\_db\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#aec66aab332a42a917556a31ace8f958c">admin\_verify\_db\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a2f38ccb4151bcf241851fa30116f69e5">admin\_verify\_db\_verify\_nulls</a>: When <a href="/content/api/cpp/namespacegpudb#ad3d267d4d815f1c947a22c9c12b41969">true</a>, verifies that null values are set to zero. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad3d267d4d815f1c947a22c9c12b41969">admin\_verify\_db\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aec66aab332a42a917556a31ace8f958c">admin\_verify\_db\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#aec66aab332a42a917556a31ace8f958c">admin\_verify\_db\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#aeab1dbdba6dc054ae372f268f47d2b5a">admin\_verify\_db\_verify\_persist</a>: When <a href="/content/api/cpp/namespacegpudb#ad3d267d4d815f1c947a22c9c12b41969">true</a>, persistent objects will be compared against their state in memory and workers will be checked for orphaned table data in persist. To check for orphaned worker data, either set <a href="/content/api/cpp/namespacegpudb#a5deb16f1c1ae3d60d2e61ccb258b4f41">concurrent\_safe</a> in <span>options</span> to <a href="/content/api/cpp/namespacegpudb#ad3d267d4d815f1c947a22c9c12b41969">true</a> or place the database offline. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad3d267d4d815f1c947a22c9c12b41969">admin\_verify\_db\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aec66aab332a42a917556a31ace8f958c">admin\_verify\_db\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#aec66aab332a42a917556a31ace8f958c">admin\_verify\_db\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a5deb16f1c1ae3d60d2e61ccb258b4f41">admin\_verify\_db\_concurrent\_safe</a>: When <a href="/content/api/cpp/namespacegpudb#ad3d267d4d815f1c947a22c9c12b41969">true</a>, allows this endpoint to be run safely with other concurrent database operations. Other operations may be slower while this is running. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad3d267d4d815f1c947a22c9c12b41969">admin\_verify\_db\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aec66aab332a42a917556a31ace8f958c">admin\_verify\_db\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ad3d267d4d815f1c947a22c9c12b41969">admin\_verify\_db\_true</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#aeceb23ae2dabb7c363a438cbbcee80b1">admin\_verify\_db\_verify\_rank0</a>: If <a href="/content/api/cpp/namespacegpudb#ad3d267d4d815f1c947a22c9c12b41969">true</a>, compare rank0 table metadata against workers' metadata. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad3d267d4d815f1c947a22c9c12b41969">admin\_verify\_db\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aec66aab332a42a917556a31ace8f958c">admin\_verify\_db\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#aec66aab332a42a917556a31ace8f958c">admin\_verify\_db\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ab35d54c59415714be083e0413bc973f2">admin\_verify\_db\_delete\_orphaned\_tables</a>: If <a href="/content/api/cpp/namespacegpudb#ad3d267d4d815f1c947a22c9c12b41969">true</a>, orphaned table directories found on workers for which there is no corresponding metadata will be deleted. It is recommended to run this while the database is offline OR set <a href="/content/api/cpp/namespacegpudb#a5deb16f1c1ae3d60d2e61ccb258b4f41">concurrent\_safe</a> in <span>options</span> to <a href="/content/api/cpp/namespacegpudb#ad3d267d4d815f1c947a22c9c12b41969">true</a>. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad3d267d4d815f1c947a22c9c12b41969">admin\_verify\_db\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aec66aab332a42a917556a31ace8f958c">admin\_verify\_db\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#aec66aab332a42a917556a31ace8f958c">admin\_verify\_db\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a503a9bd289e5aff62cfb89fd825fdab7">admin\_verify\_db\_verify\_orphaned\_tables\_only</a>: If <a href="/content/api/cpp/namespacegpudb#ad3d267d4d815f1c947a22c9c12b41969">true</a>, only the presence of orphaned table directories will be checked, all persistence and table consistency checks will be skipped. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad3d267d4d815f1c947a22c9c12b41969">admin\_verify\_db\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aec66aab332a42a917556a31ace8f958c">admin\_verify\_db\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#aec66aab332a42a917556a31ace8f958c">admin\_verify\_db\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a897e19c37c4606b8958cf13d8ec36c6d">admin\_verify\_db\_table\_includes</a>: Comma-separated list of table names to include when verifying table consistency on wokers. Cannot be used simultaneously with <a href="/content/api/cpp/namespacegpudb#a5d284f122b01040fb7e5a482c92ea0e3">table\_excludes</a>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a5d284f122b01040fb7e5a482c92ea0e3">admin\_verify\_db\_table\_excludes</a>: Comma-separated list of table names to exclude when verifying table consistency on wokers. Cannot be used simultaneously with <a href="/content/api/cpp/namespacegpudb#a897e19c37c4606b8958cf13d8ec36c6d">table\_includes</a>. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AdminVerifyDbResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AdminVerifyDbResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a53f33c09e6417aa4f7ce8f9d2bf5ae17">◆ </a></span>aggregateConvexHull() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AggregateConvexHullResponse">AggregateConvexHullResponse</a> gpudb::GPUdb::aggregateConvexHull </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1AggregateConvexHullRequest">AggregateConvexHullRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Calculates and returns the convex hull for the values in a table specified by <a href="/content/api/cpp/structgpudb_1_1AggregateConvexHullRequest#aa5c059d247ea25d4b3fa3431300786c0">tableName</a>. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AggregateConvexHullRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AggregateConvexHullResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a5342713aad628b695f89b31e5385d1bc">◆ </a></span>aggregateConvexHull() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AggregateConvexHullResponse">AggregateConvexHullResponse</a> & gpudb::GPUdb::aggregateConvexHull </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1AggregateConvexHullRequest">AggregateConvexHullRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1AggregateConvexHullResponse">AggregateConvexHullResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Calculates and returns the convex hull for the values in a table specified by <a href="/content/api/cpp/structgpudb_1_1AggregateConvexHullRequest#aa5c059d247ea25d4b3fa3431300786c0">tableName</a>. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AggregateConvexHullRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AggregateConvexHullResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AggregateConvexHullResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ab71694e118f02bd23b4174ced64786eb">◆ </a></span>aggregateConvexHull() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AggregateConvexHullResponse">AggregateConvexHullResponse</a> gpudb::GPUdb::aggregateConvexHull </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>xColumnName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>yColumnName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Calculates and returns the convex hull for the values in a table specified by <span>tableName</span>. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of table on which the operation will be performed. Must be an existing table, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>xColumnName</td>
                <td>Name of the column containing the x coordinates of the points for the operation being performed. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>yColumnName</td>
                <td>Name of the column containing the y coordinates of the points for the operation being performed. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AggregateConvexHullResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a361f86c14f9326e73fff076f842f69ed">◆ </a></span>aggregateConvexHull() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AggregateConvexHullResponse">AggregateConvexHullResponse</a> & gpudb::GPUdb::aggregateConvexHull </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>xColumnName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>yColumnName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1AggregateConvexHullResponse">AggregateConvexHullResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Calculates and returns the convex hull for the values in a table specified by <span>tableName</span>. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of table on which the operation will be performed. Must be an existing table, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>xColumnName</td>
                <td>Name of the column containing the x coordinates of the points for the operation being performed. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>yColumnName</td>
                <td>Name of the column containing the y coordinates of the points for the operation being performed. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AggregateConvexHullResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AggregateConvexHullResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a76d7b0a4e087f94ccd17f65a38f3fc8e">◆ </a></span>aggregateGroupBy() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AggregateGroupByResponse">AggregateGroupByResponse</a> gpudb::GPUdb::aggregateGroupBy </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1AggregateGroupByRequest">AggregateGroupByRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Calculates unique combinations (groups) of values for the given columns in a given table or view and computes aggregates on each unique combination. </p>
        <p>This is somewhat analogous to an SQL-style SELECT...GROUP BY.</p>
        <p>For aggregation details and examples, see <a href="/content/concepts/aggregation/">Aggregation</a>. For limitations, see <a href="/content/concepts/aggregation/#limitations">Aggregation Limitations</a>.</p>
        <p>Any column(s) can be grouped on, and all column types except unrestricted-length strings may be used for computing applicable aggregates.</p>
        <p>The results can be paged via the <a href="/content/api/cpp/structgpudb_1_1AggregateGroupByRequest#ad33d5ef5e1c47ab8c549ddad114ee63e">offset</a> and <a href="/content/api/cpp/structgpudb_1_1AggregateGroupByRequest#a5765d2623bfa7ac83104f43748a8bcb1">limit</a> parameters. For example, to get 10 groups with the largest counts the inputs would be: limit=10, options="sort\_order":"descending", "sort\_by":"value".</p>
        <p><a href="/content/api/cpp/structgpudb_1_1AggregateGroupByRequest#a7fb83ff0c7bd454e13268cdfb9c81db4">options</a> can be used to customize behavior of this call e.g. filtering or sorting the results.</p>
        <p>To group by columns 'x' and 'y' and compute the number of objects within each group, use: column\_names=\['x','y','count(\*)'].</p>
        <p>To also compute the sum of 'z' over each group, use: column\_names=\['x','y','count(\*)','sum(z)'].</p>
        <p>Available <a href="/content/concepts/expressions/#aggregate-expressions">aggregation functions</a> are: count(\*), sum, min, max, avg, mean, stddev, stddev\_pop, stddev\_samp, var, var\_pop, var\_samp, arg\_min, arg\_max and count\_distinct.</p>
        <p>Available grouping functions are <a href="/content/concepts/rollup/">Rollup</a>, <a href="/content/concepts/cube/">Cube</a>, and <a href="/content/concepts/grouping_sets/">Grouping Sets</a></p>
        <p>This service also provides support for <a href="/content/concepts/pivot/">Pivot</a> operations.</p>
        <p>Filtering on aggregates is supported via expressions using <a href="/content/concepts/expressions/#aggregate-expressions">aggregation functions</a> supplied to <a href="/content/api/cpp/namespacegpudb#ad1ab7a16358f987414622becec705d1f">having</a>.</p>
        <p>The response is returned as a dynamic schema. For details see: <a href="/content/api/concepts/#dynamic-schemas">dynamic schemas documentation</a>.</p>
        <p>If a <a href="/content/api/cpp/namespacegpudb#a74372aa877ab6529947b269da9d4ae00">result\_table</a> name is specified in the <a href="/content/api/cpp/structgpudb_1_1AggregateGroupByRequest#a7fb83ff0c7bd454e13268cdfb9c81db4">options</a>, the results are stored in a new table with that name–no results are returned in the response. Both the table name and resulting column names must adhere to <a href="/content/concepts/tables/#table">standard naming conventions</a>; column/aggregation expressions will need to be aliased. If the source table's <a href="/content/concepts/tables/#shard-keys">shard key</a> is used as the grouping column(s) and all result records are selected (<a href="/content/api/cpp/structgpudb_1_1AggregateGroupByRequest#ad33d5ef5e1c47ab8c549ddad114ee63e">offset</a> is 0 and <a href="/content/api/cpp/structgpudb_1_1AggregateGroupByRequest#a5765d2623bfa7ac83104f43748a8bcb1">limit</a> is -9999), the result table will be sharded, in all other cases it will be replicated. Sorting will properly function only if the result table is replicated or if there is only one processing node and should not be relied upon in other cases. Not available when any of the values of <a href="/content/api/cpp/structgpudb_1_1AggregateGroupByRequest#a8e3cb49fb147d79eec5ec008d999a2cd">columnNames</a> is an unrestricted-length string.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AggregateGroupByRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AggregateGroupByResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ab2b96dbacb58d0a3e621ded87e0efb3e">◆ </a></span>aggregateGroupBy() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AggregateGroupByResponse">AggregateGroupByResponse</a> & gpudb::GPUdb::aggregateGroupBy </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1AggregateGroupByRequest">AggregateGroupByRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1AggregateGroupByResponse">AggregateGroupByResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Calculates unique combinations (groups) of values for the given columns in a given table or view and computes aggregates on each unique combination. </p>
        <p>This is somewhat analogous to an SQL-style SELECT...GROUP BY.</p>
        <p>For aggregation details and examples, see <a href="/content/concepts/aggregation/">Aggregation</a>. For limitations, see <a href="/content/concepts/aggregation/#limitations">Aggregation Limitations</a>.</p>
        <p>Any column(s) can be grouped on, and all column types except unrestricted-length strings may be used for computing applicable aggregates.</p>
        <p>The results can be paged via the <a href="/content/api/cpp/structgpudb_1_1AggregateGroupByRequest#ad33d5ef5e1c47ab8c549ddad114ee63e">offset</a> and <a href="/content/api/cpp/structgpudb_1_1AggregateGroupByRequest#a5765d2623bfa7ac83104f43748a8bcb1">limit</a> parameters. For example, to get 10 groups with the largest counts the inputs would be: limit=10, options="sort\_order":"descending", "sort\_by":"value".</p>
        <p><a href="/content/api/cpp/structgpudb_1_1AggregateGroupByRequest#a7fb83ff0c7bd454e13268cdfb9c81db4">options</a> can be used to customize behavior of this call e.g. filtering or sorting the results.</p>
        <p>To group by columns 'x' and 'y' and compute the number of objects within each group, use: column\_names=\['x','y','count(\*)'].</p>
        <p>To also compute the sum of 'z' over each group, use: column\_names=\['x','y','count(\*)','sum(z)'].</p>
        <p>Available <a href="/content/concepts/expressions/#aggregate-expressions">aggregation functions</a> are: count(\*), sum, min, max, avg, mean, stddev, stddev\_pop, stddev\_samp, var, var\_pop, var\_samp, arg\_min, arg\_max and count\_distinct.</p>
        <p>Available grouping functions are <a href="/content/concepts/rollup/">Rollup</a>, <a href="/content/concepts/cube/">Cube</a>, and <a href="/content/concepts/grouping_sets/">Grouping Sets</a></p>
        <p>This service also provides support for <a href="/content/concepts/pivot/">Pivot</a> operations.</p>
        <p>Filtering on aggregates is supported via expressions using <a href="/content/concepts/expressions/#aggregate-expressions">aggregation functions</a> supplied to <a href="/content/api/cpp/namespacegpudb#ad1ab7a16358f987414622becec705d1f">having</a>.</p>
        <p>The response is returned as a dynamic schema. For details see: <a href="/content/api/concepts/#dynamic-schemas">dynamic schemas documentation</a>.</p>
        <p>If a <a href="/content/api/cpp/namespacegpudb#a74372aa877ab6529947b269da9d4ae00">result\_table</a> name is specified in the <a href="/content/api/cpp/structgpudb_1_1AggregateGroupByRequest#a7fb83ff0c7bd454e13268cdfb9c81db4">options</a>, the results are stored in a new table with that name–no results are returned in the response. Both the table name and resulting column names must adhere to <a href="/content/concepts/tables/#table">standard naming conventions</a>; column/aggregation expressions will need to be aliased. If the source table's <a href="/content/concepts/tables/#shard-keys">shard key</a> is used as the grouping column(s) and all result records are selected (<a href="/content/api/cpp/structgpudb_1_1AggregateGroupByRequest#ad33d5ef5e1c47ab8c549ddad114ee63e">offset</a> is 0 and <a href="/content/api/cpp/structgpudb_1_1AggregateGroupByRequest#a5765d2623bfa7ac83104f43748a8bcb1">limit</a> is -9999), the result table will be sharded, in all other cases it will be replicated. Sorting will properly function only if the result table is replicated or if there is only one processing node and should not be relied upon in other cases. Not available when any of the values of <a href="/content/api/cpp/structgpudb_1_1AggregateGroupByRequest#a8e3cb49fb147d79eec5ec008d999a2cd">columnNames</a> is an unrestricted-length string.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AggregateGroupByRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AggregateGroupByResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AggregateGroupByResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a30cac962c6aedc8efc312e2b4217ff31">◆ </a></span>aggregateGroupBy() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AggregateGroupByResponse">AggregateGroupByResponse</a> gpudb::GPUdb::aggregateGroupBy </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< std::string > &</td>
            <td><span><span>columnNames</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const int64\_t</td>
            <td><span><span>offset</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const int64\_t</td>
            <td><span><span>limit</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Calculates unique combinations (groups) of values for the given columns in a given table or view and computes aggregates on each unique combination. </p>
        <p>This is somewhat analogous to an SQL-style SELECT...GROUP BY.</p>
        <p>For aggregation details and examples, see <a href="/content/concepts/aggregation/">Aggregation</a>. For limitations, see <a href="/content/concepts/aggregation/#limitations">Aggregation Limitations</a>.</p>
        <p>Any column(s) can be grouped on, and all column types except unrestricted-length strings may be used for computing applicable aggregates.</p>
        <p>The results can be paged via the <span>offset</span> and <span>limit</span> parameters. For example, to get 10 groups with the largest counts the inputs would be: limit=10, options="sort\_order":"descending", "sort\_by":"value".</p>
        <p><span>options</span> can be used to customize behavior of this call e.g. filtering or sorting the results.</p>
        <p>To group by columns 'x' and 'y' and compute the number of objects within each group, use: column\_names=\['x','y','count(\*)'].</p>
        <p>To also compute the sum of 'z' over each group, use: column\_names=\['x','y','count(\*)','sum(z)'].</p>
        <p>Available <a href="/content/concepts/expressions/#aggregate-expressions">aggregation functions</a> are: count(\*), sum, min, max, avg, mean, stddev, stddev\_pop, stddev\_samp, var, var\_pop, var\_samp, arg\_min, arg\_max and count\_distinct.</p>
        <p>Available grouping functions are <a href="/content/concepts/rollup/">Rollup</a>, <a href="/content/concepts/cube/">Cube</a>, and <a href="/content/concepts/grouping_sets/">Grouping Sets</a></p>
        <p>This service also provides support for <a href="/content/concepts/pivot/">Pivot</a> operations.</p>
        <p>Filtering on aggregates is supported via expressions using <a href="/content/concepts/expressions/#aggregate-expressions">aggregation functions</a> supplied to <a href="/content/api/cpp/namespacegpudb#ad1ab7a16358f987414622becec705d1f">having</a>.</p>
        <p>The response is returned as a dynamic schema. For details see: <a href="/content/api/concepts/#dynamic-schemas">dynamic schemas documentation</a>.</p>
        <p>If a <a href="/content/api/cpp/namespacegpudb#a74372aa877ab6529947b269da9d4ae00">result\_table</a> name is specified in the <span>options</span>, the results are stored in a new table with that name–no results are returned in the response. Both the table name and resulting column names must adhere to <a href="/content/concepts/tables/#table">standard naming conventions</a>; column/aggregation expressions will need to be aliased. If the source table's <a href="/content/concepts/tables/#shard-keys">shard key</a> is used as the grouping column(s) and all result records are selected (<span>offset</span> is 0 and <span>limit</span> is -9999), the result table will be sharded, in all other cases it will be replicated. Sorting will properly function only if the result table is replicated or if there is only one processing node and should not be relied upon in other cases. Not available when any of the values of <span>columnNames</span> is an unrestricted-length string.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of an existing table or view on which the operation will be performed, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>columnNames</td>
                <td>List of one or more column names, expressions, and aggregate expressions. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>offset</td>
                <td>A positive integer indicating the number of initial results to skip (this can be useful for paging through the results). The default value is 0. The minimum allowed value is 0. The maximum allowed value is MAX\_INT. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>limit</td>
                <td>A positive integer indicating the maximum number of results to be returned, or END\_OF\_SET (-9999) to indicate that the maximum number of results allowed by the server should be returned. The number of records returned will never exceed the server's own limit, defined by the <a href="/content/config/#config-main-general">max\_get\_records\_size</a> parameter in the server configuration. Use <a href="/content/api/cpp/structgpudb_1_1RawAggregateGroupByResponse#ae76c8102a9ebe81fbfe43a04abfe8ada">hasMoreRecords</a> to see if more records exist in the result to be fetched, and <span>offset</span> and <span>limit</span> to request subsequent pages of results. The default value is -9999. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#aa908254d090a87fb897ac0e6dd799163">aggregate\_group\_by\_create\_temp\_table</a>: If <a href="/content/api/cpp/namespacegpudb#a5ad437d851707f2d854e8a6351cc963a">true</a>, a unique temporary table name will be generated in the sys\_temp schema and used in place of <a href="/content/api/cpp/namespacegpudb#a74372aa877ab6529947b269da9d4ae00">result\_table</a>. If <a href="/content/api/cpp/namespacegpudb#abcbd77d1cdc4e52ecc7b6469bedf5b09">result\_table\_persist</a> is <a href="/content/api/cpp/namespacegpudb#a405aa11a3bdf26b1dcacd96cbb6e403e">false</a> (or unspecified), then this is always allowed even if the caller does not have permission to create tables. The generated name is returned in <a href="/content/api/cpp/namespacegpudb#a12dc6d6449d7b963ee16706c1a91f08e">qualified\_result\_table\_name</a>. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a5ad437d851707f2d854e8a6351cc963a">aggregate\_group\_by\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a405aa11a3bdf26b1dcacd96cbb6e403e">aggregate\_group\_by\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a405aa11a3bdf26b1dcacd96cbb6e403e">aggregate\_group\_by\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a5ccb9fa34308f0415ffd88c3bf069061">aggregate\_group\_by\_collection\_name</a>: \[DEPRECATED–please specify the containing schema as part of <a href="/content/api/cpp/namespacegpudb#a74372aa877ab6529947b269da9d4ae00">result\_table</a> and use <a href="#a33d9a0a8e738d14b688f9f869f9640ad">createSchema</a> to create the schema if non-existent] Name of a schema which is to contain the table specified in <a href="/content/api/cpp/namespacegpudb#a74372aa877ab6529947b269da9d4ae00">result\_table</a>. If the schema provided is non-existent, it will be automatically created. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#af2c22ab3a12dd44da0c9dc5d26bd453c">aggregate\_group\_by\_expression</a>: Filter expression to apply to the table prior to computing the aggregate group by. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a03b07311fd52d5dff96e305b97a25f30">aggregate\_group\_by\_pipelined\_expression\_evaluation</a>: Evaluate the group-by during last JoinedSet filter plan step. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a5ad437d851707f2d854e8a6351cc963a">aggregate\_group\_by\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a405aa11a3bdf26b1dcacd96cbb6e403e">aggregate\_group\_by\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a405aa11a3bdf26b1dcacd96cbb6e403e">aggregate\_group\_by\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#ad1ab7a16358f987414622becec705d1f">aggregate\_group\_by\_having</a>: Filter expression to apply to the aggregated results. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#af106cf07673464dc15d91abbea82799b">aggregate\_group\_by\_sort\_order</a>: \[DEPRECATED–use order\_by instead] String indicating how the returned values should be sorted - ascending or descending. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a28c767d89d2965c6102e89152feb80aa">aggregate\_group\_by\_ascending</a>: Indicates that the returned values should be sorted in ascending order. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a1b2fcf7cfa472b96e381ce240b4a3be9">aggregate\_group\_by\_descending</a>: Indicates that the returned values should be sorted in descending order. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a28c767d89d2965c6102e89152feb80aa">aggregate\_group\_by\_ascending</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a36c24d2770a28810482273a91f22fd4a">aggregate\_group\_by\_sort\_by</a>: \[DEPRECATED–use order\_by instead] String determining how the results are sorted. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad7d16752100c9f83d593b34ccb5607fd">aggregate\_group\_by\_key</a>: Indicates that the returned values should be sorted by key, which corresponds to the grouping columns. If you have multiple grouping columns (and are sorting by key), it will first sort the first grouping column, then the second grouping column, etc. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a4cd65fb3dc2adc11f3530ec064aa1017">aggregate\_group\_by\_value</a>: Indicates that the returned values should be sorted by value, which corresponds to the aggregates. If you have multiple aggregates (and are sorting by value), it will first sort by the first aggregate, then the second aggregate, etc. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a4cd65fb3dc2adc11f3530ec064aa1017">aggregate\_group\_by\_value</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#aae3b9fc5c92010497e01226cffd66d35">aggregate\_group\_by\_order\_by</a>: Comma-separated list of the columns to be sorted by as well as the sort direction, e.g., 'timestamp asc, x desc'. The default value is ''. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a786d7acc46f0e596916684816fe99ac9">aggregate\_group\_by\_strategy\_definition</a>: The <a href="/content/rm/concepts/#tier-strategies">tier strategy</a> for the table and its columns. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a283bf5545e1025a627ffc16bb45fbb5c">aggregate\_group\_by\_compression\_codec</a>: The default <a href="/content/concepts/column_compression/">compression codec</a> for the result table's columns. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a74372aa877ab6529947b269da9d4ae00">aggregate\_group\_by\_result\_table</a>: The name of a table used to store the results, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a> and meeting <a href="/content/concepts/tables/#table-naming-criteria">table naming criteria</a>. Column names (group-by and aggregate fields) need to be given aliases e.g. \["FChar256 as fchar256", "sum(FDouble) as sfd"]. If present, no results are returned in the response. This option is not available if one of the grouping attributes is an unrestricted string (i.e.; not charN) type. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#abcbd77d1cdc4e52ecc7b6469bedf5b09">aggregate\_group\_by\_result\_table\_persist</a>: If <a href="/content/api/cpp/namespacegpudb#a5ad437d851707f2d854e8a6351cc963a">true</a>, then the result table specified in <a href="/content/api/cpp/namespacegpudb#a74372aa877ab6529947b269da9d4ae00">result\_table</a> will be persisted and will not expire unless a <a href="/content/api/cpp/namespacegpudb#ac183c4d55c255403e1ee55e4260428f3">ttl</a> is specified. If <a href="/content/api/cpp/namespacegpudb#a405aa11a3bdf26b1dcacd96cbb6e403e">false</a>, then the result table will be an in-memory table and will expire unless a <a href="/content/api/cpp/namespacegpudb#ac183c4d55c255403e1ee55e4260428f3">ttl</a> is specified otherwise. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a5ad437d851707f2d854e8a6351cc963a">aggregate\_group\_by\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a405aa11a3bdf26b1dcacd96cbb6e403e">aggregate\_group\_by\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a405aa11a3bdf26b1dcacd96cbb6e403e">aggregate\_group\_by\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ad1ef320a0013f97a4309b95ff137e493">aggregate\_group\_by\_result\_table\_force\_replicated</a>: Force the result table to be replicated (ignores any sharding). Must be used in combination with the <a href="/content/api/cpp/namespacegpudb#a74372aa877ab6529947b269da9d4ae00">result\_table</a> option. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a5ad437d851707f2d854e8a6351cc963a">aggregate\_group\_by\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a405aa11a3bdf26b1dcacd96cbb6e403e">aggregate\_group\_by\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a405aa11a3bdf26b1dcacd96cbb6e403e">aggregate\_group\_by\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#af1498816dff4937520b8e577e239e27c">aggregate\_group\_by\_result\_table\_generate\_pk</a>: If <a href="/content/api/cpp/namespacegpudb#a5ad437d851707f2d854e8a6351cc963a">true</a> then set a primary key for the result table. Must be used in combination with the <a href="/content/api/cpp/namespacegpudb#a74372aa877ab6529947b269da9d4ae00">result\_table</a> option. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a5ad437d851707f2d854e8a6351cc963a">aggregate\_group\_by\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a405aa11a3bdf26b1dcacd96cbb6e403e">aggregate\_group\_by\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a405aa11a3bdf26b1dcacd96cbb6e403e">aggregate\_group\_by\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a1a83f1c180921c89f9f6fe4350a536fd">aggregate\_group\_by\_result\_table\_generate\_soft\_pk</a>: If <a href="/content/api/cpp/namespacegpudb#a5ad437d851707f2d854e8a6351cc963a">true</a> then set a soft primary key for the result table. Must be used in combination with the <a href="/content/api/cpp/namespacegpudb#a74372aa877ab6529947b269da9d4ae00">result\_table</a> option. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a5ad437d851707f2d854e8a6351cc963a">aggregate\_group\_by\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a405aa11a3bdf26b1dcacd96cbb6e403e">aggregate\_group\_by\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a405aa11a3bdf26b1dcacd96cbb6e403e">aggregate\_group\_by\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#ac183c4d55c255403e1ee55e4260428f3">aggregate\_group\_by\_ttl</a>: Sets the <a href="/content/concepts/ttl/">TTL</a> of the table specified in <a href="/content/api/cpp/namespacegpudb#a74372aa877ab6529947b269da9d4ae00">result\_table</a>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aef9f514701414d995d637921a4ade049">aggregate\_group\_by\_chunk\_size</a>: Indicates the number of records per chunk to be used for the result table. Must be used in combination with the <a href="/content/api/cpp/namespacegpudb#a74372aa877ab6529947b269da9d4ae00">result\_table</a> option. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ab1feac29a89a52bf764820cffea46386">aggregate\_group\_by\_chunk\_column\_max\_memory</a>: Indicates the target maximum data size for each column in a chunk to be used for the result table. Must be used in combination with the <a href="/content/api/cpp/namespacegpudb#a74372aa877ab6529947b269da9d4ae00">result\_table</a> option. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a0b3e0377408de3b05d255b3edc96a976">aggregate\_group\_by\_chunk\_max\_memory</a>: Indicates the target maximum data size for all columns in a chunk to be used for the result table. Must be used in combination with the <a href="/content/api/cpp/namespacegpudb#a74372aa877ab6529947b269da9d4ae00">result\_table</a> option. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a4434c96644b582233256b0522540328a">aggregate\_group\_by\_create\_indexes</a>: Comma-separated list of columns on which to create indexes on the result table. Must be used in combination with the <a href="/content/api/cpp/namespacegpudb#a74372aa877ab6529947b269da9d4ae00">result\_table</a> option. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a0d751187efd41272bee0792978077474">aggregate\_group\_by\_partition\_type</a>: <a href="/content/concepts/tables/#partitioning">Partitioning</a> scheme to use for the result table. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a26d5fcfc9ea825b8651ec9e317d1528a">aggregate\_group\_by\_RANGE</a>: Use <a href="/content/concepts/tables/#partitioning-by-range">range partitioning</a>. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aaee302741e22b596dc37c0c3a8ec06bb">aggregate\_group\_by\_INTERVAL</a>: Use <a href="/content/concepts/tables/#partitioning-by-interval">interval partitioning</a>. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ae6d45ba2892299ea06d9192ed7e1496d">aggregate\_group\_by\_LIST</a>: Use <a href="/content/concepts/tables/#partitioning-by-list">list partitioning</a>. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#afb419421315aed861fece8885a7feca7">aggregate\_group\_by\_HASH</a>: Use <a href="/content/concepts/tables/#partitioning-by-hash">hash partitioning</a>. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a661cf72cfc6a6377ca43d225353f7551">aggregate\_group\_by\_SERIES</a>: Use <a href="/content/concepts/tables/#partitioning-by-series">series partitioning</a>. </li>
                      </ul>
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a0d25c08cb801736db8117ff232ef56c7">aggregate\_group\_by\_partition\_keys</a>: Comma-separated list of partition keys, which are the columns or column expressions by which records will be assigned to partitions defined by <a href="/content/api/cpp/namespacegpudb#a63df0982814374c894dae665d26956b1">partition\_definitions</a>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a63df0982814374c894dae665d26956b1">aggregate\_group\_by\_partition\_definitions</a>: Comma-separated list of partition definitions, whose format depends on the choice of <a href="/content/api/cpp/namespacegpudb#a0d751187efd41272bee0792978077474">partition\_type</a>. See <a href="/content/concepts/tables/#partitioning-by-range">range partitioning</a>, <a href="/content/concepts/tables/#partitioning-by-interval">interval partitioning</a>, <a href="/content/concepts/tables/#partitioning-by-list">list partitioning</a>, <a href="/content/concepts/tables/#partitioning-by-hash">hash partitioning</a>, or <a href="/content/concepts/tables/#partitioning-by-series">series partitioning</a> for example formats. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a1720f952b51372d743a2b70f77f6363d">aggregate\_group\_by\_is\_automatic\_partition</a>: If <a href="/content/api/cpp/namespacegpudb#a5ad437d851707f2d854e8a6351cc963a">true</a>, a new partition will be created for values which don't fall into an existing partition. Currently only supported for <a href="/content/concepts/tables/#partitioning-by-list">list partitions</a>. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a5ad437d851707f2d854e8a6351cc963a">aggregate\_group\_by\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a405aa11a3bdf26b1dcacd96cbb6e403e">aggregate\_group\_by\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a405aa11a3bdf26b1dcacd96cbb6e403e">aggregate\_group\_by\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#ad0d9e690e51f3a9e8fa8349e630bfb2b">aggregate\_group\_by\_view\_id</a>: ID of view of which the result table will be a member. The default value is ''. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a13aa63edf5b20c7afd14622c3779902a">aggregate\_group\_by\_pivot</a>: Pivot column. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ad3557de9a0528c4d28c4f9d894d14cea">aggregate\_group\_by\_pivot\_values</a>: Comma-separated list of the values in the <a href="/content/api/cpp/namespacegpudb#a13aa63edf5b20c7afd14622c3779902a">pivot</a> column. The list provided will become the column header prefixes in the output. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a63a1dc780a0cce215e53547eb67e893e">aggregate\_group\_by\_grouping\_sets</a>: Customize the grouping attribute sets to compute the aggregates. These sets can include ROLLUP or CUBE operators. The attribute sets should be enclosed in parentheses and can include composite attributes. All attributes specified in the grouping sets must present in the group-by attributes. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a58b20054eea24b15d459d3ccb77ec5a2">aggregate\_group\_by\_rollup</a>: This option is used to specify the multilevel aggregates. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aab3a0075e85f3ac610e4ef828310b5c8">aggregate\_group\_by\_cube</a>: This option is used to specify the multidimensional aggregates. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a1bcc92e6da4ee16c160d648cd4356984">aggregate\_group\_by\_shard\_key</a>: Comma-separated list of the columns to be sharded on; e.g. 'column1, column2'. The columns specified must be present in <span>columnNames</span>. If any alias is given for any column name, the alias must be used, rather than the original column name. The default value is ''. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AggregateGroupByResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a69c3aebe6f34c6101b93222ba8bc395e">◆ </a></span>aggregateGroupBy() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AggregateGroupByResponse">AggregateGroupByResponse</a> & gpudb::GPUdb::aggregateGroupBy </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< std::string > &</td>
            <td><span><span>columnNames</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const int64\_t</td>
            <td><span><span>offset</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const int64\_t</td>
            <td><span><span>limit</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1AggregateGroupByResponse">AggregateGroupByResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Calculates unique combinations (groups) of values for the given columns in a given table or view and computes aggregates on each unique combination. </p>
        <p>This is somewhat analogous to an SQL-style SELECT...GROUP BY.</p>
        <p>For aggregation details and examples, see <a href="/content/concepts/aggregation/">Aggregation</a>. For limitations, see <a href="/content/concepts/aggregation/#limitations">Aggregation Limitations</a>.</p>
        <p>Any column(s) can be grouped on, and all column types except unrestricted-length strings may be used for computing applicable aggregates.</p>
        <p>The results can be paged via the <span>offset</span> and <span>limit</span> parameters. For example, to get 10 groups with the largest counts the inputs would be: limit=10, options="sort\_order":"descending", "sort\_by":"value".</p>
        <p><span>options</span> can be used to customize behavior of this call e.g. filtering or sorting the results.</p>
        <p>To group by columns 'x' and 'y' and compute the number of objects within each group, use: column\_names=\['x','y','count(\*)'].</p>
        <p>To also compute the sum of 'z' over each group, use: column\_names=\['x','y','count(\*)','sum(z)'].</p>
        <p>Available <a href="/content/concepts/expressions/#aggregate-expressions">aggregation functions</a> are: count(\*), sum, min, max, avg, mean, stddev, stddev\_pop, stddev\_samp, var, var\_pop, var\_samp, arg\_min, arg\_max and count\_distinct.</p>
        <p>Available grouping functions are <a href="/content/concepts/rollup/">Rollup</a>, <a href="/content/concepts/cube/">Cube</a>, and <a href="/content/concepts/grouping_sets/">Grouping Sets</a></p>
        <p>This service also provides support for <a href="/content/concepts/pivot/">Pivot</a> operations.</p>
        <p>Filtering on aggregates is supported via expressions using <a href="/content/concepts/expressions/#aggregate-expressions">aggregation functions</a> supplied to <a href="/content/api/cpp/namespacegpudb#ad1ab7a16358f987414622becec705d1f">having</a>.</p>
        <p>The response is returned as a dynamic schema. For details see: <a href="/content/api/concepts/#dynamic-schemas">dynamic schemas documentation</a>.</p>
        <p>If a <a href="/content/api/cpp/namespacegpudb#a74372aa877ab6529947b269da9d4ae00">result\_table</a> name is specified in the <span>options</span>, the results are stored in a new table with that name–no results are returned in the response. Both the table name and resulting column names must adhere to <a href="/content/concepts/tables/#table">standard naming conventions</a>; column/aggregation expressions will need to be aliased. If the source table's <a href="/content/concepts/tables/#shard-keys">shard key</a> is used as the grouping column(s) and all result records are selected (<span>offset</span> is 0 and <span>limit</span> is -9999), the result table will be sharded, in all other cases it will be replicated. Sorting will properly function only if the result table is replicated or if there is only one processing node and should not be relied upon in other cases. Not available when any of the values of <span>columnNames</span> is an unrestricted-length string.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of an existing table or view on which the operation will be performed, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>columnNames</td>
                <td>List of one or more column names, expressions, and aggregate expressions. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>offset</td>
                <td>A positive integer indicating the number of initial results to skip (this can be useful for paging through the results). The default value is 0. The minimum allowed value is 0. The maximum allowed value is MAX\_INT. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>limit</td>
                <td>A positive integer indicating the maximum number of results to be returned, or END\_OF\_SET (-9999) to indicate that the maximum number of results allowed by the server should be returned. The number of records returned will never exceed the server's own limit, defined by the <a href="/content/config/#config-main-general">max\_get\_records\_size</a> parameter in the server configuration. Use <a href="/content/api/cpp/structgpudb_1_1RawAggregateGroupByResponse#ae76c8102a9ebe81fbfe43a04abfe8ada">hasMoreRecords</a> to see if more records exist in the result to be fetched, and <span>offset</span> and <span>limit</span> to request subsequent pages of results. The default value is -9999. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#aa908254d090a87fb897ac0e6dd799163">aggregate\_group\_by\_create\_temp\_table</a>: If <a href="/content/api/cpp/namespacegpudb#a5ad437d851707f2d854e8a6351cc963a">true</a>, a unique temporary table name will be generated in the sys\_temp schema and used in place of <a href="/content/api/cpp/namespacegpudb#a74372aa877ab6529947b269da9d4ae00">result\_table</a>. If <a href="/content/api/cpp/namespacegpudb#abcbd77d1cdc4e52ecc7b6469bedf5b09">result\_table\_persist</a> is <a href="/content/api/cpp/namespacegpudb#a405aa11a3bdf26b1dcacd96cbb6e403e">false</a> (or unspecified), then this is always allowed even if the caller does not have permission to create tables. The generated name is returned in <a href="/content/api/cpp/namespacegpudb#a12dc6d6449d7b963ee16706c1a91f08e">qualified\_result\_table\_name</a>. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a5ad437d851707f2d854e8a6351cc963a">aggregate\_group\_by\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a405aa11a3bdf26b1dcacd96cbb6e403e">aggregate\_group\_by\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a405aa11a3bdf26b1dcacd96cbb6e403e">aggregate\_group\_by\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a5ccb9fa34308f0415ffd88c3bf069061">aggregate\_group\_by\_collection\_name</a>: \[DEPRECATED–please specify the containing schema as part of <a href="/content/api/cpp/namespacegpudb#a74372aa877ab6529947b269da9d4ae00">result\_table</a> and use <a href="#a33d9a0a8e738d14b688f9f869f9640ad">createSchema</a> to create the schema if non-existent] Name of a schema which is to contain the table specified in <a href="/content/api/cpp/namespacegpudb#a74372aa877ab6529947b269da9d4ae00">result\_table</a>. If the schema provided is non-existent, it will be automatically created. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#af2c22ab3a12dd44da0c9dc5d26bd453c">aggregate\_group\_by\_expression</a>: Filter expression to apply to the table prior to computing the aggregate group by. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a03b07311fd52d5dff96e305b97a25f30">aggregate\_group\_by\_pipelined\_expression\_evaluation</a>: Evaluate the group-by during last JoinedSet filter plan step. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a5ad437d851707f2d854e8a6351cc963a">aggregate\_group\_by\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a405aa11a3bdf26b1dcacd96cbb6e403e">aggregate\_group\_by\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a405aa11a3bdf26b1dcacd96cbb6e403e">aggregate\_group\_by\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#ad1ab7a16358f987414622becec705d1f">aggregate\_group\_by\_having</a>: Filter expression to apply to the aggregated results. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#af106cf07673464dc15d91abbea82799b">aggregate\_group\_by\_sort\_order</a>: \[DEPRECATED–use order\_by instead] String indicating how the returned values should be sorted - ascending or descending. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a28c767d89d2965c6102e89152feb80aa">aggregate\_group\_by\_ascending</a>: Indicates that the returned values should be sorted in ascending order. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a1b2fcf7cfa472b96e381ce240b4a3be9">aggregate\_group\_by\_descending</a>: Indicates that the returned values should be sorted in descending order. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a28c767d89d2965c6102e89152feb80aa">aggregate\_group\_by\_ascending</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a36c24d2770a28810482273a91f22fd4a">aggregate\_group\_by\_sort\_by</a>: \[DEPRECATED–use order\_by instead] String determining how the results are sorted. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad7d16752100c9f83d593b34ccb5607fd">aggregate\_group\_by\_key</a>: Indicates that the returned values should be sorted by key, which corresponds to the grouping columns. If you have multiple grouping columns (and are sorting by key), it will first sort the first grouping column, then the second grouping column, etc. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a4cd65fb3dc2adc11f3530ec064aa1017">aggregate\_group\_by\_value</a>: Indicates that the returned values should be sorted by value, which corresponds to the aggregates. If you have multiple aggregates (and are sorting by value), it will first sort by the first aggregate, then the second aggregate, etc. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a4cd65fb3dc2adc11f3530ec064aa1017">aggregate\_group\_by\_value</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#aae3b9fc5c92010497e01226cffd66d35">aggregate\_group\_by\_order\_by</a>: Comma-separated list of the columns to be sorted by as well as the sort direction, e.g., 'timestamp asc, x desc'. The default value is ''. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a786d7acc46f0e596916684816fe99ac9">aggregate\_group\_by\_strategy\_definition</a>: The <a href="/content/rm/concepts/#tier-strategies">tier strategy</a> for the table and its columns. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a283bf5545e1025a627ffc16bb45fbb5c">aggregate\_group\_by\_compression\_codec</a>: The default <a href="/content/concepts/column_compression/">compression codec</a> for the result table's columns. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a74372aa877ab6529947b269da9d4ae00">aggregate\_group\_by\_result\_table</a>: The name of a table used to store the results, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a> and meeting <a href="/content/concepts/tables/#table-naming-criteria">table naming criteria</a>. Column names (group-by and aggregate fields) need to be given aliases e.g. \["FChar256 as fchar256", "sum(FDouble) as sfd"]. If present, no results are returned in the response. This option is not available if one of the grouping attributes is an unrestricted string (i.e.; not charN) type. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#abcbd77d1cdc4e52ecc7b6469bedf5b09">aggregate\_group\_by\_result\_table\_persist</a>: If <a href="/content/api/cpp/namespacegpudb#a5ad437d851707f2d854e8a6351cc963a">true</a>, then the result table specified in <a href="/content/api/cpp/namespacegpudb#a74372aa877ab6529947b269da9d4ae00">result\_table</a> will be persisted and will not expire unless a <a href="/content/api/cpp/namespacegpudb#ac183c4d55c255403e1ee55e4260428f3">ttl</a> is specified. If <a href="/content/api/cpp/namespacegpudb#a405aa11a3bdf26b1dcacd96cbb6e403e">false</a>, then the result table will be an in-memory table and will expire unless a <a href="/content/api/cpp/namespacegpudb#ac183c4d55c255403e1ee55e4260428f3">ttl</a> is specified otherwise. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a5ad437d851707f2d854e8a6351cc963a">aggregate\_group\_by\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a405aa11a3bdf26b1dcacd96cbb6e403e">aggregate\_group\_by\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a405aa11a3bdf26b1dcacd96cbb6e403e">aggregate\_group\_by\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ad1ef320a0013f97a4309b95ff137e493">aggregate\_group\_by\_result\_table\_force\_replicated</a>: Force the result table to be replicated (ignores any sharding). Must be used in combination with the <a href="/content/api/cpp/namespacegpudb#a74372aa877ab6529947b269da9d4ae00">result\_table</a> option. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a5ad437d851707f2d854e8a6351cc963a">aggregate\_group\_by\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a405aa11a3bdf26b1dcacd96cbb6e403e">aggregate\_group\_by\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a405aa11a3bdf26b1dcacd96cbb6e403e">aggregate\_group\_by\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#af1498816dff4937520b8e577e239e27c">aggregate\_group\_by\_result\_table\_generate\_pk</a>: If <a href="/content/api/cpp/namespacegpudb#a5ad437d851707f2d854e8a6351cc963a">true</a> then set a primary key for the result table. Must be used in combination with the <a href="/content/api/cpp/namespacegpudb#a74372aa877ab6529947b269da9d4ae00">result\_table</a> option. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a5ad437d851707f2d854e8a6351cc963a">aggregate\_group\_by\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a405aa11a3bdf26b1dcacd96cbb6e403e">aggregate\_group\_by\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a405aa11a3bdf26b1dcacd96cbb6e403e">aggregate\_group\_by\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a1a83f1c180921c89f9f6fe4350a536fd">aggregate\_group\_by\_result\_table\_generate\_soft\_pk</a>: If <a href="/content/api/cpp/namespacegpudb#a5ad437d851707f2d854e8a6351cc963a">true</a> then set a soft primary key for the result table. Must be used in combination with the <a href="/content/api/cpp/namespacegpudb#a74372aa877ab6529947b269da9d4ae00">result\_table</a> option. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a5ad437d851707f2d854e8a6351cc963a">aggregate\_group\_by\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a405aa11a3bdf26b1dcacd96cbb6e403e">aggregate\_group\_by\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a405aa11a3bdf26b1dcacd96cbb6e403e">aggregate\_group\_by\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#ac183c4d55c255403e1ee55e4260428f3">aggregate\_group\_by\_ttl</a>: Sets the <a href="/content/concepts/ttl/">TTL</a> of the table specified in <a href="/content/api/cpp/namespacegpudb#a74372aa877ab6529947b269da9d4ae00">result\_table</a>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aef9f514701414d995d637921a4ade049">aggregate\_group\_by\_chunk\_size</a>: Indicates the number of records per chunk to be used for the result table. Must be used in combination with the <a href="/content/api/cpp/namespacegpudb#a74372aa877ab6529947b269da9d4ae00">result\_table</a> option. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ab1feac29a89a52bf764820cffea46386">aggregate\_group\_by\_chunk\_column\_max\_memory</a>: Indicates the target maximum data size for each column in a chunk to be used for the result table. Must be used in combination with the <a href="/content/api/cpp/namespacegpudb#a74372aa877ab6529947b269da9d4ae00">result\_table</a> option. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a0b3e0377408de3b05d255b3edc96a976">aggregate\_group\_by\_chunk\_max\_memory</a>: Indicates the target maximum data size for all columns in a chunk to be used for the result table. Must be used in combination with the <a href="/content/api/cpp/namespacegpudb#a74372aa877ab6529947b269da9d4ae00">result\_table</a> option. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a4434c96644b582233256b0522540328a">aggregate\_group\_by\_create\_indexes</a>: Comma-separated list of columns on which to create indexes on the result table. Must be used in combination with the <a href="/content/api/cpp/namespacegpudb#a74372aa877ab6529947b269da9d4ae00">result\_table</a> option. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a0d751187efd41272bee0792978077474">aggregate\_group\_by\_partition\_type</a>: <a href="/content/concepts/tables/#partitioning">Partitioning</a> scheme to use for the result table. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a26d5fcfc9ea825b8651ec9e317d1528a">aggregate\_group\_by\_RANGE</a>: Use <a href="/content/concepts/tables/#partitioning-by-range">range partitioning</a>. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aaee302741e22b596dc37c0c3a8ec06bb">aggregate\_group\_by\_INTERVAL</a>: Use <a href="/content/concepts/tables/#partitioning-by-interval">interval partitioning</a>. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ae6d45ba2892299ea06d9192ed7e1496d">aggregate\_group\_by\_LIST</a>: Use <a href="/content/concepts/tables/#partitioning-by-list">list partitioning</a>. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#afb419421315aed861fece8885a7feca7">aggregate\_group\_by\_HASH</a>: Use <a href="/content/concepts/tables/#partitioning-by-hash">hash partitioning</a>. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a661cf72cfc6a6377ca43d225353f7551">aggregate\_group\_by\_SERIES</a>: Use <a href="/content/concepts/tables/#partitioning-by-series">series partitioning</a>. </li>
                      </ul>
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a0d25c08cb801736db8117ff232ef56c7">aggregate\_group\_by\_partition\_keys</a>: Comma-separated list of partition keys, which are the columns or column expressions by which records will be assigned to partitions defined by <a href="/content/api/cpp/namespacegpudb#a63df0982814374c894dae665d26956b1">partition\_definitions</a>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a63df0982814374c894dae665d26956b1">aggregate\_group\_by\_partition\_definitions</a>: Comma-separated list of partition definitions, whose format depends on the choice of <a href="/content/api/cpp/namespacegpudb#a0d751187efd41272bee0792978077474">partition\_type</a>. See <a href="/content/concepts/tables/#partitioning-by-range">range partitioning</a>, <a href="/content/concepts/tables/#partitioning-by-interval">interval partitioning</a>, <a href="/content/concepts/tables/#partitioning-by-list">list partitioning</a>, <a href="/content/concepts/tables/#partitioning-by-hash">hash partitioning</a>, or <a href="/content/concepts/tables/#partitioning-by-series">series partitioning</a> for example formats. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a1720f952b51372d743a2b70f77f6363d">aggregate\_group\_by\_is\_automatic\_partition</a>: If <a href="/content/api/cpp/namespacegpudb#a5ad437d851707f2d854e8a6351cc963a">true</a>, a new partition will be created for values which don't fall into an existing partition. Currently only supported for <a href="/content/concepts/tables/#partitioning-by-list">list partitions</a>. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a5ad437d851707f2d854e8a6351cc963a">aggregate\_group\_by\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a405aa11a3bdf26b1dcacd96cbb6e403e">aggregate\_group\_by\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a405aa11a3bdf26b1dcacd96cbb6e403e">aggregate\_group\_by\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#ad0d9e690e51f3a9e8fa8349e630bfb2b">aggregate\_group\_by\_view\_id</a>: ID of view of which the result table will be a member. The default value is ''. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a13aa63edf5b20c7afd14622c3779902a">aggregate\_group\_by\_pivot</a>: Pivot column. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ad3557de9a0528c4d28c4f9d894d14cea">aggregate\_group\_by\_pivot\_values</a>: Comma-separated list of the values in the <a href="/content/api/cpp/namespacegpudb#a13aa63edf5b20c7afd14622c3779902a">pivot</a> column. The list provided will become the column header prefixes in the output. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a63a1dc780a0cce215e53547eb67e893e">aggregate\_group\_by\_grouping\_sets</a>: Customize the grouping attribute sets to compute the aggregates. These sets can include ROLLUP or CUBE operators. The attribute sets should be enclosed in parentheses and can include composite attributes. All attributes specified in the grouping sets must present in the group-by attributes. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a58b20054eea24b15d459d3ccb77ec5a2">aggregate\_group\_by\_rollup</a>: This option is used to specify the multilevel aggregates. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aab3a0075e85f3ac610e4ef828310b5c8">aggregate\_group\_by\_cube</a>: This option is used to specify the multidimensional aggregates. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a1bcc92e6da4ee16c160d648cd4356984">aggregate\_group\_by\_shard\_key</a>: Comma-separated list of the columns to be sharded on; e.g. 'column1, column2'. The columns specified must be present in <span>columnNames</span>. If any alias is given for any column name, the alias must be used, rather than the original column name. The default value is ''. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AggregateGroupByResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AggregateGroupByResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a229b78476fee686199caaa9de5a113b2">◆ </a></span>aggregateGroupByRaw() <span>\[1/2]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1RawAggregateGroupByResponse">RawAggregateGroupByResponse</a> gpudb::GPUdb::aggregateGroupByRaw </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1AggregateGroupByRequest">AggregateGroupByRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Calculates unique combinations (groups) of values for the given columns in a given table or view and computes aggregates on each unique combination. </p>
        <p>This is somewhat analogous to an SQL-style SELECT...GROUP BY.</p>
        <p>For aggregation details and examples, see <a href="/content/concepts/aggregation/">Aggregation</a>. For limitations, see <a href="/content/concepts/aggregation/#limitations">Aggregation Limitations</a>.</p>
        <p>Any column(s) can be grouped on, and all column types except unrestricted-length strings may be used for computing applicable aggregates.</p>
        <p>The results can be paged via the <a href="/content/api/cpp/structgpudb_1_1AggregateGroupByRequest#ad33d5ef5e1c47ab8c549ddad114ee63e">offset</a> and <a href="/content/api/cpp/structgpudb_1_1AggregateGroupByRequest#a5765d2623bfa7ac83104f43748a8bcb1">limit</a> parameters. For example, to get 10 groups with the largest counts the inputs would be: limit=10, options="sort\_order":"descending", "sort\_by":"value".</p>
        <p><a href="/content/api/cpp/structgpudb_1_1AggregateGroupByRequest#a7fb83ff0c7bd454e13268cdfb9c81db4">options</a> can be used to customize behavior of this call e.g. filtering or sorting the results.</p>
        <p>To group by columns 'x' and 'y' and compute the number of objects within each group, use: column\_names=\['x','y','count(\*)'].</p>
        <p>To also compute the sum of 'z' over each group, use: column\_names=\['x','y','count(\*)','sum(z)'].</p>
        <p>Available <a href="/content/concepts/expressions/#aggregate-expressions">aggregation functions</a> are: count(\*), sum, min, max, avg, mean, stddev, stddev\_pop, stddev\_samp, var, var\_pop, var\_samp, arg\_min, arg\_max and count\_distinct.</p>
        <p>Available grouping functions are <a href="/content/concepts/rollup/">Rollup</a>, <a href="/content/concepts/cube/">Cube</a>, and <a href="/content/concepts/grouping_sets/">Grouping Sets</a></p>
        <p>This service also provides support for <a href="/content/concepts/pivot/">Pivot</a> operations.</p>
        <p>Filtering on aggregates is supported via expressions using <a href="/content/concepts/expressions/#aggregate-expressions">aggregation functions</a> supplied to <a href="/content/api/cpp/namespacegpudb#ad1ab7a16358f987414622becec705d1f">having</a>.</p>
        <p>The response is returned as a dynamic schema. For details see: <a href="/content/api/concepts/#dynamic-schemas">dynamic schemas documentation</a>.</p>
        <p>If a <a href="/content/api/cpp/namespacegpudb#a74372aa877ab6529947b269da9d4ae00">result\_table</a> name is specified in the <a href="/content/api/cpp/structgpudb_1_1AggregateGroupByRequest#a7fb83ff0c7bd454e13268cdfb9c81db4">options</a>, the results are stored in a new table with that name–no results are returned in the response. Both the table name and resulting column names must adhere to <a href="/content/concepts/tables/#table">standard naming conventions</a>; column/aggregation expressions will need to be aliased. If the source table's <a href="/content/concepts/tables/#shard-keys">shard key</a> is used as the grouping column(s) and all result records are selected (<a href="/content/api/cpp/structgpudb_1_1AggregateGroupByRequest#ad33d5ef5e1c47ab8c549ddad114ee63e">offset</a> is 0 and <a href="/content/api/cpp/structgpudb_1_1AggregateGroupByRequest#a5765d2623bfa7ac83104f43748a8bcb1">limit</a> is -9999), the result table will be sharded, in all other cases it will be replicated. Sorting will properly function only if the result table is replicated or if there is only one processing node and should not be relied upon in other cases. Not available when any of the values of <a href="/content/api/cpp/structgpudb_1_1AggregateGroupByRequest#a8e3cb49fb147d79eec5ec008d999a2cd">columnNames</a> is an unrestricted-length string.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AggregateGroupByRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1RawAggregateGroupByResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a7660bce798a03aa6d1512429d1e72401">◆ </a></span>aggregateGroupByRaw() <span>\[2/2]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1RawAggregateGroupByResponse">RawAggregateGroupByResponse</a> & gpudb::GPUdb::aggregateGroupByRaw </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1AggregateGroupByRequest">AggregateGroupByRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1RawAggregateGroupByResponse">RawAggregateGroupByResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Calculates unique combinations (groups) of values for the given columns in a given table or view and computes aggregates on each unique combination. </p>
        <p>This is somewhat analogous to an SQL-style SELECT...GROUP BY.</p>
        <p>For aggregation details and examples, see <a href="/content/concepts/aggregation/">Aggregation</a>. For limitations, see <a href="/content/concepts/aggregation/#limitations">Aggregation Limitations</a>.</p>
        <p>Any column(s) can be grouped on, and all column types except unrestricted-length strings may be used for computing applicable aggregates.</p>
        <p>The results can be paged via the <a href="/content/api/cpp/structgpudb_1_1AggregateGroupByRequest#ad33d5ef5e1c47ab8c549ddad114ee63e">offset</a> and <a href="/content/api/cpp/structgpudb_1_1AggregateGroupByRequest#a5765d2623bfa7ac83104f43748a8bcb1">limit</a> parameters. For example, to get 10 groups with the largest counts the inputs would be: limit=10, options="sort\_order":"descending", "sort\_by":"value".</p>
        <p><a href="/content/api/cpp/structgpudb_1_1AggregateGroupByRequest#a7fb83ff0c7bd454e13268cdfb9c81db4">options</a> can be used to customize behavior of this call e.g. filtering or sorting the results.</p>
        <p>To group by columns 'x' and 'y' and compute the number of objects within each group, use: column\_names=\['x','y','count(\*)'].</p>
        <p>To also compute the sum of 'z' over each group, use: column\_names=\['x','y','count(\*)','sum(z)'].</p>
        <p>Available <a href="/content/concepts/expressions/#aggregate-expressions">aggregation functions</a> are: count(\*), sum, min, max, avg, mean, stddev, stddev\_pop, stddev\_samp, var, var\_pop, var\_samp, arg\_min, arg\_max and count\_distinct.</p>
        <p>Available grouping functions are <a href="/content/concepts/rollup/">Rollup</a>, <a href="/content/concepts/cube/">Cube</a>, and <a href="/content/concepts/grouping_sets/">Grouping Sets</a></p>
        <p>This service also provides support for <a href="/content/concepts/pivot/">Pivot</a> operations.</p>
        <p>Filtering on aggregates is supported via expressions using <a href="/content/concepts/expressions/#aggregate-expressions">aggregation functions</a> supplied to <a href="/content/api/cpp/namespacegpudb#ad1ab7a16358f987414622becec705d1f">having</a>.</p>
        <p>The response is returned as a dynamic schema. For details see: <a href="/content/api/concepts/#dynamic-schemas">dynamic schemas documentation</a>.</p>
        <p>If a <a href="/content/api/cpp/namespacegpudb#a74372aa877ab6529947b269da9d4ae00">result\_table</a> name is specified in the <a href="/content/api/cpp/structgpudb_1_1AggregateGroupByRequest#a7fb83ff0c7bd454e13268cdfb9c81db4">options</a>, the results are stored in a new table with that name–no results are returned in the response. Both the table name and resulting column names must adhere to <a href="/content/concepts/tables/#table">standard naming conventions</a>; column/aggregation expressions will need to be aliased. If the source table's <a href="/content/concepts/tables/#shard-keys">shard key</a> is used as the grouping column(s) and all result records are selected (<a href="/content/api/cpp/structgpudb_1_1AggregateGroupByRequest#ad33d5ef5e1c47ab8c549ddad114ee63e">offset</a> is 0 and <a href="/content/api/cpp/structgpudb_1_1AggregateGroupByRequest#a5765d2623bfa7ac83104f43748a8bcb1">limit</a> is -9999), the result table will be sharded, in all other cases it will be replicated. Sorting will properly function only if the result table is replicated or if there is only one processing node and should not be relied upon in other cases. Not available when any of the values of <a href="/content/api/cpp/structgpudb_1_1AggregateGroupByRequest#a8e3cb49fb147d79eec5ec008d999a2cd">columnNames</a> is an unrestricted-length string.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AggregateGroupByRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1RawAggregateGroupByResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1RawAggregateGroupByResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a44f85f0ed810158552eade4159d161ac">◆ </a></span>aggregateHistogram() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AggregateHistogramResponse">AggregateHistogramResponse</a> gpudb::GPUdb::aggregateHistogram </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1AggregateHistogramRequest">AggregateHistogramRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Performs a histogram calculation given a table, a column, and an interval function. </p>
        <p>The <a href="/content/api/cpp/structgpudb_1_1AggregateHistogramRequest#abdd548aff47a9cb171d656db838b004d">interval</a> is used to produce bins of that size and the result, computed over the records falling within each bin, is returned. For each bin, the start value is inclusive, but the end value is exclusive–except for the very last bin for which the end value is also inclusive. The value returned for each bin is the number of records in it, except when a column name is provided as a <a href="/content/api/cpp/namespacegpudb#a1a869e8637f82e48e93e1c57d7be8170">value\_column</a>. In this latter case the sum of the values corresponding to the <a href="/content/api/cpp/namespacegpudb#a1a869e8637f82e48e93e1c57d7be8170">value\_column</a> is used as the result instead. The total number of bins requested cannot exceed 10,000.</p>
        <p>NOTE: The Kinetica instance being accessed must be running a CUDA (GPU-based) build to service a request that specifies a <a href="/content/api/cpp/namespacegpudb#a1a869e8637f82e48e93e1c57d7be8170">value\_column</a>.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AggregateHistogramRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AggregateHistogramResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a55de0ae15f0c2d85a0a5b785db143275">◆ </a></span>aggregateHistogram() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AggregateHistogramResponse">AggregateHistogramResponse</a> & gpudb::GPUdb::aggregateHistogram </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1AggregateHistogramRequest">AggregateHistogramRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1AggregateHistogramResponse">AggregateHistogramResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Performs a histogram calculation given a table, a column, and an interval function. </p>
        <p>The <a href="/content/api/cpp/structgpudb_1_1AggregateHistogramRequest#abdd548aff47a9cb171d656db838b004d">interval</a> is used to produce bins of that size and the result, computed over the records falling within each bin, is returned. For each bin, the start value is inclusive, but the end value is exclusive–except for the very last bin for which the end value is also inclusive. The value returned for each bin is the number of records in it, except when a column name is provided as a <a href="/content/api/cpp/namespacegpudb#a1a869e8637f82e48e93e1c57d7be8170">value\_column</a>. In this latter case the sum of the values corresponding to the <a href="/content/api/cpp/namespacegpudb#a1a869e8637f82e48e93e1c57d7be8170">value\_column</a> is used as the result instead. The total number of bins requested cannot exceed 10,000.</p>
        <p>NOTE: The Kinetica instance being accessed must be running a CUDA (GPU-based) build to service a request that specifies a <a href="/content/api/cpp/namespacegpudb#a1a869e8637f82e48e93e1c57d7be8170">value\_column</a>.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AggregateHistogramRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AggregateHistogramResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AggregateHistogramResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a81f941c05e1304c4709f95346eaae747">◆ </a></span>aggregateHistogram() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AggregateHistogramResponse">AggregateHistogramResponse</a> gpudb::GPUdb::aggregateHistogram </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>columnName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const double</td>
            <td><span><span>start</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const double</td>
            <td><span><span>end</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const double</td>
            <td><span><span>interval</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Performs a histogram calculation given a table, a column, and an interval function. </p>
        <p>The <span>interval</span> is used to produce bins of that size and the result, computed over the records falling within each bin, is returned. For each bin, the start value is inclusive, but the end value is exclusive–except for the very last bin for which the end value is also inclusive. The value returned for each bin is the number of records in it, except when a column name is provided as a <a href="/content/api/cpp/namespacegpudb#a1a869e8637f82e48e93e1c57d7be8170">value\_column</a>. In this latter case the sum of the values corresponding to the <a href="/content/api/cpp/namespacegpudb#a1a869e8637f82e48e93e1c57d7be8170">value\_column</a> is used as the result instead. The total number of bins requested cannot exceed 10,000.</p>
        <p>NOTE: The Kinetica instance being accessed must be running a CUDA (GPU-based) build to service a request that specifies a <a href="/content/api/cpp/namespacegpudb#a1a869e8637f82e48e93e1c57d7be8170">value\_column</a>.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of the table on which the operation will be performed. Must be an existing table, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>columnName</td>
                <td>Name of a column or an expression of one or more column names over which the histogram will be calculated. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>start</td>
                <td>Lower end value of the histogram interval, inclusive. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>end</td>
                <td>Upper end value of the histogram interval, inclusive. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>interval</td>
                <td>The size of each bin within the start and end parameters. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a1a869e8637f82e48e93e1c57d7be8170">aggregate\_histogram\_value\_column</a>: The name of the column to use when calculating the bin values (values are summed). The column must be a numerical type (int, double, long, float). </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ab782971147a6d658b91d87eb8c5d9cec">aggregate\_histogram\_start</a>: The start parameter for char types. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#abc6eb3aa953301a4cc0772837694139a">aggregate\_histogram\_end</a>: The end parameter for char types. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ad71784c6b9ebc622c7e45f341fdb9e72">aggregate\_histogram\_interval</a>: The interval parameter for char types. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AggregateHistogramResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#af0eea9fee904ec49d2ba8ee73df3b90c">◆ </a></span>aggregateHistogram() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AggregateHistogramResponse">AggregateHistogramResponse</a> & gpudb::GPUdb::aggregateHistogram </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>columnName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const double</td>
            <td><span><span>start</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const double</td>
            <td><span><span>end</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const double</td>
            <td><span><span>interval</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1AggregateHistogramResponse">AggregateHistogramResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Performs a histogram calculation given a table, a column, and an interval function. </p>
        <p>The <span>interval</span> is used to produce bins of that size and the result, computed over the records falling within each bin, is returned. For each bin, the start value is inclusive, but the end value is exclusive–except for the very last bin for which the end value is also inclusive. The value returned for each bin is the number of records in it, except when a column name is provided as a <a href="/content/api/cpp/namespacegpudb#a1a869e8637f82e48e93e1c57d7be8170">value\_column</a>. In this latter case the sum of the values corresponding to the <a href="/content/api/cpp/namespacegpudb#a1a869e8637f82e48e93e1c57d7be8170">value\_column</a> is used as the result instead. The total number of bins requested cannot exceed 10,000.</p>
        <p>NOTE: The Kinetica instance being accessed must be running a CUDA (GPU-based) build to service a request that specifies a <a href="/content/api/cpp/namespacegpudb#a1a869e8637f82e48e93e1c57d7be8170">value\_column</a>.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of the table on which the operation will be performed. Must be an existing table, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>columnName</td>
                <td>Name of a column or an expression of one or more column names over which the histogram will be calculated. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>start</td>
                <td>Lower end value of the histogram interval, inclusive. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>end</td>
                <td>Upper end value of the histogram interval, inclusive. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>interval</td>
                <td>The size of each bin within the start and end parameters. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a1a869e8637f82e48e93e1c57d7be8170">aggregate\_histogram\_value\_column</a>: The name of the column to use when calculating the bin values (values are summed). The column must be a numerical type (int, double, long, float). </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ab782971147a6d658b91d87eb8c5d9cec">aggregate\_histogram\_start</a>: The start parameter for char types. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#abc6eb3aa953301a4cc0772837694139a">aggregate\_histogram\_end</a>: The end parameter for char types. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ad71784c6b9ebc622c7e45f341fdb9e72">aggregate\_histogram\_interval</a>: The interval parameter for char types. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AggregateHistogramResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AggregateHistogramResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ad5a2053d2dbd8781f49d4ce47c902c3e">◆ </a></span>aggregateKMeans() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AggregateKMeansResponse">AggregateKMeansResponse</a> gpudb::GPUdb::aggregateKMeans </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1AggregateKMeansRequest">AggregateKMeansRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>This endpoint runs the k-means algorithm - a heuristic algorithm that attempts to do k-means clustering. </p>
        <p>An ideal k-means clustering algorithm selects k points such that the sum of the mean squared distances of each member of the set to the nearest of the k points is minimized. The k-means algorithm however does not necessarily produce such an ideal cluster. It begins with a randomly selected set of k points and then refines the location of the points iteratively and settles to a local minimum. Various parameters and options are provided to control the heuristic search.</p>
        <p>NOTE: The Kinetica instance being accessed must be running a CUDA (GPU-based) build to service this request.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AggregateKMeansRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AggregateKMeansResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ac94cd2cd6cbc6a3d01100b6565c76788">◆ </a></span>aggregateKMeans() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AggregateKMeansResponse">AggregateKMeansResponse</a> & gpudb::GPUdb::aggregateKMeans </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1AggregateKMeansRequest">AggregateKMeansRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1AggregateKMeansResponse">AggregateKMeansResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>This endpoint runs the k-means algorithm - a heuristic algorithm that attempts to do k-means clustering. </p>
        <p>An ideal k-means clustering algorithm selects k points such that the sum of the mean squared distances of each member of the set to the nearest of the k points is minimized. The k-means algorithm however does not necessarily produce such an ideal cluster. It begins with a randomly selected set of k points and then refines the location of the points iteratively and settles to a local minimum. Various parameters and options are provided to control the heuristic search.</p>
        <p>NOTE: The Kinetica instance being accessed must be running a CUDA (GPU-based) build to service this request.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AggregateKMeansRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AggregateKMeansResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AggregateKMeansResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ac88006219510944c94cba1df8c2e71cd">◆ </a></span>aggregateKMeans() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AggregateKMeansResponse">AggregateKMeansResponse</a> gpudb::GPUdb::aggregateKMeans </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< std::string > &</td>
            <td><span><span>columnNames</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const int32\_t</td>
            <td><span><span>k</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const double</td>
            <td><span><span>tolerance</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>This endpoint runs the k-means algorithm - a heuristic algorithm that attempts to do k-means clustering. </p>
        <p>An ideal k-means clustering algorithm selects k points such that the sum of the mean squared distances of each member of the set to the nearest of the k points is minimized. The k-means algorithm however does not necessarily produce such an ideal cluster. It begins with a randomly selected set of k points and then refines the location of the points iteratively and settles to a local minimum. Various parameters and options are provided to control the heuristic search.</p>
        <p>NOTE: The Kinetica instance being accessed must be running a CUDA (GPU-based) build to service this request.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of the table on which the operation will be performed. Must be an existing table, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>columnNames</td>
                <td>List of column names on which the operation would be performed. If n columns are provided then each of the k result points will have n dimensions corresponding to the n columns. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>k</td>
                <td>The number of mean points to be determined by the algorithm. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>tolerance</td>
                <td>Stop iterating when the distances between successive points is less than the given tolerance. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#accffe0d5bdce257dcd6fc2dcbfc4e114">aggregate\_k\_means\_whiten</a>: When set to 1 each of the columns is first normalized by its stdv - default is not to whiten. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a935f1e072f932bc8077e0c420d7eaf0d">aggregate\_k\_means\_max\_iters</a>: Number of times to try to hit the tolerance limit before giving up - default is 10. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#acaccbb0f7d7f66237de23f0a52b353c9">aggregate\_k\_means\_num\_tries</a>: Number of times to run the k-means algorithm with a different randomly selected starting points - helps avoid local minimum. Default is 1. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ac2dbbed6d5915b77fd2d96d822a45c56">aggregate\_k\_means\_create\_temp\_table</a>: If <a href="/content/api/cpp/namespacegpudb#a806315c06574b201e75ec323030fca04">true</a>, a unique temporary table name will be generated in the sys\_temp schema and used in place of <a href="/content/api/cpp/namespacegpudb#aaac1a56923c27501a783d47cf036f1e2">result\_table</a>. If <a href="/content/api/cpp/namespacegpudb#a7c89b6148e0de3beb043c8a4fc2dff15">result\_table\_persist</a> is <a href="/content/api/cpp/namespacegpudb#ac434edd0cd229d6b29ad08da700a6cee">false</a> (or unspecified), then this is always allowed even if the caller does not have permission to create tables. The generated name is returned in <a href="/content/api/cpp/namespacegpudb#a3751e914a2b49c5dae04100e3298b086">qualified\_result\_table\_name</a>. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a806315c06574b201e75ec323030fca04">aggregate\_k\_means\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ac434edd0cd229d6b29ad08da700a6cee">aggregate\_k\_means\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ac434edd0cd229d6b29ad08da700a6cee">aggregate\_k\_means\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#aaac1a56923c27501a783d47cf036f1e2">aggregate\_k\_means\_result\_table</a>: The name of a table used to store the results, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a> and meeting <a href="/content/concepts/tables/#table-naming-criteria">table naming criteria</a>. If this option is specified, the results are not returned in the response. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a7c89b6148e0de3beb043c8a4fc2dff15">aggregate\_k\_means\_result\_table\_persist</a>: If <a href="/content/api/cpp/namespacegpudb#a806315c06574b201e75ec323030fca04">true</a>, then the result table specified in <a href="/content/api/cpp/namespacegpudb#aaac1a56923c27501a783d47cf036f1e2">result\_table</a> will be persisted and will not expire unless a <a href="/content/api/cpp/namespacegpudb#aa0654f4d5266cdd1a97095482e410298">ttl</a> is specified. If <a href="/content/api/cpp/namespacegpudb#ac434edd0cd229d6b29ad08da700a6cee">false</a>, then the result table will be an in-memory table and will expire unless a <a href="/content/api/cpp/namespacegpudb#aa0654f4d5266cdd1a97095482e410298">ttl</a> is specified otherwise. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a806315c06574b201e75ec323030fca04">aggregate\_k\_means\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ac434edd0cd229d6b29ad08da700a6cee">aggregate\_k\_means\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ac434edd0cd229d6b29ad08da700a6cee">aggregate\_k\_means\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#aa0654f4d5266cdd1a97095482e410298">aggregate\_k\_means\_ttl</a>: Sets the <a href="/content/concepts/ttl/">TTL</a> of the table specified in <a href="/content/api/cpp/namespacegpudb#aaac1a56923c27501a783d47cf036f1e2">result\_table</a>. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AggregateKMeansResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a325a1fab76dc072b4bcbbe0890793bc1">◆ </a></span>aggregateKMeans() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AggregateKMeansResponse">AggregateKMeansResponse</a> & gpudb::GPUdb::aggregateKMeans </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< std::string > &</td>
            <td><span><span>columnNames</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const int32\_t</td>
            <td><span><span>k</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const double</td>
            <td><span><span>tolerance</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1AggregateKMeansResponse">AggregateKMeansResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>This endpoint runs the k-means algorithm - a heuristic algorithm that attempts to do k-means clustering. </p>
        <p>An ideal k-means clustering algorithm selects k points such that the sum of the mean squared distances of each member of the set to the nearest of the k points is minimized. The k-means algorithm however does not necessarily produce such an ideal cluster. It begins with a randomly selected set of k points and then refines the location of the points iteratively and settles to a local minimum. Various parameters and options are provided to control the heuristic search.</p>
        <p>NOTE: The Kinetica instance being accessed must be running a CUDA (GPU-based) build to service this request.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of the table on which the operation will be performed. Must be an existing table, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>columnNames</td>
                <td>List of column names on which the operation would be performed. If n columns are provided then each of the k result points will have n dimensions corresponding to the n columns. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>k</td>
                <td>The number of mean points to be determined by the algorithm. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>tolerance</td>
                <td>Stop iterating when the distances between successive points is less than the given tolerance. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#accffe0d5bdce257dcd6fc2dcbfc4e114">aggregate\_k\_means\_whiten</a>: When set to 1 each of the columns is first normalized by its stdv - default is not to whiten. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a935f1e072f932bc8077e0c420d7eaf0d">aggregate\_k\_means\_max\_iters</a>: Number of times to try to hit the tolerance limit before giving up - default is 10. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#acaccbb0f7d7f66237de23f0a52b353c9">aggregate\_k\_means\_num\_tries</a>: Number of times to run the k-means algorithm with a different randomly selected starting points - helps avoid local minimum. Default is 1. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ac2dbbed6d5915b77fd2d96d822a45c56">aggregate\_k\_means\_create\_temp\_table</a>: If <a href="/content/api/cpp/namespacegpudb#a806315c06574b201e75ec323030fca04">true</a>, a unique temporary table name will be generated in the sys\_temp schema and used in place of <a href="/content/api/cpp/namespacegpudb#aaac1a56923c27501a783d47cf036f1e2">result\_table</a>. If <a href="/content/api/cpp/namespacegpudb#a7c89b6148e0de3beb043c8a4fc2dff15">result\_table\_persist</a> is <a href="/content/api/cpp/namespacegpudb#ac434edd0cd229d6b29ad08da700a6cee">false</a> (or unspecified), then this is always allowed even if the caller does not have permission to create tables. The generated name is returned in <a href="/content/api/cpp/namespacegpudb#a3751e914a2b49c5dae04100e3298b086">qualified\_result\_table\_name</a>. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a806315c06574b201e75ec323030fca04">aggregate\_k\_means\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ac434edd0cd229d6b29ad08da700a6cee">aggregate\_k\_means\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ac434edd0cd229d6b29ad08da700a6cee">aggregate\_k\_means\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#aaac1a56923c27501a783d47cf036f1e2">aggregate\_k\_means\_result\_table</a>: The name of a table used to store the results, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a> and meeting <a href="/content/concepts/tables/#table-naming-criteria">table naming criteria</a>. If this option is specified, the results are not returned in the response. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a7c89b6148e0de3beb043c8a4fc2dff15">aggregate\_k\_means\_result\_table\_persist</a>: If <a href="/content/api/cpp/namespacegpudb#a806315c06574b201e75ec323030fca04">true</a>, then the result table specified in <a href="/content/api/cpp/namespacegpudb#aaac1a56923c27501a783d47cf036f1e2">result\_table</a> will be persisted and will not expire unless a <a href="/content/api/cpp/namespacegpudb#aa0654f4d5266cdd1a97095482e410298">ttl</a> is specified. If <a href="/content/api/cpp/namespacegpudb#ac434edd0cd229d6b29ad08da700a6cee">false</a>, then the result table will be an in-memory table and will expire unless a <a href="/content/api/cpp/namespacegpudb#aa0654f4d5266cdd1a97095482e410298">ttl</a> is specified otherwise. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a806315c06574b201e75ec323030fca04">aggregate\_k\_means\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ac434edd0cd229d6b29ad08da700a6cee">aggregate\_k\_means\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ac434edd0cd229d6b29ad08da700a6cee">aggregate\_k\_means\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#aa0654f4d5266cdd1a97095482e410298">aggregate\_k\_means\_ttl</a>: Sets the <a href="/content/concepts/ttl/">TTL</a> of the table specified in <a href="/content/api/cpp/namespacegpudb#aaac1a56923c27501a783d47cf036f1e2">result\_table</a>. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AggregateKMeansResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AggregateKMeansResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a0f4f8435266adafdab5c5c5c81a88ce3">◆ </a></span>aggregateMinMax() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AggregateMinMaxResponse">AggregateMinMaxResponse</a> gpudb::GPUdb::aggregateMinMax </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1AggregateMinMaxRequest">AggregateMinMaxRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Calculates and returns the minimum and maximum values of a particular column in a table. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AggregateMinMaxRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AggregateMinMaxResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ac77ceff80e8d09cf71435e7d1f735348">◆ </a></span>aggregateMinMax() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AggregateMinMaxResponse">AggregateMinMaxResponse</a> & gpudb::GPUdb::aggregateMinMax </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1AggregateMinMaxRequest">AggregateMinMaxRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1AggregateMinMaxResponse">AggregateMinMaxResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Calculates and returns the minimum and maximum values of a particular column in a table. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AggregateMinMaxRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AggregateMinMaxResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AggregateMinMaxResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a08b988eb93cfa99ca7aeaa3a093acac2">◆ </a></span>aggregateMinMax() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AggregateMinMaxResponse">AggregateMinMaxResponse</a> gpudb::GPUdb::aggregateMinMax </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>columnName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Calculates and returns the minimum and maximum values of a particular column in a table. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of the table on which the operation will be performed. Must be an existing table, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>columnName</td>
                <td>Name of a column or an expression of one or more column on which the min-max will be calculated. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AggregateMinMaxResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a814eeb562646d7dbbeddbf4a54d4164e">◆ </a></span>aggregateMinMax() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AggregateMinMaxResponse">AggregateMinMaxResponse</a> & gpudb::GPUdb::aggregateMinMax </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>columnName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1AggregateMinMaxResponse">AggregateMinMaxResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Calculates and returns the minimum and maximum values of a particular column in a table. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of the table on which the operation will be performed. Must be an existing table, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>columnName</td>
                <td>Name of a column or an expression of one or more column on which the min-max will be calculated. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AggregateMinMaxResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AggregateMinMaxResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a2ea45e8117eaaf785e5791d86f7bf31a">◆ </a></span>aggregateMinMaxGeometry() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AggregateMinMaxGeometryResponse">AggregateMinMaxGeometryResponse</a> gpudb::GPUdb::aggregateMinMaxGeometry </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1AggregateMinMaxGeometryRequest">AggregateMinMaxGeometryRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Calculates and returns the minimum and maximum x- and y-coordinates of a particular geospatial geometry column in a table. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AggregateMinMaxGeometryRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AggregateMinMaxGeometryResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a3148eca67319655a1f8bc84d30604405">◆ </a></span>aggregateMinMaxGeometry() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AggregateMinMaxGeometryResponse">AggregateMinMaxGeometryResponse</a> & gpudb::GPUdb::aggregateMinMaxGeometry </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1AggregateMinMaxGeometryRequest">AggregateMinMaxGeometryRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1AggregateMinMaxGeometryResponse">AggregateMinMaxGeometryResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Calculates and returns the minimum and maximum x- and y-coordinates of a particular geospatial geometry column in a table. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AggregateMinMaxGeometryRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AggregateMinMaxGeometryResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AggregateMinMaxGeometryResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a2922273b4ee8519ce678124d7e640309">◆ </a></span>aggregateMinMaxGeometry() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AggregateMinMaxGeometryResponse">AggregateMinMaxGeometryResponse</a> gpudb::GPUdb::aggregateMinMaxGeometry </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>columnName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Calculates and returns the minimum and maximum x- and y-coordinates of a particular geospatial geometry column in a table. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of the table on which the operation will be performed. Must be an existing table, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>columnName</td>
                <td>Name of a geospatial geometry column on which the min-max will be calculated. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AggregateMinMaxGeometryResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#acd7747a52281b1bba0d77d71bfc4b100">◆ </a></span>aggregateMinMaxGeometry() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AggregateMinMaxGeometryResponse">AggregateMinMaxGeometryResponse</a> & gpudb::GPUdb::aggregateMinMaxGeometry </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>columnName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1AggregateMinMaxGeometryResponse">AggregateMinMaxGeometryResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Calculates and returns the minimum and maximum x- and y-coordinates of a particular geospatial geometry column in a table. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of the table on which the operation will be performed. Must be an existing table, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>columnName</td>
                <td>Name of a geospatial geometry column on which the min-max will be calculated. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AggregateMinMaxGeometryResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AggregateMinMaxGeometryResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ae8be38925c2de5770cde61ce058641c6">◆ </a></span>aggregateStatistics() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AggregateStatisticsResponse">AggregateStatisticsResponse</a> gpudb::GPUdb::aggregateStatistics </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1AggregateStatisticsRequest">AggregateStatisticsRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Calculates the requested statistics of the given column(s) in a given table. </p>
        <p>The available statistics are: <a href="/content/api/cpp/namespacegpudb#a910faa6f48dd193f18aba29b5c960344">count</a> (number of total objects), <a href="/content/api/cpp/namespacegpudb#a321e05dbc66fb2bd763a96e37c2ef28c">mean</a>, <a href="/content/api/cpp/namespacegpudb#a80eb30610a806779605b67de7a650a88">stdv</a> (standard deviation), <a href="/content/api/cpp/namespacegpudb#add21322ff5f88391b8453a054b4b37a2">variance</a>, <a href="/content/api/cpp/namespacegpudb#a27661ef055a1ceaf3712e11ecf627488">skew</a>, <a href="/content/api/cpp/namespacegpudb#af4bc4d865eef8b909cd55780ae4af232">kurtosis</a>, <a href="/content/api/cpp/namespacegpudb#aa117dbda93c32c62770145de97c4c9c2">sum</a>, <a href="/content/api/cpp/namespacegpudb#a90baeec3c38fc6bd4953070dc6c9d0ea">min</a>, <a href="/content/api/cpp/namespacegpudb#a912e6ca011bcd0ea98799d9db7152459">max</a>, <a href="/content/api/cpp/namespacegpudb#a673d92e6228a5a96680db7b385aeceb4">weighted\_average</a>, <a href="/content/api/cpp/namespacegpudb#aa88f43507d7f396847a0a10a054c8b31">cardinality</a> (unique count), <a href="/content/api/cpp/namespacegpudb#aecd79bad34930f168402bea13f361615">estimated\_cardinality</a>, <a href="/content/api/cpp/namespacegpudb#a6b2e607ab0d4568753af82c6cb796057">percentile</a>, and <a href="/content/api/cpp/namespacegpudb#a543743eb2266f91be3240a5ce00dbfbf">percentile\_rank</a>.</p>
        <p>Estimated cardinality is calculated by using the hyperloglog approximation technique.</p>
        <p>Percentiles and percentile ranks are approximate and are calculated using the t-digest algorithm. They must include the desired <a href="/content/api/cpp/namespacegpudb#a6b2e607ab0d4568753af82c6cb796057">percentile</a>/<a href="/content/api/cpp/namespacegpudb#a543743eb2266f91be3240a5ce00dbfbf">percentile\_rank</a>. To compute multiple percentiles each value must be specified separately (i.e.\ 'percentile(75.0),percentile(99.0),percentile\_rank(1234.56),percentile\_rank(-5)').</p>
        <p>A second, comma-separated value can be added to the <a href="/content/api/cpp/namespacegpudb#a6b2e607ab0d4568753af82c6cb796057">percentile</a> statistic to calculate percentile resolution, e.g., a 50th percentile with 200 resolution would be 'percentile(50,200)'.</p>
        <p>The weighted average statistic requires a weight column to be specified in <a href="/content/api/cpp/namespacegpudb#a1ab2e07eb9717291d5a706cdb09639ae">weight\_column\_name</a>. The weighted average is then defined as the sum of the products of <a href="/content/api/cpp/structgpudb_1_1AggregateStatisticsRequest#a89707d310f05b515e33352c74ed15c1e">columnName</a> times the <a href="/content/api/cpp/namespacegpudb#a1ab2e07eb9717291d5a706cdb09639ae">weight\_column\_name</a> values divided by the sum of the <a href="/content/api/cpp/namespacegpudb#a1ab2e07eb9717291d5a706cdb09639ae">weight\_column\_name</a> values.</p>
        <p>Additional columns can be used in the calculation of statistics via <a href="/content/api/cpp/namespacegpudb#ac247aec8a5036be28db98f2a2b7f01f2">additional\_column\_names</a>. Values in these columns will be included in the overall aggregate calculation–individual aggregates will not be calculated per additional column. For instance, requesting the <a href="/content/api/cpp/namespacegpudb#a910faa6f48dd193f18aba29b5c960344">count</a> and <a href="/content/api/cpp/namespacegpudb#a321e05dbc66fb2bd763a96e37c2ef28c">mean</a> of <a href="/content/api/cpp/structgpudb_1_1AggregateStatisticsRequest#a89707d310f05b515e33352c74ed15c1e">columnName</a> x and <a href="/content/api/cpp/namespacegpudb#ac247aec8a5036be28db98f2a2b7f01f2">additional\_column\_names</a> y and z, where x holds the numbers 1-10, y holds 11-20, and z holds 21-30, would return the total number of x, y, and z values (30), and the single average value across all x, y, and z values (15.5).</p>
        <p>The response includes a list of key/value pairs of each statistic requested and its corresponding value.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AggregateStatisticsRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AggregateStatisticsResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a2ec160656cda21fb8968cd0dd74cfc68">◆ </a></span>aggregateStatistics() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AggregateStatisticsResponse">AggregateStatisticsResponse</a> & gpudb::GPUdb::aggregateStatistics </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1AggregateStatisticsRequest">AggregateStatisticsRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1AggregateStatisticsResponse">AggregateStatisticsResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Calculates the requested statistics of the given column(s) in a given table. </p>
        <p>The available statistics are: <a href="/content/api/cpp/namespacegpudb#a910faa6f48dd193f18aba29b5c960344">count</a> (number of total objects), <a href="/content/api/cpp/namespacegpudb#a321e05dbc66fb2bd763a96e37c2ef28c">mean</a>, <a href="/content/api/cpp/namespacegpudb#a80eb30610a806779605b67de7a650a88">stdv</a> (standard deviation), <a href="/content/api/cpp/namespacegpudb#add21322ff5f88391b8453a054b4b37a2">variance</a>, <a href="/content/api/cpp/namespacegpudb#a27661ef055a1ceaf3712e11ecf627488">skew</a>, <a href="/content/api/cpp/namespacegpudb#af4bc4d865eef8b909cd55780ae4af232">kurtosis</a>, <a href="/content/api/cpp/namespacegpudb#aa117dbda93c32c62770145de97c4c9c2">sum</a>, <a href="/content/api/cpp/namespacegpudb#a90baeec3c38fc6bd4953070dc6c9d0ea">min</a>, <a href="/content/api/cpp/namespacegpudb#a912e6ca011bcd0ea98799d9db7152459">max</a>, <a href="/content/api/cpp/namespacegpudb#a673d92e6228a5a96680db7b385aeceb4">weighted\_average</a>, <a href="/content/api/cpp/namespacegpudb#aa88f43507d7f396847a0a10a054c8b31">cardinality</a> (unique count), <a href="/content/api/cpp/namespacegpudb#aecd79bad34930f168402bea13f361615">estimated\_cardinality</a>, <a href="/content/api/cpp/namespacegpudb#a6b2e607ab0d4568753af82c6cb796057">percentile</a>, and <a href="/content/api/cpp/namespacegpudb#a543743eb2266f91be3240a5ce00dbfbf">percentile\_rank</a>.</p>
        <p>Estimated cardinality is calculated by using the hyperloglog approximation technique.</p>
        <p>Percentiles and percentile ranks are approximate and are calculated using the t-digest algorithm. They must include the desired <a href="/content/api/cpp/namespacegpudb#a6b2e607ab0d4568753af82c6cb796057">percentile</a>/<a href="/content/api/cpp/namespacegpudb#a543743eb2266f91be3240a5ce00dbfbf">percentile\_rank</a>. To compute multiple percentiles each value must be specified separately (i.e.\ 'percentile(75.0),percentile(99.0),percentile\_rank(1234.56),percentile\_rank(-5)').</p>
        <p>A second, comma-separated value can be added to the <a href="/content/api/cpp/namespacegpudb#a6b2e607ab0d4568753af82c6cb796057">percentile</a> statistic to calculate percentile resolution, e.g., a 50th percentile with 200 resolution would be 'percentile(50,200)'.</p>
        <p>The weighted average statistic requires a weight column to be specified in <a href="/content/api/cpp/namespacegpudb#a1ab2e07eb9717291d5a706cdb09639ae">weight\_column\_name</a>. The weighted average is then defined as the sum of the products of <a href="/content/api/cpp/structgpudb_1_1AggregateStatisticsRequest#a89707d310f05b515e33352c74ed15c1e">columnName</a> times the <a href="/content/api/cpp/namespacegpudb#a1ab2e07eb9717291d5a706cdb09639ae">weight\_column\_name</a> values divided by the sum of the <a href="/content/api/cpp/namespacegpudb#a1ab2e07eb9717291d5a706cdb09639ae">weight\_column\_name</a> values.</p>
        <p>Additional columns can be used in the calculation of statistics via <a href="/content/api/cpp/namespacegpudb#ac247aec8a5036be28db98f2a2b7f01f2">additional\_column\_names</a>. Values in these columns will be included in the overall aggregate calculation–individual aggregates will not be calculated per additional column. For instance, requesting the <a href="/content/api/cpp/namespacegpudb#a910faa6f48dd193f18aba29b5c960344">count</a> and <a href="/content/api/cpp/namespacegpudb#a321e05dbc66fb2bd763a96e37c2ef28c">mean</a> of <a href="/content/api/cpp/structgpudb_1_1AggregateStatisticsRequest#a89707d310f05b515e33352c74ed15c1e">columnName</a> x and <a href="/content/api/cpp/namespacegpudb#ac247aec8a5036be28db98f2a2b7f01f2">additional\_column\_names</a> y and z, where x holds the numbers 1-10, y holds 11-20, and z holds 21-30, would return the total number of x, y, and z values (30), and the single average value across all x, y, and z values (15.5).</p>
        <p>The response includes a list of key/value pairs of each statistic requested and its corresponding value.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AggregateStatisticsRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AggregateStatisticsResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AggregateStatisticsResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a14e2268cde99791da1ffb54f1f8326cb">◆ </a></span>aggregateStatistics() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AggregateStatisticsResponse">AggregateStatisticsResponse</a> gpudb::GPUdb::aggregateStatistics </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>columnName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>stats</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Calculates the requested statistics of the given column(s) in a given table. </p>
        <p>The available statistics are: <a href="/content/api/cpp/namespacegpudb#a910faa6f48dd193f18aba29b5c960344">count</a> (number of total objects), <a href="/content/api/cpp/namespacegpudb#a321e05dbc66fb2bd763a96e37c2ef28c">mean</a>, <a href="/content/api/cpp/namespacegpudb#a80eb30610a806779605b67de7a650a88">stdv</a> (standard deviation), <a href="/content/api/cpp/namespacegpudb#add21322ff5f88391b8453a054b4b37a2">variance</a>, <a href="/content/api/cpp/namespacegpudb#a27661ef055a1ceaf3712e11ecf627488">skew</a>, <a href="/content/api/cpp/namespacegpudb#af4bc4d865eef8b909cd55780ae4af232">kurtosis</a>, <a href="/content/api/cpp/namespacegpudb#aa117dbda93c32c62770145de97c4c9c2">sum</a>, <a href="/content/api/cpp/namespacegpudb#a90baeec3c38fc6bd4953070dc6c9d0ea">min</a>, <a href="/content/api/cpp/namespacegpudb#a912e6ca011bcd0ea98799d9db7152459">max</a>, <a href="/content/api/cpp/namespacegpudb#a673d92e6228a5a96680db7b385aeceb4">weighted\_average</a>, <a href="/content/api/cpp/namespacegpudb#aa88f43507d7f396847a0a10a054c8b31">cardinality</a> (unique count), <a href="/content/api/cpp/namespacegpudb#aecd79bad34930f168402bea13f361615">estimated\_cardinality</a>, <a href="/content/api/cpp/namespacegpudb#a6b2e607ab0d4568753af82c6cb796057">percentile</a>, and <a href="/content/api/cpp/namespacegpudb#a543743eb2266f91be3240a5ce00dbfbf">percentile\_rank</a>.</p>
        <p>Estimated cardinality is calculated by using the hyperloglog approximation technique.</p>
        <p>Percentiles and percentile ranks are approximate and are calculated using the t-digest algorithm. They must include the desired <a href="/content/api/cpp/namespacegpudb#a6b2e607ab0d4568753af82c6cb796057">percentile</a>/<a href="/content/api/cpp/namespacegpudb#a543743eb2266f91be3240a5ce00dbfbf">percentile\_rank</a>. To compute multiple percentiles each value must be specified separately (i.e.\ 'percentile(75.0),percentile(99.0),percentile\_rank(1234.56),percentile\_rank(-5)').</p>
        <p>A second, comma-separated value can be added to the <a href="/content/api/cpp/namespacegpudb#a6b2e607ab0d4568753af82c6cb796057">percentile</a> statistic to calculate percentile resolution, e.g., a 50th percentile with 200 resolution would be 'percentile(50,200)'.</p>
        <p>The weighted average statistic requires a weight column to be specified in <a href="/content/api/cpp/namespacegpudb#a1ab2e07eb9717291d5a706cdb09639ae">weight\_column\_name</a>. The weighted average is then defined as the sum of the products of <span>columnName</span> times the <a href="/content/api/cpp/namespacegpudb#a1ab2e07eb9717291d5a706cdb09639ae">weight\_column\_name</a> values divided by the sum of the <a href="/content/api/cpp/namespacegpudb#a1ab2e07eb9717291d5a706cdb09639ae">weight\_column\_name</a> values.</p>
        <p>Additional columns can be used in the calculation of statistics via <a href="/content/api/cpp/namespacegpudb#ac247aec8a5036be28db98f2a2b7f01f2">additional\_column\_names</a>. Values in these columns will be included in the overall aggregate calculation–individual aggregates will not be calculated per additional column. For instance, requesting the <a href="/content/api/cpp/namespacegpudb#a910faa6f48dd193f18aba29b5c960344">count</a> and <a href="/content/api/cpp/namespacegpudb#a321e05dbc66fb2bd763a96e37c2ef28c">mean</a> of <span>columnName</span> x and <a href="/content/api/cpp/namespacegpudb#ac247aec8a5036be28db98f2a2b7f01f2">additional\_column\_names</a> y and z, where x holds the numbers 1-10, y holds 11-20, and z holds 21-30, would return the total number of x, y, and z values (30), and the single average value across all x, y, and z values (15.5).</p>
        <p>The response includes a list of key/value pairs of each statistic requested and its corresponding value.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of the table on which the statistics operation will be performed, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>columnName</td>
                <td>Name of the primary column for which the statistics are to be calculated. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>stats</td>

                <td>
                  Comma separated list of the statistics to calculate, e.g. "sum,mean". Supported values:

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a910faa6f48dd193f18aba29b5c960344">aggregate\_statistics\_count</a>: Number of objects (independent of the given column(s)). </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a321e05dbc66fb2bd763a96e37c2ef28c">aggregate\_statistics\_mean</a>: Arithmetic mean (average), equivalent to sum/count. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a80eb30610a806779605b67de7a650a88">aggregate\_statistics\_stdv</a>: Sample standard deviation (denominator is count-1). </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#add21322ff5f88391b8453a054b4b37a2">aggregate\_statistics\_variance</a>: Unbiased sample variance (denominator is count-1). </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a27661ef055a1ceaf3712e11ecf627488">aggregate\_statistics\_skew</a>: Skewness (third standardized moment). </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#af4bc4d865eef8b909cd55780ae4af232">aggregate\_statistics\_kurtosis</a>: Kurtosis (fourth standardized moment). </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aa117dbda93c32c62770145de97c4c9c2">aggregate\_statistics\_sum</a>: Sum of all values in the column(s). </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a90baeec3c38fc6bd4953070dc6c9d0ea">aggregate\_statistics\_min</a>: Minimum value of the column(s). </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a912e6ca011bcd0ea98799d9db7152459">aggregate\_statistics\_max</a>: Maximum value of the column(s). </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a673d92e6228a5a96680db7b385aeceb4">aggregate\_statistics\_weighted\_average</a>: Weighted arithmetic mean (using the option <a href="/content/api/cpp/namespacegpudb#a1ab2e07eb9717291d5a706cdb09639ae">weight\_column\_name</a> as the weighting column). </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aa88f43507d7f396847a0a10a054c8b31">aggregate\_statistics\_cardinality</a>: Number of unique values in the column(s). </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aecd79bad34930f168402bea13f361615">aggregate\_statistics\_estimated\_cardinality</a>: Estimate (via hyperloglog technique) of the number of unique values in the column(s). </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a6b2e607ab0d4568753af82c6cb796057">aggregate\_statistics\_percentile</a>: Estimate (via t-digest) of the given percentile of the column(s) (percentile(50.0) will be an approximation of the median). Add a second, comma-separated value to calculate percentile resolution, e.g., 'percentile(75,150)'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a543743eb2266f91be3240a5ce00dbfbf">aggregate\_statistics\_percentile\_rank</a>: Estimate (via t-digest) of the percentile rank of the given value in the column(s) (if the given value is the median of the column(s), percentile\_rank(\<median>) will return approximately 50.0). </li>
                  </ul>
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#ac247aec8a5036be28db98f2a2b7f01f2">aggregate\_statistics\_additional\_column\_names</a>: A list of comma separated column names over which statistics can be accumulated along with the primary column. All columns listed and <span>columnName</span> must be of the same type. Must not include the column specified in <span>columnName</span> and no column can be listed twice. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a1ab2e07eb9717291d5a706cdb09639ae">aggregate\_statistics\_weight\_column\_name</a>: Name of column used as weighting attribute for the weighted average statistic. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AggregateStatisticsResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ad2e88c5ed0f712c53671d74f8690f8c6">◆ </a></span>aggregateStatistics() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AggregateStatisticsResponse">AggregateStatisticsResponse</a> & gpudb::GPUdb::aggregateStatistics </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>columnName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>stats</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1AggregateStatisticsResponse">AggregateStatisticsResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Calculates the requested statistics of the given column(s) in a given table. </p>
        <p>The available statistics are: <a href="/content/api/cpp/namespacegpudb#a910faa6f48dd193f18aba29b5c960344">count</a> (number of total objects), <a href="/content/api/cpp/namespacegpudb#a321e05dbc66fb2bd763a96e37c2ef28c">mean</a>, <a href="/content/api/cpp/namespacegpudb#a80eb30610a806779605b67de7a650a88">stdv</a> (standard deviation), <a href="/content/api/cpp/namespacegpudb#add21322ff5f88391b8453a054b4b37a2">variance</a>, <a href="/content/api/cpp/namespacegpudb#a27661ef055a1ceaf3712e11ecf627488">skew</a>, <a href="/content/api/cpp/namespacegpudb#af4bc4d865eef8b909cd55780ae4af232">kurtosis</a>, <a href="/content/api/cpp/namespacegpudb#aa117dbda93c32c62770145de97c4c9c2">sum</a>, <a href="/content/api/cpp/namespacegpudb#a90baeec3c38fc6bd4953070dc6c9d0ea">min</a>, <a href="/content/api/cpp/namespacegpudb#a912e6ca011bcd0ea98799d9db7152459">max</a>, <a href="/content/api/cpp/namespacegpudb#a673d92e6228a5a96680db7b385aeceb4">weighted\_average</a>, <a href="/content/api/cpp/namespacegpudb#aa88f43507d7f396847a0a10a054c8b31">cardinality</a> (unique count), <a href="/content/api/cpp/namespacegpudb#aecd79bad34930f168402bea13f361615">estimated\_cardinality</a>, <a href="/content/api/cpp/namespacegpudb#a6b2e607ab0d4568753af82c6cb796057">percentile</a>, and <a href="/content/api/cpp/namespacegpudb#a543743eb2266f91be3240a5ce00dbfbf">percentile\_rank</a>.</p>
        <p>Estimated cardinality is calculated by using the hyperloglog approximation technique.</p>
        <p>Percentiles and percentile ranks are approximate and are calculated using the t-digest algorithm. They must include the desired <a href="/content/api/cpp/namespacegpudb#a6b2e607ab0d4568753af82c6cb796057">percentile</a>/<a href="/content/api/cpp/namespacegpudb#a543743eb2266f91be3240a5ce00dbfbf">percentile\_rank</a>. To compute multiple percentiles each value must be specified separately (i.e.\ 'percentile(75.0),percentile(99.0),percentile\_rank(1234.56),percentile\_rank(-5)').</p>
        <p>A second, comma-separated value can be added to the <a href="/content/api/cpp/namespacegpudb#a6b2e607ab0d4568753af82c6cb796057">percentile</a> statistic to calculate percentile resolution, e.g., a 50th percentile with 200 resolution would be 'percentile(50,200)'.</p>
        <p>The weighted average statistic requires a weight column to be specified in <a href="/content/api/cpp/namespacegpudb#a1ab2e07eb9717291d5a706cdb09639ae">weight\_column\_name</a>. The weighted average is then defined as the sum of the products of <span>columnName</span> times the <a href="/content/api/cpp/namespacegpudb#a1ab2e07eb9717291d5a706cdb09639ae">weight\_column\_name</a> values divided by the sum of the <a href="/content/api/cpp/namespacegpudb#a1ab2e07eb9717291d5a706cdb09639ae">weight\_column\_name</a> values.</p>
        <p>Additional columns can be used in the calculation of statistics via <a href="/content/api/cpp/namespacegpudb#ac247aec8a5036be28db98f2a2b7f01f2">additional\_column\_names</a>. Values in these columns will be included in the overall aggregate calculation–individual aggregates will not be calculated per additional column. For instance, requesting the <a href="/content/api/cpp/namespacegpudb#a910faa6f48dd193f18aba29b5c960344">count</a> and <a href="/content/api/cpp/namespacegpudb#a321e05dbc66fb2bd763a96e37c2ef28c">mean</a> of <span>columnName</span> x and <a href="/content/api/cpp/namespacegpudb#ac247aec8a5036be28db98f2a2b7f01f2">additional\_column\_names</a> y and z, where x holds the numbers 1-10, y holds 11-20, and z holds 21-30, would return the total number of x, y, and z values (30), and the single average value across all x, y, and z values (15.5).</p>
        <p>The response includes a list of key/value pairs of each statistic requested and its corresponding value.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of the table on which the statistics operation will be performed, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>columnName</td>
                <td>Name of the primary column for which the statistics are to be calculated. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>stats</td>

                <td>
                  Comma separated list of the statistics to calculate, e.g. "sum,mean". Supported values:

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a910faa6f48dd193f18aba29b5c960344">aggregate\_statistics\_count</a>: Number of objects (independent of the given column(s)). </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a321e05dbc66fb2bd763a96e37c2ef28c">aggregate\_statistics\_mean</a>: Arithmetic mean (average), equivalent to sum/count. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a80eb30610a806779605b67de7a650a88">aggregate\_statistics\_stdv</a>: Sample standard deviation (denominator is count-1). </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#add21322ff5f88391b8453a054b4b37a2">aggregate\_statistics\_variance</a>: Unbiased sample variance (denominator is count-1). </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a27661ef055a1ceaf3712e11ecf627488">aggregate\_statistics\_skew</a>: Skewness (third standardized moment). </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#af4bc4d865eef8b909cd55780ae4af232">aggregate\_statistics\_kurtosis</a>: Kurtosis (fourth standardized moment). </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aa117dbda93c32c62770145de97c4c9c2">aggregate\_statistics\_sum</a>: Sum of all values in the column(s). </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a90baeec3c38fc6bd4953070dc6c9d0ea">aggregate\_statistics\_min</a>: Minimum value of the column(s). </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a912e6ca011bcd0ea98799d9db7152459">aggregate\_statistics\_max</a>: Maximum value of the column(s). </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a673d92e6228a5a96680db7b385aeceb4">aggregate\_statistics\_weighted\_average</a>: Weighted arithmetic mean (using the option <a href="/content/api/cpp/namespacegpudb#a1ab2e07eb9717291d5a706cdb09639ae">weight\_column\_name</a> as the weighting column). </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aa88f43507d7f396847a0a10a054c8b31">aggregate\_statistics\_cardinality</a>: Number of unique values in the column(s). </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aecd79bad34930f168402bea13f361615">aggregate\_statistics\_estimated\_cardinality</a>: Estimate (via hyperloglog technique) of the number of unique values in the column(s). </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a6b2e607ab0d4568753af82c6cb796057">aggregate\_statistics\_percentile</a>: Estimate (via t-digest) of the given percentile of the column(s) (percentile(50.0) will be an approximation of the median). Add a second, comma-separated value to calculate percentile resolution, e.g., 'percentile(75,150)'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a543743eb2266f91be3240a5ce00dbfbf">aggregate\_statistics\_percentile\_rank</a>: Estimate (via t-digest) of the percentile rank of the given value in the column(s) (if the given value is the median of the column(s), percentile\_rank(\<median>) will return approximately 50.0). </li>
                  </ul>
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#ac247aec8a5036be28db98f2a2b7f01f2">aggregate\_statistics\_additional\_column\_names</a>: A list of comma separated column names over which statistics can be accumulated along with the primary column. All columns listed and <span>columnName</span> must be of the same type. Must not include the column specified in <span>columnName</span> and no column can be listed twice. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a1ab2e07eb9717291d5a706cdb09639ae">aggregate\_statistics\_weight\_column\_name</a>: Name of column used as weighting attribute for the weighted average statistic. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AggregateStatisticsResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AggregateStatisticsResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ab4b8d8c9fb721c8337fc9ffec67118df">◆ </a></span>aggregateStatisticsByRange() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AggregateStatisticsByRangeResponse">AggregateStatisticsByRangeResponse</a> gpudb::GPUdb::aggregateStatisticsByRange </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1AggregateStatisticsByRangeRequest">AggregateStatisticsByRangeRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Divides the given set into bins and calculates statistics of the values of a value-column in each bin. </p>
        <p>The bins are based on the values of a given binning-column. The statistics that may be requested are mean, stdv (standard deviation), variance, skew, kurtosis, sum, min, max, first, last and weighted average. In addition to the requested statistics the count of total samples in each bin is returned. This counts vector is just the histogram of the column used to divide the set members into bins. The weighted average statistic requires a weight column to be specified in <a href="/content/api/cpp/namespacegpudb#a079d69711e9b9157e1b8903947ca93c0">weight\_column\_name</a>. The weighted average is then defined as the sum of the products of the value column times the weight column divided by the sum of the weight column.</p>
        <p>There are two methods for binning the set members. In the first, which can be used for numeric valued binning-columns, a min, max and interval are specified. The number of bins, nbins, is the integer upper bound of (max-min)/interval. Values that fall in the range \[min+n\*interval,min+(n+1)\*interval) are placed in the nth bin where n ranges from 0..nbin-2. The final bin is \[min+(nbin-1)\*interval,max]. In the second method, <a href="/content/api/cpp/namespacegpudb#a65d78d9aab0dd5d9f544276ff8821105">bin\_values</a> specifies a list of binning column values. Binning-columns whose value matches the nth member of the <a href="/content/api/cpp/namespacegpudb#a65d78d9aab0dd5d9f544276ff8821105">bin\_values</a> list are placed in the nth bin. When a list is provided, the binning-column must be of type string or int.</p>
        <p>NOTE: The Kinetica instance being accessed must be running a CUDA (GPU-based) build to service this request.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AggregateStatisticsByRangeRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AggregateStatisticsByRangeResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ac462c1d0e86217293522998fa6923381">◆ </a></span>aggregateStatisticsByRange() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AggregateStatisticsByRangeResponse">AggregateStatisticsByRangeResponse</a> & gpudb::GPUdb::aggregateStatisticsByRange </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1AggregateStatisticsByRangeRequest">AggregateStatisticsByRangeRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1AggregateStatisticsByRangeResponse">AggregateStatisticsByRangeResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Divides the given set into bins and calculates statistics of the values of a value-column in each bin. </p>
        <p>The bins are based on the values of a given binning-column. The statistics that may be requested are mean, stdv (standard deviation), variance, skew, kurtosis, sum, min, max, first, last and weighted average. In addition to the requested statistics the count of total samples in each bin is returned. This counts vector is just the histogram of the column used to divide the set members into bins. The weighted average statistic requires a weight column to be specified in <a href="/content/api/cpp/namespacegpudb#a079d69711e9b9157e1b8903947ca93c0">weight\_column\_name</a>. The weighted average is then defined as the sum of the products of the value column times the weight column divided by the sum of the weight column.</p>
        <p>There are two methods for binning the set members. In the first, which can be used for numeric valued binning-columns, a min, max and interval are specified. The number of bins, nbins, is the integer upper bound of (max-min)/interval. Values that fall in the range \[min+n\*interval,min+(n+1)\*interval) are placed in the nth bin where n ranges from 0..nbin-2. The final bin is \[min+(nbin-1)\*interval,max]. In the second method, <a href="/content/api/cpp/namespacegpudb#a65d78d9aab0dd5d9f544276ff8821105">bin\_values</a> specifies a list of binning column values. Binning-columns whose value matches the nth member of the <a href="/content/api/cpp/namespacegpudb#a65d78d9aab0dd5d9f544276ff8821105">bin\_values</a> list are placed in the nth bin. When a list is provided, the binning-column must be of type string or int.</p>
        <p>NOTE: The Kinetica instance being accessed must be running a CUDA (GPU-based) build to service this request.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AggregateStatisticsByRangeRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AggregateStatisticsByRangeResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AggregateStatisticsByRangeResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a5edaf858ba73c3e2582e0d9c9266277e">◆ </a></span>aggregateStatisticsByRange() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AggregateStatisticsByRangeResponse">AggregateStatisticsByRangeResponse</a> gpudb::GPUdb::aggregateStatisticsByRange </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>selectExpression</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>columnName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>valueColumnName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>stats</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const double</td>
            <td><span><span>start</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const double</td>
            <td><span><span>end</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const double</td>
            <td><span><span>interval</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Divides the given set into bins and calculates statistics of the values of a value-column in each bin. </p>
        <p>The bins are based on the values of a given binning-column. The statistics that may be requested are mean, stdv (standard deviation), variance, skew, kurtosis, sum, min, max, first, last and weighted average. In addition to the requested statistics the count of total samples in each bin is returned. This counts vector is just the histogram of the column used to divide the set members into bins. The weighted average statistic requires a weight column to be specified in <a href="/content/api/cpp/namespacegpudb#a079d69711e9b9157e1b8903947ca93c0">weight\_column\_name</a>. The weighted average is then defined as the sum of the products of the value column times the weight column divided by the sum of the weight column.</p>
        <p>There are two methods for binning the set members. In the first, which can be used for numeric valued binning-columns, a min, max and interval are specified. The number of bins, nbins, is the integer upper bound of (max-min)/interval. Values that fall in the range \[min+n\*interval,min+(n+1)\*interval) are placed in the nth bin where n ranges from 0..nbin-2. The final bin is \[min+(nbin-1)\*interval,max]. In the second method, <a href="/content/api/cpp/namespacegpudb#a65d78d9aab0dd5d9f544276ff8821105">bin\_values</a> specifies a list of binning column values. Binning-columns whose value matches the nth member of the <a href="/content/api/cpp/namespacegpudb#a65d78d9aab0dd5d9f544276ff8821105">bin\_values</a> list are placed in the nth bin. When a list is provided, the binning-column must be of type string or int.</p>
        <p>NOTE: The Kinetica instance being accessed must be running a CUDA (GPU-based) build to service this request.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of the table on which the ranged-statistics operation will be performed, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>selectExpression</td>
                <td>For a non-empty expression statistics are calculated for those records for which the expression is true. The default value is ''. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>columnName</td>
                <td>Name of the binning-column used to divide the set samples into bins. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>valueColumnName</td>
                <td>Name of the value-column for which statistics are to be computed. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>stats</td>
                <td>A string of comma separated list of the statistics to calculate, e.g. 'sum,mean'. Available statistics: mean, stdv (standard deviation), variance, skew, kurtosis, sum. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>start</td>
                <td>The lower bound of the binning-column. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>end</td>
                <td>The upper bound of the binning-column. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>interval</td>
                <td>The interval of a bin. Set members fall into bin i if the binning-column falls in the range \[start+interval\*i, start+interval\*(i+1)). </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#ae4a9b854af6340e4b22d4f68f8f42ef8">aggregate\_statistics\_by\_range\_additional\_column\_names</a>: A list of comma separated value-column names over which statistics can be accumulated along with the primary value\_column. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a65d78d9aab0dd5d9f544276ff8821105">aggregate\_statistics\_by\_range\_bin\_values</a>: A list of comma separated binning-column values. Values that match the nth bin\_values value are placed in the nth bin. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a079d69711e9b9157e1b8903947ca93c0">aggregate\_statistics\_by\_range\_weight\_column\_name</a>: Name of the column used as weighting column for the weighted\_average statistic. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a62e4a022fde7a49a14bbf0f2e4cf655a">aggregate\_statistics\_by\_range\_order\_column\_name</a>: Name of the column used for candlestick charting techniques. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AggregateStatisticsByRangeResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a4877d3a8fdad666d77809b3d1ded333b">◆ </a></span>aggregateStatisticsByRange() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AggregateStatisticsByRangeResponse">AggregateStatisticsByRangeResponse</a> & gpudb::GPUdb::aggregateStatisticsByRange </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>selectExpression</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>columnName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>valueColumnName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>stats</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const double</td>
            <td><span><span>start</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const double</td>
            <td><span><span>end</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const double</td>
            <td><span><span>interval</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1AggregateStatisticsByRangeResponse">AggregateStatisticsByRangeResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Divides the given set into bins and calculates statistics of the values of a value-column in each bin. </p>
        <p>The bins are based on the values of a given binning-column. The statistics that may be requested are mean, stdv (standard deviation), variance, skew, kurtosis, sum, min, max, first, last and weighted average. In addition to the requested statistics the count of total samples in each bin is returned. This counts vector is just the histogram of the column used to divide the set members into bins. The weighted average statistic requires a weight column to be specified in <a href="/content/api/cpp/namespacegpudb#a079d69711e9b9157e1b8903947ca93c0">weight\_column\_name</a>. The weighted average is then defined as the sum of the products of the value column times the weight column divided by the sum of the weight column.</p>
        <p>There are two methods for binning the set members. In the first, which can be used for numeric valued binning-columns, a min, max and interval are specified. The number of bins, nbins, is the integer upper bound of (max-min)/interval. Values that fall in the range \[min+n\*interval,min+(n+1)\*interval) are placed in the nth bin where n ranges from 0..nbin-2. The final bin is \[min+(nbin-1)\*interval,max]. In the second method, <a href="/content/api/cpp/namespacegpudb#a65d78d9aab0dd5d9f544276ff8821105">bin\_values</a> specifies a list of binning column values. Binning-columns whose value matches the nth member of the <a href="/content/api/cpp/namespacegpudb#a65d78d9aab0dd5d9f544276ff8821105">bin\_values</a> list are placed in the nth bin. When a list is provided, the binning-column must be of type string or int.</p>
        <p>NOTE: The Kinetica instance being accessed must be running a CUDA (GPU-based) build to service this request.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of the table on which the ranged-statistics operation will be performed, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>selectExpression</td>
                <td>For a non-empty expression statistics are calculated for those records for which the expression is true. The default value is ''. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>columnName</td>
                <td>Name of the binning-column used to divide the set samples into bins. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>valueColumnName</td>
                <td>Name of the value-column for which statistics are to be computed. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>stats</td>
                <td>A string of comma separated list of the statistics to calculate, e.g. 'sum,mean'. Available statistics: mean, stdv (standard deviation), variance, skew, kurtosis, sum. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>start</td>
                <td>The lower bound of the binning-column. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>end</td>
                <td>The upper bound of the binning-column. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>interval</td>
                <td>The interval of a bin. Set members fall into bin i if the binning-column falls in the range \[start+interval\*i, start+interval\*(i+1)). </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#ae4a9b854af6340e4b22d4f68f8f42ef8">aggregate\_statistics\_by\_range\_additional\_column\_names</a>: A list of comma separated value-column names over which statistics can be accumulated along with the primary value\_column. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a65d78d9aab0dd5d9f544276ff8821105">aggregate\_statistics\_by\_range\_bin\_values</a>: A list of comma separated binning-column values. Values that match the nth bin\_values value are placed in the nth bin. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a079d69711e9b9157e1b8903947ca93c0">aggregate\_statistics\_by\_range\_weight\_column\_name</a>: Name of the column used as weighting column for the weighted\_average statistic. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a62e4a022fde7a49a14bbf0f2e4cf655a">aggregate\_statistics\_by\_range\_order\_column\_name</a>: Name of the column used for candlestick charting techniques. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AggregateStatisticsByRangeResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AggregateStatisticsByRangeResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a19a392ef8588ef5bef4b650a2b7a99ba">◆ </a></span>aggregateUnique() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AggregateUniqueResponse">AggregateUniqueResponse</a> gpudb::GPUdb::aggregateUnique </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1AggregateUniqueRequest">AggregateUniqueRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Returns all the unique values from a particular column (specified by <a href="/content/api/cpp/structgpudb_1_1AggregateUniqueRequest#a3fdc4b7bccd3b9fcd14ab1b45b6c3cb0">columnName</a>) of a particular table or view (specified by <a href="/content/api/cpp/structgpudb_1_1AggregateUniqueRequest#a328a501af128cf4c6a0e48b705d98360">tableName</a>). </p>
        <p>If <a href="/content/api/cpp/structgpudb_1_1AggregateUniqueRequest#a3fdc4b7bccd3b9fcd14ab1b45b6c3cb0">columnName</a> is a numeric column, the values will be in <a href="/content/api/cpp/structgpudb_1_1RawAggregateUniqueResponse#aa6cc3a59af6a4b6a9deccc913a3ac38b">binaryEncodedResponse</a>. Otherwise if <a href="/content/api/cpp/structgpudb_1_1AggregateUniqueRequest#a3fdc4b7bccd3b9fcd14ab1b45b6c3cb0">columnName</a> is a string column, the values will be in <a href="/content/api/cpp/structgpudb_1_1RawAggregateUniqueResponse#ac2d8e9ebc9d9fcd530f9b6cc84555890">jsonEncodedResponse</a>. The results can be paged via <a href="/content/api/cpp/structgpudb_1_1AggregateUniqueRequest#a72dcacc3c10af128eee98e0724464411">offset</a> and <a href="/content/api/cpp/structgpudb_1_1AggregateUniqueRequest#af8df24843fa865129e3b50f8a6f80731">limit</a> parameters.</p>
        <p>"limit":"10","sort\_order":"descending"</p>
        <p>The response is returned as a dynamic schema. For details see: <a href="/content/api/concepts/#dynamic-schemas">dynamic schemas documentation</a>.</p>
        <p>If a <a href="/content/api/cpp/namespacegpudb#aa237f688a5ba22fc86ae0b3e6c521060">result\_table</a> name is specified in the <a href="/content/api/cpp/structgpudb_1_1AggregateUniqueRequest#aa30473089a64cd808f10f6def803571f">options</a>, the results are stored in a new table with that name–no results are returned in the response. Both the table name and resulting column name must adhere to <a href="/content/concepts/tables/#table">standard naming conventions</a>; any column expression will need to be aliased. If the source table's <a href="/content/concepts/tables/#shard-keys">shard key</a> is used as the <a href="/content/api/cpp/structgpudb_1_1AggregateUniqueRequest#a3fdc4b7bccd3b9fcd14ab1b45b6c3cb0">columnName</a>, the result table will be sharded, in all other cases it will be replicated. Sorting will properly function only if the result table is replicated or if there is only one processing node and should not be relied upon in other cases. Not available if the value of <a href="/content/api/cpp/structgpudb_1_1AggregateUniqueRequest#a3fdc4b7bccd3b9fcd14ab1b45b6c3cb0">columnName</a> is an unrestricted-length string.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AggregateUniqueRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AggregateUniqueResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a8b74de77f46fc621091997a4eb60b116">◆ </a></span>aggregateUnique() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AggregateUniqueResponse">AggregateUniqueResponse</a> & gpudb::GPUdb::aggregateUnique </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1AggregateUniqueRequest">AggregateUniqueRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1AggregateUniqueResponse">AggregateUniqueResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Returns all the unique values from a particular column (specified by <a href="/content/api/cpp/structgpudb_1_1AggregateUniqueRequest#a3fdc4b7bccd3b9fcd14ab1b45b6c3cb0">columnName</a>) of a particular table or view (specified by <a href="/content/api/cpp/structgpudb_1_1AggregateUniqueRequest#a328a501af128cf4c6a0e48b705d98360">tableName</a>). </p>
        <p>If <a href="/content/api/cpp/structgpudb_1_1AggregateUniqueRequest#a3fdc4b7bccd3b9fcd14ab1b45b6c3cb0">columnName</a> is a numeric column, the values will be in <a href="/content/api/cpp/structgpudb_1_1RawAggregateUniqueResponse#aa6cc3a59af6a4b6a9deccc913a3ac38b">binaryEncodedResponse</a>. Otherwise if <a href="/content/api/cpp/structgpudb_1_1AggregateUniqueRequest#a3fdc4b7bccd3b9fcd14ab1b45b6c3cb0">columnName</a> is a string column, the values will be in <a href="/content/api/cpp/structgpudb_1_1RawAggregateUniqueResponse#ac2d8e9ebc9d9fcd530f9b6cc84555890">jsonEncodedResponse</a>. The results can be paged via <a href="/content/api/cpp/structgpudb_1_1AggregateUniqueRequest#a72dcacc3c10af128eee98e0724464411">offset</a> and <a href="/content/api/cpp/structgpudb_1_1AggregateUniqueRequest#af8df24843fa865129e3b50f8a6f80731">limit</a> parameters.</p>
        <p>"limit":"10","sort\_order":"descending"</p>
        <p>The response is returned as a dynamic schema. For details see: <a href="/content/api/concepts/#dynamic-schemas">dynamic schemas documentation</a>.</p>
        <p>If a <a href="/content/api/cpp/namespacegpudb#aa237f688a5ba22fc86ae0b3e6c521060">result\_table</a> name is specified in the <a href="/content/api/cpp/structgpudb_1_1AggregateUniqueRequest#aa30473089a64cd808f10f6def803571f">options</a>, the results are stored in a new table with that name–no results are returned in the response. Both the table name and resulting column name must adhere to <a href="/content/concepts/tables/#table">standard naming conventions</a>; any column expression will need to be aliased. If the source table's <a href="/content/concepts/tables/#shard-keys">shard key</a> is used as the <a href="/content/api/cpp/structgpudb_1_1AggregateUniqueRequest#a3fdc4b7bccd3b9fcd14ab1b45b6c3cb0">columnName</a>, the result table will be sharded, in all other cases it will be replicated. Sorting will properly function only if the result table is replicated or if there is only one processing node and should not be relied upon in other cases. Not available if the value of <a href="/content/api/cpp/structgpudb_1_1AggregateUniqueRequest#a3fdc4b7bccd3b9fcd14ab1b45b6c3cb0">columnName</a> is an unrestricted-length string.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AggregateUniqueRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AggregateUniqueResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AggregateUniqueResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a5a23184b011dc1f0fea7b2486c7d195e">◆ </a></span>aggregateUnique() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AggregateUniqueResponse">AggregateUniqueResponse</a> gpudb::GPUdb::aggregateUnique </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>columnName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const int64\_t</td>
            <td><span><span>offset</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const int64\_t</td>
            <td><span><span>limit</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Returns all the unique values from a particular column (specified by <span>columnName</span>) of a particular table or view (specified by <span>tableName</span>). </p>
        <p>If <span>columnName</span> is a numeric column, the values will be in <a href="/content/api/cpp/structgpudb_1_1RawAggregateUniqueResponse#aa6cc3a59af6a4b6a9deccc913a3ac38b">binaryEncodedResponse</a>. Otherwise if <span>columnName</span> is a string column, the values will be in <a href="/content/api/cpp/structgpudb_1_1RawAggregateUniqueResponse#ac2d8e9ebc9d9fcd530f9b6cc84555890">jsonEncodedResponse</a>. The results can be paged via <span>offset</span> and <span>limit</span> parameters.</p>
        <p>"limit":"10","sort\_order":"descending"</p>
        <p>The response is returned as a dynamic schema. For details see: <a href="/content/api/concepts/#dynamic-schemas">dynamic schemas documentation</a>.</p>
        <p>If a <a href="/content/api/cpp/namespacegpudb#aa237f688a5ba22fc86ae0b3e6c521060">result\_table</a> name is specified in the <span>options</span>, the results are stored in a new table with that name–no results are returned in the response. Both the table name and resulting column name must adhere to <a href="/content/concepts/tables/#table">standard naming conventions</a>; any column expression will need to be aliased. If the source table's <a href="/content/concepts/tables/#shard-keys">shard key</a> is used as the <span>columnName</span>, the result table will be sharded, in all other cases it will be replicated. Sorting will properly function only if the result table is replicated or if there is only one processing node and should not be relied upon in other cases. Not available if the value of <span>columnName</span> is an unrestricted-length string.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of an existing table or view on which the operation will be performed, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>columnName</td>
                <td>Name of the column or an expression containing one or more column names on which the unique function would be applied. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>offset</td>
                <td>A positive integer indicating the number of initial results to skip (this can be useful for paging through the results). The default value is 0. The minimum allowed value is 0. The maximum allowed value is MAX\_INT. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>limit</td>
                <td>A positive integer indicating the maximum number of results to be returned, or END\_OF\_SET (-9999) to indicate that the maximum number of results allowed by the server should be returned. The number of records returned will never exceed the server's own limit, defined by the <a href="/content/config/#config-main-general">max\_get\_records\_size</a> parameter in the server configuration. Use <a href="/content/api/cpp/structgpudb_1_1RawAggregateUniqueResponse#a92a4b2c3978f7be8a5464939a0749cce">hasMoreRecords</a> to see if more records exist in the result to be fetched, and <span>offset</span> and <span>limit</span> to request subsequent pages of results. The default value is -9999. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a77ae199f38df61e6dde8d89b93ecc936">aggregate\_unique\_create\_temp\_table</a>: If <a href="/content/api/cpp/namespacegpudb#ae2162cf6fc03fa39704610646c6c56e5">true</a>, a unique temporary table name will be generated in the sys\_temp schema and used in place of <a href="/content/api/cpp/namespacegpudb#aa237f688a5ba22fc86ae0b3e6c521060">result\_table</a>. If <a href="/content/api/cpp/namespacegpudb#ade4c9fcafefc10a54ab23558c1900f8d">result\_table\_persist</a> is <a href="/content/api/cpp/namespacegpudb#a23539e4a24f19c6e30de466dad5f9a42">false</a> (or unspecified), then this is always allowed even if the caller does not have permission to create tables. The generated name is returned in <a href="/content/api/cpp/namespacegpudb#a8321609fc27d60dfac001c3f95b47833">qualified\_result\_table\_name</a>. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ae2162cf6fc03fa39704610646c6c56e5">aggregate\_unique\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a23539e4a24f19c6e30de466dad5f9a42">aggregate\_unique\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a23539e4a24f19c6e30de466dad5f9a42">aggregate\_unique\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#acd236cab9fe7d1fe7084335013d751cf">aggregate\_unique\_collection\_name</a>: \[DEPRECATED–please specify the containing schema as part of <a href="/content/api/cpp/namespacegpudb#aa237f688a5ba22fc86ae0b3e6c521060">result\_table</a> and use <a href="#a33d9a0a8e738d14b688f9f869f9640ad">createSchema</a> to create the schema if non-existent] Name of a schema which is to contain the table specified in <a href="/content/api/cpp/namespacegpudb#aa237f688a5ba22fc86ae0b3e6c521060">result\_table</a>. If the schema provided is non-existent, it will be automatically created. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#af35b92a0588fa81c24dcf16208d822c8">aggregate\_unique\_expression</a>: Filter expression to apply to the table. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a05bb58bc3e1dcf84975fe26bd07f0436">aggregate\_unique\_sort\_order</a>: String indicating how the returned values should be sorted. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#afb2a58270ae4341a0d5812c584a2f674">aggregate\_unique\_ascending</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad88048ed2c450445a0069a1d85b48faa">aggregate\_unique\_descending</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#afb2a58270ae4341a0d5812c584a2f674">aggregate\_unique\_ascending</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a2a78a0aa14ebf04309bc96df3739aa27">aggregate\_unique\_order\_by</a>: Comma-separated list of the columns to be sorted by as well as the sort direction, e.g., 'timestamp asc, x desc'. The default value is ''. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aa237f688a5ba22fc86ae0b3e6c521060">aggregate\_unique\_result\_table</a>: The name of the table used to store the results, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a> and meeting <a href="/content/concepts/tables/#table-naming-criteria">table naming criteria</a>. If present, no results are returned in the response. Not available if <span>columnName</span> is an unrestricted-length string. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ade4c9fcafefc10a54ab23558c1900f8d">aggregate\_unique\_result\_table\_persist</a>: If <a href="/content/api/cpp/namespacegpudb#ae2162cf6fc03fa39704610646c6c56e5">true</a>, then the result table specified in <a href="/content/api/cpp/namespacegpudb#aa237f688a5ba22fc86ae0b3e6c521060">result\_table</a> will be persisted and will not expire unless a <a href="/content/api/cpp/namespacegpudb#a28e49f5596045f1ebdc340d2fb1a05e3">ttl</a> is specified. If <a href="/content/api/cpp/namespacegpudb#a23539e4a24f19c6e30de466dad5f9a42">false</a>, then the result table will be an in-memory table and will expire unless a <a href="/content/api/cpp/namespacegpudb#a28e49f5596045f1ebdc340d2fb1a05e3">ttl</a> is specified otherwise. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ae2162cf6fc03fa39704610646c6c56e5">aggregate\_unique\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a23539e4a24f19c6e30de466dad5f9a42">aggregate\_unique\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a23539e4a24f19c6e30de466dad5f9a42">aggregate\_unique\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a383842d62bb6a43ea568c92f5d573e57">aggregate\_unique\_result\_table\_force\_replicated</a>: Force the result table to be replicated (ignores any sharding). Must be used in combination with the <a href="/content/api/cpp/namespacegpudb#aa237f688a5ba22fc86ae0b3e6c521060">result\_table</a> option. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ae2162cf6fc03fa39704610646c6c56e5">aggregate\_unique\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a23539e4a24f19c6e30de466dad5f9a42">aggregate\_unique\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a23539e4a24f19c6e30de466dad5f9a42">aggregate\_unique\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ade359b9173c6c1a7010fcd6c176cb7ba">aggregate\_unique\_result\_table\_generate\_pk</a>: If <a href="/content/api/cpp/namespacegpudb#ae2162cf6fc03fa39704610646c6c56e5">true</a> then set a primary key for the result table. Must be used in combination with the <a href="/content/api/cpp/namespacegpudb#aa237f688a5ba22fc86ae0b3e6c521060">result\_table</a> option. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ae2162cf6fc03fa39704610646c6c56e5">aggregate\_unique\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a23539e4a24f19c6e30de466dad5f9a42">aggregate\_unique\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a23539e4a24f19c6e30de466dad5f9a42">aggregate\_unique\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a28e49f5596045f1ebdc340d2fb1a05e3">aggregate\_unique\_ttl</a>: Sets the <a href="/content/concepts/ttl/">TTL</a> of the table specified in <a href="/content/api/cpp/namespacegpudb#aa237f688a5ba22fc86ae0b3e6c521060">result\_table</a>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#af51d44b139b7d778beeaa3286367659d">aggregate\_unique\_chunk\_size</a>: Indicates the number of records per chunk to be used for the result table. Must be used in combination with the <a href="/content/api/cpp/namespacegpudb#aa237f688a5ba22fc86ae0b3e6c521060">result\_table</a> option. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a548924decb1fccf1698abc8d60edb330">aggregate\_unique\_chunk\_column\_max\_memory</a>: Indicates the target maximum data size for each column in a chunk to be used for the result table. Must be used in combination with the <a href="/content/api/cpp/namespacegpudb#aa237f688a5ba22fc86ae0b3e6c521060">result\_table</a> option. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a89580bb1a1408953bf5c4f54e9911bae">aggregate\_unique\_chunk\_max\_memory</a>: Indicates the target maximum data size for all columns in a chunk to be used for the result table. Must be used in combination with the <a href="/content/api/cpp/namespacegpudb#aa237f688a5ba22fc86ae0b3e6c521060">result\_table</a> option. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a5670309522a62cfc3429eb0342ccf987">aggregate\_unique\_compression\_codec</a>: The default <a href="/content/concepts/column_compression/">compression codec</a> for the result table's columns. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aaa96a6401e834f845c3d7fe6e5fcb532">aggregate\_unique\_view\_id</a>: ID of view of which the result table will be a member. The default value is ''. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AggregateUniqueResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#acecb5a2b0ce05acfcff56998bd6f6d5c">◆ </a></span>aggregateUnique() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AggregateUniqueResponse">AggregateUniqueResponse</a> & gpudb::GPUdb::aggregateUnique </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>columnName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const int64\_t</td>
            <td><span><span>offset</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const int64\_t</td>
            <td><span><span>limit</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1AggregateUniqueResponse">AggregateUniqueResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Returns all the unique values from a particular column (specified by <span>columnName</span>) of a particular table or view (specified by <span>tableName</span>). </p>
        <p>If <span>columnName</span> is a numeric column, the values will be in <a href="/content/api/cpp/structgpudb_1_1RawAggregateUniqueResponse#aa6cc3a59af6a4b6a9deccc913a3ac38b">binaryEncodedResponse</a>. Otherwise if <span>columnName</span> is a string column, the values will be in <a href="/content/api/cpp/structgpudb_1_1RawAggregateUniqueResponse#ac2d8e9ebc9d9fcd530f9b6cc84555890">jsonEncodedResponse</a>. The results can be paged via <span>offset</span> and <span>limit</span> parameters.</p>
        <p>"limit":"10","sort\_order":"descending"</p>
        <p>The response is returned as a dynamic schema. For details see: <a href="/content/api/concepts/#dynamic-schemas">dynamic schemas documentation</a>.</p>
        <p>If a <a href="/content/api/cpp/namespacegpudb#aa237f688a5ba22fc86ae0b3e6c521060">result\_table</a> name is specified in the <span>options</span>, the results are stored in a new table with that name–no results are returned in the response. Both the table name and resulting column name must adhere to <a href="/content/concepts/tables/#table">standard naming conventions</a>; any column expression will need to be aliased. If the source table's <a href="/content/concepts/tables/#shard-keys">shard key</a> is used as the <span>columnName</span>, the result table will be sharded, in all other cases it will be replicated. Sorting will properly function only if the result table is replicated or if there is only one processing node and should not be relied upon in other cases. Not available if the value of <span>columnName</span> is an unrestricted-length string.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of an existing table or view on which the operation will be performed, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>columnName</td>
                <td>Name of the column or an expression containing one or more column names on which the unique function would be applied. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>offset</td>
                <td>A positive integer indicating the number of initial results to skip (this can be useful for paging through the results). The default value is 0. The minimum allowed value is 0. The maximum allowed value is MAX\_INT. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>limit</td>
                <td>A positive integer indicating the maximum number of results to be returned, or END\_OF\_SET (-9999) to indicate that the maximum number of results allowed by the server should be returned. The number of records returned will never exceed the server's own limit, defined by the <a href="/content/config/#config-main-general">max\_get\_records\_size</a> parameter in the server configuration. Use <a href="/content/api/cpp/structgpudb_1_1RawAggregateUniqueResponse#a92a4b2c3978f7be8a5464939a0749cce">hasMoreRecords</a> to see if more records exist in the result to be fetched, and <span>offset</span> and <span>limit</span> to request subsequent pages of results. The default value is -9999. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a77ae199f38df61e6dde8d89b93ecc936">aggregate\_unique\_create\_temp\_table</a>: If <a href="/content/api/cpp/namespacegpudb#ae2162cf6fc03fa39704610646c6c56e5">true</a>, a unique temporary table name will be generated in the sys\_temp schema and used in place of <a href="/content/api/cpp/namespacegpudb#aa237f688a5ba22fc86ae0b3e6c521060">result\_table</a>. If <a href="/content/api/cpp/namespacegpudb#ade4c9fcafefc10a54ab23558c1900f8d">result\_table\_persist</a> is <a href="/content/api/cpp/namespacegpudb#a23539e4a24f19c6e30de466dad5f9a42">false</a> (or unspecified), then this is always allowed even if the caller does not have permission to create tables. The generated name is returned in <a href="/content/api/cpp/namespacegpudb#a8321609fc27d60dfac001c3f95b47833">qualified\_result\_table\_name</a>. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ae2162cf6fc03fa39704610646c6c56e5">aggregate\_unique\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a23539e4a24f19c6e30de466dad5f9a42">aggregate\_unique\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a23539e4a24f19c6e30de466dad5f9a42">aggregate\_unique\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#acd236cab9fe7d1fe7084335013d751cf">aggregate\_unique\_collection\_name</a>: \[DEPRECATED–please specify the containing schema as part of <a href="/content/api/cpp/namespacegpudb#aa237f688a5ba22fc86ae0b3e6c521060">result\_table</a> and use <a href="#a33d9a0a8e738d14b688f9f869f9640ad">createSchema</a> to create the schema if non-existent] Name of a schema which is to contain the table specified in <a href="/content/api/cpp/namespacegpudb#aa237f688a5ba22fc86ae0b3e6c521060">result\_table</a>. If the schema provided is non-existent, it will be automatically created. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#af35b92a0588fa81c24dcf16208d822c8">aggregate\_unique\_expression</a>: Filter expression to apply to the table. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a05bb58bc3e1dcf84975fe26bd07f0436">aggregate\_unique\_sort\_order</a>: String indicating how the returned values should be sorted. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#afb2a58270ae4341a0d5812c584a2f674">aggregate\_unique\_ascending</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad88048ed2c450445a0069a1d85b48faa">aggregate\_unique\_descending</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#afb2a58270ae4341a0d5812c584a2f674">aggregate\_unique\_ascending</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a2a78a0aa14ebf04309bc96df3739aa27">aggregate\_unique\_order\_by</a>: Comma-separated list of the columns to be sorted by as well as the sort direction, e.g., 'timestamp asc, x desc'. The default value is ''. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aa237f688a5ba22fc86ae0b3e6c521060">aggregate\_unique\_result\_table</a>: The name of the table used to store the results, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a> and meeting <a href="/content/concepts/tables/#table-naming-criteria">table naming criteria</a>. If present, no results are returned in the response. Not available if <span>columnName</span> is an unrestricted-length string. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ade4c9fcafefc10a54ab23558c1900f8d">aggregate\_unique\_result\_table\_persist</a>: If <a href="/content/api/cpp/namespacegpudb#ae2162cf6fc03fa39704610646c6c56e5">true</a>, then the result table specified in <a href="/content/api/cpp/namespacegpudb#aa237f688a5ba22fc86ae0b3e6c521060">result\_table</a> will be persisted and will not expire unless a <a href="/content/api/cpp/namespacegpudb#a28e49f5596045f1ebdc340d2fb1a05e3">ttl</a> is specified. If <a href="/content/api/cpp/namespacegpudb#a23539e4a24f19c6e30de466dad5f9a42">false</a>, then the result table will be an in-memory table and will expire unless a <a href="/content/api/cpp/namespacegpudb#a28e49f5596045f1ebdc340d2fb1a05e3">ttl</a> is specified otherwise. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ae2162cf6fc03fa39704610646c6c56e5">aggregate\_unique\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a23539e4a24f19c6e30de466dad5f9a42">aggregate\_unique\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a23539e4a24f19c6e30de466dad5f9a42">aggregate\_unique\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a383842d62bb6a43ea568c92f5d573e57">aggregate\_unique\_result\_table\_force\_replicated</a>: Force the result table to be replicated (ignores any sharding). Must be used in combination with the <a href="/content/api/cpp/namespacegpudb#aa237f688a5ba22fc86ae0b3e6c521060">result\_table</a> option. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ae2162cf6fc03fa39704610646c6c56e5">aggregate\_unique\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a23539e4a24f19c6e30de466dad5f9a42">aggregate\_unique\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a23539e4a24f19c6e30de466dad5f9a42">aggregate\_unique\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ade359b9173c6c1a7010fcd6c176cb7ba">aggregate\_unique\_result\_table\_generate\_pk</a>: If <a href="/content/api/cpp/namespacegpudb#ae2162cf6fc03fa39704610646c6c56e5">true</a> then set a primary key for the result table. Must be used in combination with the <a href="/content/api/cpp/namespacegpudb#aa237f688a5ba22fc86ae0b3e6c521060">result\_table</a> option. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ae2162cf6fc03fa39704610646c6c56e5">aggregate\_unique\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a23539e4a24f19c6e30de466dad5f9a42">aggregate\_unique\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a23539e4a24f19c6e30de466dad5f9a42">aggregate\_unique\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a28e49f5596045f1ebdc340d2fb1a05e3">aggregate\_unique\_ttl</a>: Sets the <a href="/content/concepts/ttl/">TTL</a> of the table specified in <a href="/content/api/cpp/namespacegpudb#aa237f688a5ba22fc86ae0b3e6c521060">result\_table</a>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#af51d44b139b7d778beeaa3286367659d">aggregate\_unique\_chunk\_size</a>: Indicates the number of records per chunk to be used for the result table. Must be used in combination with the <a href="/content/api/cpp/namespacegpudb#aa237f688a5ba22fc86ae0b3e6c521060">result\_table</a> option. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a548924decb1fccf1698abc8d60edb330">aggregate\_unique\_chunk\_column\_max\_memory</a>: Indicates the target maximum data size for each column in a chunk to be used for the result table. Must be used in combination with the <a href="/content/api/cpp/namespacegpudb#aa237f688a5ba22fc86ae0b3e6c521060">result\_table</a> option. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a89580bb1a1408953bf5c4f54e9911bae">aggregate\_unique\_chunk\_max\_memory</a>: Indicates the target maximum data size for all columns in a chunk to be used for the result table. Must be used in combination with the <a href="/content/api/cpp/namespacegpudb#aa237f688a5ba22fc86ae0b3e6c521060">result\_table</a> option. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a5670309522a62cfc3429eb0342ccf987">aggregate\_unique\_compression\_codec</a>: The default <a href="/content/concepts/column_compression/">compression codec</a> for the result table's columns. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aaa96a6401e834f845c3d7fe6e5fcb532">aggregate\_unique\_view\_id</a>: ID of view of which the result table will be a member. The default value is ''. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AggregateUniqueResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AggregateUniqueResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ac9490ba63fb5203c35caad4458a0e17f">◆ </a></span>aggregateUniqueRaw() <span>\[1/2]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1RawAggregateUniqueResponse">RawAggregateUniqueResponse</a> gpudb::GPUdb::aggregateUniqueRaw </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1AggregateUniqueRequest">AggregateUniqueRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Returns all the unique values from a particular column (specified by <a href="/content/api/cpp/structgpudb_1_1AggregateUniqueRequest#a3fdc4b7bccd3b9fcd14ab1b45b6c3cb0">columnName</a>) of a particular table or view (specified by <a href="/content/api/cpp/structgpudb_1_1AggregateUniqueRequest#a328a501af128cf4c6a0e48b705d98360">tableName</a>). </p>
        <p>If <a href="/content/api/cpp/structgpudb_1_1AggregateUniqueRequest#a3fdc4b7bccd3b9fcd14ab1b45b6c3cb0">columnName</a> is a numeric column, the values will be in <a href="/content/api/cpp/structgpudb_1_1RawAggregateUniqueResponse#aa6cc3a59af6a4b6a9deccc913a3ac38b">binaryEncodedResponse</a>. Otherwise if <a href="/content/api/cpp/structgpudb_1_1AggregateUniqueRequest#a3fdc4b7bccd3b9fcd14ab1b45b6c3cb0">columnName</a> is a string column, the values will be in <a href="/content/api/cpp/structgpudb_1_1RawAggregateUniqueResponse#ac2d8e9ebc9d9fcd530f9b6cc84555890">jsonEncodedResponse</a>. The results can be paged via <a href="/content/api/cpp/structgpudb_1_1AggregateUniqueRequest#a72dcacc3c10af128eee98e0724464411">offset</a> and <a href="/content/api/cpp/structgpudb_1_1AggregateUniqueRequest#af8df24843fa865129e3b50f8a6f80731">limit</a> parameters.</p>
        <p>"limit":"10","sort\_order":"descending"</p>
        <p>The response is returned as a dynamic schema. For details see: <a href="/content/api/concepts/#dynamic-schemas">dynamic schemas documentation</a>.</p>
        <p>If a <a href="/content/api/cpp/namespacegpudb#aa237f688a5ba22fc86ae0b3e6c521060">result\_table</a> name is specified in the <a href="/content/api/cpp/structgpudb_1_1AggregateUniqueRequest#aa30473089a64cd808f10f6def803571f">options</a>, the results are stored in a new table with that name–no results are returned in the response. Both the table name and resulting column name must adhere to <a href="/content/concepts/tables/#table">standard naming conventions</a>; any column expression will need to be aliased. If the source table's <a href="/content/concepts/tables/#shard-keys">shard key</a> is used as the <a href="/content/api/cpp/structgpudb_1_1AggregateUniqueRequest#a3fdc4b7bccd3b9fcd14ab1b45b6c3cb0">columnName</a>, the result table will be sharded, in all other cases it will be replicated. Sorting will properly function only if the result table is replicated or if there is only one processing node and should not be relied upon in other cases. Not available if the value of <a href="/content/api/cpp/structgpudb_1_1AggregateUniqueRequest#a3fdc4b7bccd3b9fcd14ab1b45b6c3cb0">columnName</a> is an unrestricted-length string.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AggregateUniqueRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1RawAggregateUniqueResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ac6cb1c7220529cbdc386956135c7dbd1">◆ </a></span>aggregateUniqueRaw() <span>\[2/2]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1RawAggregateUniqueResponse">RawAggregateUniqueResponse</a> & gpudb::GPUdb::aggregateUniqueRaw </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1AggregateUniqueRequest">AggregateUniqueRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1RawAggregateUniqueResponse">RawAggregateUniqueResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Returns all the unique values from a particular column (specified by <a href="/content/api/cpp/structgpudb_1_1AggregateUniqueRequest#a3fdc4b7bccd3b9fcd14ab1b45b6c3cb0">columnName</a>) of a particular table or view (specified by <a href="/content/api/cpp/structgpudb_1_1AggregateUniqueRequest#a328a501af128cf4c6a0e48b705d98360">tableName</a>). </p>
        <p>If <a href="/content/api/cpp/structgpudb_1_1AggregateUniqueRequest#a3fdc4b7bccd3b9fcd14ab1b45b6c3cb0">columnName</a> is a numeric column, the values will be in <a href="/content/api/cpp/structgpudb_1_1RawAggregateUniqueResponse#aa6cc3a59af6a4b6a9deccc913a3ac38b">binaryEncodedResponse</a>. Otherwise if <a href="/content/api/cpp/structgpudb_1_1AggregateUniqueRequest#a3fdc4b7bccd3b9fcd14ab1b45b6c3cb0">columnName</a> is a string column, the values will be in <a href="/content/api/cpp/structgpudb_1_1RawAggregateUniqueResponse#ac2d8e9ebc9d9fcd530f9b6cc84555890">jsonEncodedResponse</a>. The results can be paged via <a href="/content/api/cpp/structgpudb_1_1AggregateUniqueRequest#a72dcacc3c10af128eee98e0724464411">offset</a> and <a href="/content/api/cpp/structgpudb_1_1AggregateUniqueRequest#af8df24843fa865129e3b50f8a6f80731">limit</a> parameters.</p>
        <p>"limit":"10","sort\_order":"descending"</p>
        <p>The response is returned as a dynamic schema. For details see: <a href="/content/api/concepts/#dynamic-schemas">dynamic schemas documentation</a>.</p>
        <p>If a <a href="/content/api/cpp/namespacegpudb#aa237f688a5ba22fc86ae0b3e6c521060">result\_table</a> name is specified in the <a href="/content/api/cpp/structgpudb_1_1AggregateUniqueRequest#aa30473089a64cd808f10f6def803571f">options</a>, the results are stored in a new table with that name–no results are returned in the response. Both the table name and resulting column name must adhere to <a href="/content/concepts/tables/#table">standard naming conventions</a>; any column expression will need to be aliased. If the source table's <a href="/content/concepts/tables/#shard-keys">shard key</a> is used as the <a href="/content/api/cpp/structgpudb_1_1AggregateUniqueRequest#a3fdc4b7bccd3b9fcd14ab1b45b6c3cb0">columnName</a>, the result table will be sharded, in all other cases it will be replicated. Sorting will properly function only if the result table is replicated or if there is only one processing node and should not be relied upon in other cases. Not available if the value of <a href="/content/api/cpp/structgpudb_1_1AggregateUniqueRequest#a3fdc4b7bccd3b9fcd14ab1b45b6c3cb0">columnName</a> is an unrestricted-length string.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AggregateUniqueRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1RawAggregateUniqueResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1RawAggregateUniqueResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#abb9e5e7039f10b231076f29aa7a01f13">◆ </a></span>aggregateUnpivot() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AggregateUnpivotResponse">AggregateUnpivotResponse</a> gpudb::GPUdb::aggregateUnpivot </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1AggregateUnpivotRequest">AggregateUnpivotRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Rotate the column values into rows values. </p>
        <p>For unpivot details and examples, see <a href="/content/concepts/unpivot/">Unpivot</a>. For limitations, see <a href="/content/concepts/unpivot/#limitations">Unpivot Limitations</a>.</p>
        <p>Unpivot is used to normalize tables that are built for cross tabular reporting purposes. The unpivot operator rotates the column values for all the pivoted columns. A variable column, value column and all columns from the source table except the unpivot columns are projected into the result table. The variable column and value columns in the result table indicate the pivoted column name and values respectively.</p>
        <p>The response is returned as a dynamic schema. For details see: <a href="/content/api/concepts/#dynamic-schemas">dynamic schemas documentation</a>.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AggregateUnpivotRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AggregateUnpivotResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a230c26f2273d7f4c8557ea6d855880be">◆ </a></span>aggregateUnpivot() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AggregateUnpivotResponse">AggregateUnpivotResponse</a> & gpudb::GPUdb::aggregateUnpivot </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1AggregateUnpivotRequest">AggregateUnpivotRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1AggregateUnpivotResponse">AggregateUnpivotResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Rotate the column values into rows values. </p>
        <p>For unpivot details and examples, see <a href="/content/concepts/unpivot/">Unpivot</a>. For limitations, see <a href="/content/concepts/unpivot/#limitations">Unpivot Limitations</a>.</p>
        <p>Unpivot is used to normalize tables that are built for cross tabular reporting purposes. The unpivot operator rotates the column values for all the pivoted columns. A variable column, value column and all columns from the source table except the unpivot columns are projected into the result table. The variable column and value columns in the result table indicate the pivoted column name and values respectively.</p>
        <p>The response is returned as a dynamic schema. For details see: <a href="/content/api/concepts/#dynamic-schemas">dynamic schemas documentation</a>.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AggregateUnpivotRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AggregateUnpivotResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AggregateUnpivotResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a1d1d8a9064e31a9e7a790a026c5d484c">◆ </a></span>aggregateUnpivot() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AggregateUnpivotResponse">AggregateUnpivotResponse</a> gpudb::GPUdb::aggregateUnpivot </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< std::string > &</td>
            <td><span><span>columnNames</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>variableColumnName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>valueColumnName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< std::string > &</td>
            <td><span><span>pivotedColumns</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Rotate the column values into rows values. </p>
        <p>For unpivot details and examples, see <a href="/content/concepts/unpivot/">Unpivot</a>. For limitations, see <a href="/content/concepts/unpivot/#limitations">Unpivot Limitations</a>.</p>
        <p>Unpivot is used to normalize tables that are built for cross tabular reporting purposes. The unpivot operator rotates the column values for all the pivoted columns. A variable column, value column and all columns from the source table except the unpivot columns are projected into the result table. The variable column and value columns in the result table indicate the pivoted column name and values respectively.</p>
        <p>The response is returned as a dynamic schema. For details see: <a href="/content/api/concepts/#dynamic-schemas">dynamic schemas documentation</a>.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of the table on which the operation will be performed. Must be an existing table/view, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>columnNames</td>
                <td>List of column names or expressions. A wildcard '\*' can be used to include all the non-pivoted columns from the source table. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>variableColumnName</td>
                <td>Specifies the variable/parameter column name. The default value is ''. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>valueColumnName</td>
                <td>Specifies the value column name. The default value is ''. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>pivotedColumns</td>
                <td>List of one or more values typically the column names of the input table. All the columns in the source table must have the same data type. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a2036bf8f1a4ffcadddddeac02a04bc1a">aggregate\_unpivot\_create\_temp\_table</a>: If <a href="/content/api/cpp/namespacegpudb#a33167760257feb5d179403462f3ae254">true</a>, a unique temporary table name will be generated in the sys\_temp schema and used in place of <a href="/content/api/cpp/namespacegpudb#a387e724aa5d35a6e0adca724661df1e1">result\_table</a>. If <a href="/content/api/cpp/namespacegpudb#adee083994f1ffeddf092c7cb1d4cf951">result\_table\_persist</a> is <a href="/content/api/cpp/namespacegpudb#a0c9aac1cb76ab97b113672060d6b2878">false</a> (or unspecified), then this is always allowed even if the caller does not have permission to create tables. The generated name is returned in <a href="/content/api/cpp/namespacegpudb#a1438d7ecedcae6aa9bf9479f474c697f">qualified\_result\_table\_name</a>. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a33167760257feb5d179403462f3ae254">aggregate\_unpivot\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a0c9aac1cb76ab97b113672060d6b2878">aggregate\_unpivot\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a0c9aac1cb76ab97b113672060d6b2878">aggregate\_unpivot\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a6f04037712699777d16c32ee4970aa63">aggregate\_unpivot\_collection\_name</a>: \[DEPRECATED–please specify the containing schema as part of <a href="/content/api/cpp/namespacegpudb#a387e724aa5d35a6e0adca724661df1e1">result\_table</a> and use <a href="#a33d9a0a8e738d14b688f9f869f9640ad">createSchema</a> to create the schema if non-existent] Name of a schema which is to contain the table specified in <a href="/content/api/cpp/namespacegpudb#a387e724aa5d35a6e0adca724661df1e1">result\_table</a>. If the schema is non-existent, it will be automatically created. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a387e724aa5d35a6e0adca724661df1e1">aggregate\_unpivot\_result\_table</a>: The name of a table used to store the results, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a> and meeting <a href="/content/concepts/tables/#table-naming-criteria">table naming criteria</a>. If present, no results are returned in the response. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#adee083994f1ffeddf092c7cb1d4cf951">aggregate\_unpivot\_result\_table\_persist</a>: If <a href="/content/api/cpp/namespacegpudb#a33167760257feb5d179403462f3ae254">true</a>, then the result table specified in <a href="/content/api/cpp/namespacegpudb#a387e724aa5d35a6e0adca724661df1e1">result\_table</a> will be persisted and will not expire unless a <a href="/content/api/cpp/namespacegpudb#a0c375406608938d35ce6250306b47635">ttl</a> is specified. If <a href="/content/api/cpp/namespacegpudb#a0c9aac1cb76ab97b113672060d6b2878">false</a>, then the result table will be an in-memory table and will expire unless a <a href="/content/api/cpp/namespacegpudb#a0c375406608938d35ce6250306b47635">ttl</a> is specified otherwise. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a33167760257feb5d179403462f3ae254">aggregate\_unpivot\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a0c9aac1cb76ab97b113672060d6b2878">aggregate\_unpivot\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a0c9aac1cb76ab97b113672060d6b2878">aggregate\_unpivot\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a498ee2118f20a8fbbab465782086a2f1">aggregate\_unpivot\_expression</a>: Filter expression to apply to the table prior to unpivot processing. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a337de7431bbf0e74372f0b534adde685">aggregate\_unpivot\_order\_by</a>: Comma-separated list of the columns to be sorted by; e.g. 'timestamp asc, x desc'. The columns specified must be present in input table. If any alias is given for any column name, the alias must be used, rather than the original column name. The default value is ''. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#acb6790d339de47ea7409b225e5101a6b">aggregate\_unpivot\_chunk\_size</a>: Indicates the number of records per chunk to be used for the result table. Must be used in combination with the <a href="/content/api/cpp/namespacegpudb#a387e724aa5d35a6e0adca724661df1e1">result\_table</a> option. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aefa72e874c4d54373d570e974587ac8a">aggregate\_unpivot\_chunk\_column\_max\_memory</a>: Indicates the target maximum data size for each column in a chunk to be used for the result table. Must be used in combination with the <a href="/content/api/cpp/namespacegpudb#a387e724aa5d35a6e0adca724661df1e1">result\_table</a> option. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a8d4045fa5de1e02c5bdce48da1e9a7eb">aggregate\_unpivot\_chunk\_max\_memory</a>: Indicates the target maximum data size for all columns in a chunk to be used for the result table. Must be used in combination with the <a href="/content/api/cpp/namespacegpudb#a387e724aa5d35a6e0adca724661df1e1">result\_table</a> option. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a5a4adc837fd9ad3da04aa2f13fcccaf0">aggregate\_unpivot\_compression\_codec</a>: The default <a href="/content/concepts/column_compression/">compression codec</a> for the result table's columns. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ad620c09d7215ea88cc1599699376274c">aggregate\_unpivot\_limit</a>: The number of records to keep. The default value is ''. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a0c375406608938d35ce6250306b47635">aggregate\_unpivot\_ttl</a>: Sets the <a href="/content/concepts/ttl/">TTL</a> of the table specified in <a href="/content/api/cpp/namespacegpudb#a387e724aa5d35a6e0adca724661df1e1">result\_table</a>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a411eff5faa3bfdfb9bc9b529d4af7fbd">aggregate\_unpivot\_view\_id</a>: View this result table is part of. The default value is ''. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a653d0f030e3d8bbab9fee5024170abe9">aggregate\_unpivot\_create\_indexes</a>: Comma-separated list of columns on which to create indexes on the table specified in <a href="/content/api/cpp/namespacegpudb#a387e724aa5d35a6e0adca724661df1e1">result\_table</a>. The columns specified must be present in output column names. If any alias is given for any column name, the alias must be used, rather than the original column name. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a539c77b9d83b3d45c151d98bf08058e9">aggregate\_unpivot\_result\_table\_force\_replicated</a>: Force the result table to be replicated (ignores any sharding). Must be used in combination with the <a href="/content/api/cpp/namespacegpudb#a387e724aa5d35a6e0adca724661df1e1">result\_table</a> option. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a33167760257feb5d179403462f3ae254">aggregate\_unpivot\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a0c9aac1cb76ab97b113672060d6b2878">aggregate\_unpivot\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a0c9aac1cb76ab97b113672060d6b2878">aggregate\_unpivot\_false</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AggregateUnpivotResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#aa11b6bb15992bc255b391433441d5f40">◆ </a></span>aggregateUnpivot() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AggregateUnpivotResponse">AggregateUnpivotResponse</a> & gpudb::GPUdb::aggregateUnpivot </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< std::string > &</td>
            <td><span><span>columnNames</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>variableColumnName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>valueColumnName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< std::string > &</td>
            <td><span><span>pivotedColumns</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1AggregateUnpivotResponse">AggregateUnpivotResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Rotate the column values into rows values. </p>
        <p>For unpivot details and examples, see <a href="/content/concepts/unpivot/">Unpivot</a>. For limitations, see <a href="/content/concepts/unpivot/#limitations">Unpivot Limitations</a>.</p>
        <p>Unpivot is used to normalize tables that are built for cross tabular reporting purposes. The unpivot operator rotates the column values for all the pivoted columns. A variable column, value column and all columns from the source table except the unpivot columns are projected into the result table. The variable column and value columns in the result table indicate the pivoted column name and values respectively.</p>
        <p>The response is returned as a dynamic schema. For details see: <a href="/content/api/concepts/#dynamic-schemas">dynamic schemas documentation</a>.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of the table on which the operation will be performed. Must be an existing table/view, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>columnNames</td>
                <td>List of column names or expressions. A wildcard '\*' can be used to include all the non-pivoted columns from the source table. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>variableColumnName</td>
                <td>Specifies the variable/parameter column name. The default value is ''. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>valueColumnName</td>
                <td>Specifies the value column name. The default value is ''. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>pivotedColumns</td>
                <td>List of one or more values typically the column names of the input table. All the columns in the source table must have the same data type. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a2036bf8f1a4ffcadddddeac02a04bc1a">aggregate\_unpivot\_create\_temp\_table</a>: If <a href="/content/api/cpp/namespacegpudb#a33167760257feb5d179403462f3ae254">true</a>, a unique temporary table name will be generated in the sys\_temp schema and used in place of <a href="/content/api/cpp/namespacegpudb#a387e724aa5d35a6e0adca724661df1e1">result\_table</a>. If <a href="/content/api/cpp/namespacegpudb#adee083994f1ffeddf092c7cb1d4cf951">result\_table\_persist</a> is <a href="/content/api/cpp/namespacegpudb#a0c9aac1cb76ab97b113672060d6b2878">false</a> (or unspecified), then this is always allowed even if the caller does not have permission to create tables. The generated name is returned in <a href="/content/api/cpp/namespacegpudb#a1438d7ecedcae6aa9bf9479f474c697f">qualified\_result\_table\_name</a>. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a33167760257feb5d179403462f3ae254">aggregate\_unpivot\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a0c9aac1cb76ab97b113672060d6b2878">aggregate\_unpivot\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a0c9aac1cb76ab97b113672060d6b2878">aggregate\_unpivot\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a6f04037712699777d16c32ee4970aa63">aggregate\_unpivot\_collection\_name</a>: \[DEPRECATED–please specify the containing schema as part of <a href="/content/api/cpp/namespacegpudb#a387e724aa5d35a6e0adca724661df1e1">result\_table</a> and use <a href="#a33d9a0a8e738d14b688f9f869f9640ad">createSchema</a> to create the schema if non-existent] Name of a schema which is to contain the table specified in <a href="/content/api/cpp/namespacegpudb#a387e724aa5d35a6e0adca724661df1e1">result\_table</a>. If the schema is non-existent, it will be automatically created. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a387e724aa5d35a6e0adca724661df1e1">aggregate\_unpivot\_result\_table</a>: The name of a table used to store the results, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a> and meeting <a href="/content/concepts/tables/#table-naming-criteria">table naming criteria</a>. If present, no results are returned in the response. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#adee083994f1ffeddf092c7cb1d4cf951">aggregate\_unpivot\_result\_table\_persist</a>: If <a href="/content/api/cpp/namespacegpudb#a33167760257feb5d179403462f3ae254">true</a>, then the result table specified in <a href="/content/api/cpp/namespacegpudb#a387e724aa5d35a6e0adca724661df1e1">result\_table</a> will be persisted and will not expire unless a <a href="/content/api/cpp/namespacegpudb#a0c375406608938d35ce6250306b47635">ttl</a> is specified. If <a href="/content/api/cpp/namespacegpudb#a0c9aac1cb76ab97b113672060d6b2878">false</a>, then the result table will be an in-memory table and will expire unless a <a href="/content/api/cpp/namespacegpudb#a0c375406608938d35ce6250306b47635">ttl</a> is specified otherwise. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a33167760257feb5d179403462f3ae254">aggregate\_unpivot\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a0c9aac1cb76ab97b113672060d6b2878">aggregate\_unpivot\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a0c9aac1cb76ab97b113672060d6b2878">aggregate\_unpivot\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a498ee2118f20a8fbbab465782086a2f1">aggregate\_unpivot\_expression</a>: Filter expression to apply to the table prior to unpivot processing. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a337de7431bbf0e74372f0b534adde685">aggregate\_unpivot\_order\_by</a>: Comma-separated list of the columns to be sorted by; e.g. 'timestamp asc, x desc'. The columns specified must be present in input table. If any alias is given for any column name, the alias must be used, rather than the original column name. The default value is ''. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#acb6790d339de47ea7409b225e5101a6b">aggregate\_unpivot\_chunk\_size</a>: Indicates the number of records per chunk to be used for the result table. Must be used in combination with the <a href="/content/api/cpp/namespacegpudb#a387e724aa5d35a6e0adca724661df1e1">result\_table</a> option. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aefa72e874c4d54373d570e974587ac8a">aggregate\_unpivot\_chunk\_column\_max\_memory</a>: Indicates the target maximum data size for each column in a chunk to be used for the result table. Must be used in combination with the <a href="/content/api/cpp/namespacegpudb#a387e724aa5d35a6e0adca724661df1e1">result\_table</a> option. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a8d4045fa5de1e02c5bdce48da1e9a7eb">aggregate\_unpivot\_chunk\_max\_memory</a>: Indicates the target maximum data size for all columns in a chunk to be used for the result table. Must be used in combination with the <a href="/content/api/cpp/namespacegpudb#a387e724aa5d35a6e0adca724661df1e1">result\_table</a> option. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a5a4adc837fd9ad3da04aa2f13fcccaf0">aggregate\_unpivot\_compression\_codec</a>: The default <a href="/content/concepts/column_compression/">compression codec</a> for the result table's columns. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ad620c09d7215ea88cc1599699376274c">aggregate\_unpivot\_limit</a>: The number of records to keep. The default value is ''. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a0c375406608938d35ce6250306b47635">aggregate\_unpivot\_ttl</a>: Sets the <a href="/content/concepts/ttl/">TTL</a> of the table specified in <a href="/content/api/cpp/namespacegpudb#a387e724aa5d35a6e0adca724661df1e1">result\_table</a>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a411eff5faa3bfdfb9bc9b529d4af7fbd">aggregate\_unpivot\_view\_id</a>: View this result table is part of. The default value is ''. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a653d0f030e3d8bbab9fee5024170abe9">aggregate\_unpivot\_create\_indexes</a>: Comma-separated list of columns on which to create indexes on the table specified in <a href="/content/api/cpp/namespacegpudb#a387e724aa5d35a6e0adca724661df1e1">result\_table</a>. The columns specified must be present in output column names. If any alias is given for any column name, the alias must be used, rather than the original column name. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a539c77b9d83b3d45c151d98bf08058e9">aggregate\_unpivot\_result\_table\_force\_replicated</a>: Force the result table to be replicated (ignores any sharding). Must be used in combination with the <a href="/content/api/cpp/namespacegpudb#a387e724aa5d35a6e0adca724661df1e1">result\_table</a> option. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a33167760257feb5d179403462f3ae254">aggregate\_unpivot\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a0c9aac1cb76ab97b113672060d6b2878">aggregate\_unpivot\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a0c9aac1cb76ab97b113672060d6b2878">aggregate\_unpivot\_false</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AggregateUnpivotResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AggregateUnpivotResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a147bb1df6e7e6a862c49f148642bde3b">◆ </a></span>aggregateUnpivotRaw() <span>\[1/2]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1RawAggregateUnpivotResponse">RawAggregateUnpivotResponse</a> gpudb::GPUdb::aggregateUnpivotRaw </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1AggregateUnpivotRequest">AggregateUnpivotRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Rotate the column values into rows values. </p>
        <p>For unpivot details and examples, see <a href="/content/concepts/unpivot/">Unpivot</a>. For limitations, see <a href="/content/concepts/unpivot/#limitations">Unpivot Limitations</a>.</p>
        <p>Unpivot is used to normalize tables that are built for cross tabular reporting purposes. The unpivot operator rotates the column values for all the pivoted columns. A variable column, value column and all columns from the source table except the unpivot columns are projected into the result table. The variable column and value columns in the result table indicate the pivoted column name and values respectively.</p>
        <p>The response is returned as a dynamic schema. For details see: <a href="/content/api/concepts/#dynamic-schemas">dynamic schemas documentation</a>.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AggregateUnpivotRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1RawAggregateUnpivotResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ac1b8c35f677977449dee7e9d7361c1b1">◆ </a></span>aggregateUnpivotRaw() <span>\[2/2]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1RawAggregateUnpivotResponse">RawAggregateUnpivotResponse</a> & gpudb::GPUdb::aggregateUnpivotRaw </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1AggregateUnpivotRequest">AggregateUnpivotRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1RawAggregateUnpivotResponse">RawAggregateUnpivotResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Rotate the column values into rows values. </p>
        <p>For unpivot details and examples, see <a href="/content/concepts/unpivot/">Unpivot</a>. For limitations, see <a href="/content/concepts/unpivot/#limitations">Unpivot Limitations</a>.</p>
        <p>Unpivot is used to normalize tables that are built for cross tabular reporting purposes. The unpivot operator rotates the column values for all the pivoted columns. A variable column, value column and all columns from the source table except the unpivot columns are projected into the result table. The variable column and value columns in the result table indicate the pivoted column name and values respectively.</p>
        <p>The response is returned as a dynamic schema. For details see: <a href="/content/api/concepts/#dynamic-schemas">dynamic schemas documentation</a>.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AggregateUnpivotRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1RawAggregateUnpivotResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1RawAggregateUnpivotResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a0d261d4f3dab25f405d4c23d98957d50">◆ </a></span>alterBackup() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AlterBackupResponse">AlterBackupResponse</a> gpudb::GPUdb::alterBackup </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1AlterBackupRequest">AlterBackupRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Alters an existing database <a href="/content/admin/backup_restore/#database-backup">backup</a>, accessible via the <a href="/content/concepts/data_sinks/">data sink</a> specified by <a href="/content/api/cpp/structgpudb_1_1AlterBackupRequest#afb40c34397bdfd1b9fd1cbba27a85ef0">datasinkName</a>. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AlterBackupRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AlterBackupResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a1f41e6f7246ec165a78018ebc4e14bb1">◆ </a></span>alterBackup() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AlterBackupResponse">AlterBackupResponse</a> & gpudb::GPUdb::alterBackup </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1AlterBackupRequest">AlterBackupRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1AlterBackupResponse">AlterBackupResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Alters an existing database <a href="/content/admin/backup_restore/#database-backup">backup</a>, accessible via the <a href="/content/concepts/data_sinks/">data sink</a> specified by <a href="/content/api/cpp/structgpudb_1_1AlterBackupRequest#afb40c34397bdfd1b9fd1cbba27a85ef0">datasinkName</a>. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AlterBackupRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AlterBackupResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AlterBackupResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a8d54f289d7c4c7630c3bf7d582a3473c">◆ </a></span>alterBackup() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AlterBackupResponse">AlterBackupResponse</a> gpudb::GPUdb::alterBackup </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>backupName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>action</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>value</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>datasinkName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Alters an existing database <a href="/content/admin/backup_restore/#database-backup">backup</a>, accessible via the <a href="/content/concepts/data_sinks/">data sink</a> specified by <span>datasinkName</span>. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>backupName</td>
                <td>Name of the backup to be altered. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>action</td>

                <td>
                  Operation to be applied. Supported values:

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a0603d48ca575ca53ce3195abe3de6228">alter\_backup\_checksum</a>: Calculate checksum for backed-up files. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ae63a14fc4ac33f9599d4a73f1985a42c">alter\_backup\_ddl\_only</a>: Whether or not to only save DDL and not back up table data, when taking future snapshots; set <span>value</span> to 'true' or 'false' for DDL only or DDL and table data, respectively. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a63fbf7a1a9547096545c61f48f905e2c">alter\_backup\_max\_incremental\_backups\_to\_keep</a>: Maximum number of incremental snapshots to keep, when taking future snapshots; set <span>value</span> to the number of snapshots to keep. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ae7a5dac180ab97cdc5f9906eb607bd68">alter\_backup\_merge</a>: Merges all snapshots within a backup and creates a single full snapshot. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a36d42509e69f99d17e52c76fa2cb9e17">alter\_backup\_purge</a>: Deletes a snapshot from a backup; set <span>value</span> to the snapshot ID to purge. </li>
                  </ul>
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>value</td>
                <td>Value of the modification, depending on <span>action</span>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>datasinkName</td>
                <td>Data sink through which the backup is accessible. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a05ceddc176637e5a40f2da39892827ed">alter\_backup\_comment</a>: Comments to store with the backup. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a662eb7205d50dc6af0c9485ae24421be">alter\_backup\_dry\_run</a>: Whether or not to perform a dry run of a backup alteration. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#aadac6be158dcb8ba69a9743892b1d1ba">alter\_backup\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aab7544d67c85c8c4dfaf0aaf202856b1">alter\_backup\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#aab7544d67c85c8c4dfaf0aaf202856b1">alter\_backup\_false</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AlterBackupResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#aac2057974412bc4ecd18b7d997dfddec">◆ </a></span>alterBackup() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AlterBackupResponse">AlterBackupResponse</a> & gpudb::GPUdb::alterBackup </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>backupName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>action</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>value</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>datasinkName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1AlterBackupResponse">AlterBackupResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Alters an existing database <a href="/content/admin/backup_restore/#database-backup">backup</a>, accessible via the <a href="/content/concepts/data_sinks/">data sink</a> specified by <span>datasinkName</span>. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>backupName</td>
                <td>Name of the backup to be altered. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>action</td>

                <td>
                  Operation to be applied. Supported values:

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a0603d48ca575ca53ce3195abe3de6228">alter\_backup\_checksum</a>: Calculate checksum for backed-up files. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ae63a14fc4ac33f9599d4a73f1985a42c">alter\_backup\_ddl\_only</a>: Whether or not to only save DDL and not back up table data, when taking future snapshots; set <span>value</span> to 'true' or 'false' for DDL only or DDL and table data, respectively. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a63fbf7a1a9547096545c61f48f905e2c">alter\_backup\_max\_incremental\_backups\_to\_keep</a>: Maximum number of incremental snapshots to keep, when taking future snapshots; set <span>value</span> to the number of snapshots to keep. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ae7a5dac180ab97cdc5f9906eb607bd68">alter\_backup\_merge</a>: Merges all snapshots within a backup and creates a single full snapshot. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a36d42509e69f99d17e52c76fa2cb9e17">alter\_backup\_purge</a>: Deletes a snapshot from a backup; set <span>value</span> to the snapshot ID to purge. </li>
                  </ul>
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>value</td>
                <td>Value of the modification, depending on <span>action</span>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>datasinkName</td>
                <td>Data sink through which the backup is accessible. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a05ceddc176637e5a40f2da39892827ed">alter\_backup\_comment</a>: Comments to store with the backup. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a662eb7205d50dc6af0c9485ae24421be">alter\_backup\_dry\_run</a>: Whether or not to perform a dry run of a backup alteration. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#aadac6be158dcb8ba69a9743892b1d1ba">alter\_backup\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aab7544d67c85c8c4dfaf0aaf202856b1">alter\_backup\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#aab7544d67c85c8c4dfaf0aaf202856b1">alter\_backup\_false</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AlterBackupResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AlterBackupResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a19066a22f5900356bc3548de446d3479">◆ </a></span>alterCredential() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AlterCredentialResponse">AlterCredentialResponse</a> gpudb::GPUdb::alterCredential </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1AlterCredentialRequest">AlterCredentialRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Alter the properties of an existing <a href="/content/concepts/credentials/">credential</a>. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AlterCredentialRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AlterCredentialResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ad9f46493013dfadf7407f4eb354c2471">◆ </a></span>alterCredential() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AlterCredentialResponse">AlterCredentialResponse</a> & gpudb::GPUdb::alterCredential </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1AlterCredentialRequest">AlterCredentialRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1AlterCredentialResponse">AlterCredentialResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Alter the properties of an existing <a href="/content/concepts/credentials/">credential</a>. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AlterCredentialRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AlterCredentialResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AlterCredentialResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#adaa26ea985ede026372964285b8db9dc">◆ </a></span>alterCredential() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AlterCredentialResponse">AlterCredentialResponse</a> gpudb::GPUdb::alterCredential </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>credentialName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>credentialUpdatesMap</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Alter the properties of an existing <a href="/content/concepts/credentials/">credential</a>. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>credentialName</td>
                <td>Name of the credential to be altered. Must be an existing credential. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>credentialUpdatesMap</td>

                <td>
                  Map containing the properties of the credential to be updated. Error if empty.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#acbe58f4fbab362cc8dd4dc7b8ac626e4">alter\_credential\_type</a>: New type for the credential. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ae67665ea5874ca7df26c5680efe4000c">alter\_credential\_aws\_access\_key</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ab67b8cae15ecf35bb8b2fa65317e1a22">alter\_credential\_aws\_iam\_role</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aebc258c34bf76a0e4be4b61b2440d666">alter\_credential\_azure\_ad</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aaa61269bb8fd21c529a03d88e3a5ac29">alter\_credential\_azure\_oauth</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a1508ac782c4bd1df830ee4cf9aa8290b">alter\_credential\_azure\_sas</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aba09141c1f9dd528dbfb72354b0c29a6">alter\_credential\_azure\_storage\_key</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#af7eeef1e95b631e703b20e3820dd2b63">alter\_credential\_docker</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aa5e72fbc6fb943c44ab3adb277e65571">alter\_credential\_gcs\_service\_account\_id</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ab02740e0e0b5476b34d5417721dd8d34">alter\_credential\_gcs\_service\_account\_keys</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a04eedf0337df007b400a5fe1e6ce09bf">alter\_credential\_hdfs</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a24e6eb6993d62427e64566f75a3995d4">alter\_credential\_kafka</a> </li>
                      </ul>
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#ac5f5b53121bae47344de94dc9ff9d5ea">alter\_credential\_identity</a>: New user for the credential. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a4b27737f5ba83040a2fe706038113112">alter\_credential\_secret</a>: New password for the credential. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a0d660e03d2141d2dafeeba4f825f99e5">alter\_credential\_schema\_name</a>: Updates the schema name. If <a href="/content/api/cpp/namespacegpudb#a0d660e03d2141d2dafeeba4f825f99e5">schema\_name</a> doesn't exist, an error will be thrown. If <a href="/content/api/cpp/namespacegpudb#a0d660e03d2141d2dafeeba4f825f99e5">schema\_name</a> is empty, then the user's default schema will be used. </li>
                  </ul>
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AlterCredentialResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ab10b0b8b3f630025364dba27f0f565ba">◆ </a></span>alterCredential() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AlterCredentialResponse">AlterCredentialResponse</a> & gpudb::GPUdb::alterCredential </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>credentialName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>credentialUpdatesMap</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1AlterCredentialResponse">AlterCredentialResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Alter the properties of an existing <a href="/content/concepts/credentials/">credential</a>. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>credentialName</td>
                <td>Name of the credential to be altered. Must be an existing credential. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>credentialUpdatesMap</td>

                <td>
                  Map containing the properties of the credential to be updated. Error if empty.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#acbe58f4fbab362cc8dd4dc7b8ac626e4">alter\_credential\_type</a>: New type for the credential. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ae67665ea5874ca7df26c5680efe4000c">alter\_credential\_aws\_access\_key</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ab67b8cae15ecf35bb8b2fa65317e1a22">alter\_credential\_aws\_iam\_role</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aebc258c34bf76a0e4be4b61b2440d666">alter\_credential\_azure\_ad</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aaa61269bb8fd21c529a03d88e3a5ac29">alter\_credential\_azure\_oauth</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a1508ac782c4bd1df830ee4cf9aa8290b">alter\_credential\_azure\_sas</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aba09141c1f9dd528dbfb72354b0c29a6">alter\_credential\_azure\_storage\_key</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#af7eeef1e95b631e703b20e3820dd2b63">alter\_credential\_docker</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aa5e72fbc6fb943c44ab3adb277e65571">alter\_credential\_gcs\_service\_account\_id</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ab02740e0e0b5476b34d5417721dd8d34">alter\_credential\_gcs\_service\_account\_keys</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a04eedf0337df007b400a5fe1e6ce09bf">alter\_credential\_hdfs</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a24e6eb6993d62427e64566f75a3995d4">alter\_credential\_kafka</a> </li>
                      </ul>
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#ac5f5b53121bae47344de94dc9ff9d5ea">alter\_credential\_identity</a>: New user for the credential. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a4b27737f5ba83040a2fe706038113112">alter\_credential\_secret</a>: New password for the credential. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a0d660e03d2141d2dafeeba4f825f99e5">alter\_credential\_schema\_name</a>: Updates the schema name. If <a href="/content/api/cpp/namespacegpudb#a0d660e03d2141d2dafeeba4f825f99e5">schema\_name</a> doesn't exist, an error will be thrown. If <a href="/content/api/cpp/namespacegpudb#a0d660e03d2141d2dafeeba4f825f99e5">schema\_name</a> is empty, then the user's default schema will be used. </li>
                  </ul>
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AlterCredentialResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AlterCredentialResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#aa7b2ae37561ffd0675a2ec5d18b6e5ce">◆ </a></span>alterDatasink() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AlterDatasinkResponse">AlterDatasinkResponse</a> gpudb::GPUdb::alterDatasink </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1AlterDatasinkRequest">AlterDatasinkRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Alters the properties of an existing <a href="/content/concepts/data_sinks/">data sink</a>. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AlterDatasinkRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AlterDatasinkResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a52113bd44be00a37c4d3b09e48fb4216">◆ </a></span>alterDatasink() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AlterDatasinkResponse">AlterDatasinkResponse</a> & gpudb::GPUdb::alterDatasink </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1AlterDatasinkRequest">AlterDatasinkRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1AlterDatasinkResponse">AlterDatasinkResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Alters the properties of an existing <a href="/content/concepts/data_sinks/">data sink</a>. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AlterDatasinkRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AlterDatasinkResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AlterDatasinkResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a8bbff72646e20ac38334c69ec48fe439">◆ </a></span>alterDatasink() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AlterDatasinkResponse">AlterDatasinkResponse</a> gpudb::GPUdb::alterDatasink </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>datasinkUpdatesMap</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Alters the properties of an existing <a href="/content/concepts/data_sinks/">data sink</a>. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>name</td>
                <td>Name of the data sink to be altered. Must be an existing data sink. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>datasinkUpdatesMap</td>

                <td>
                  Map containing the properties of the data sink to be updated. Error if empty.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a4a0d104c0178c4b56f7b03995f058fb1">alter\_datasink\_destination</a>: Destination for the output data in format 'destination\_type://path\[:port]'. Supported destination types are 'azure', 'gcs', 'hdfs', 'http', 'https', 'jdbc', 'kafka', and 's3'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a6a43e5c70a4c21da60ffe78da948329a">alter\_datasink\_connection\_timeout</a>: Timeout in seconds for connecting to this sink. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a3eb2340f0817eec3552c34e557dfeb12">alter\_datasink\_wait\_timeout</a>: Timeout in seconds for waiting for a response from this sink. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a7bd38a886837904caaa90b1446124fc0">alter\_datasink\_credential</a>: Name of the <a href="/content/concepts/credentials/">credential</a> object to be used in this data sink. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a8b092f302ce0ea59d53580f5947b1628">alter\_datasink\_s3\_bucket\_name</a>: Name of the Amazon S3 bucket to use as the data sink. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ac11298cb08ca616f27aaac0cc34bb161">alter\_datasink\_s3\_region</a>: Name of the Amazon S3 region where the given bucket is located. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a30e5b754c8a2df5f6969ef041ab1db3b">alter\_datasink\_s3\_verify\_ssl</a>: Whether to verify SSL connections. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#aa5cf0f71ea6d896d2d85adae7bba2487">alter\_datasink\_true</a>: Connect with SSL verification. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a6aeccac0ebf48fc56991c2a65a3b2272">alter\_datasink\_false</a>: Connect without verifying the SSL connection; for testing purposes, bypassing TLS errors, self-signed certificates, etc. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#aa5cf0f71ea6d896d2d85adae7bba2487">alter\_datasink\_true</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a1db4f002d25d102b7ba31935c2e45d48">alter\_datasink\_s3\_use\_virtual\_addressing</a>: Whether to use virtual addressing when referencing the Amazon S3 sink. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#aa5cf0f71ea6d896d2d85adae7bba2487">alter\_datasink\_true</a>: The requests URI should be specified in virtual-hosted-style format where the bucket name is part of the domain name in the URL. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a6aeccac0ebf48fc56991c2a65a3b2272">alter\_datasink\_false</a>: Use path-style URI for requests. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#aa5cf0f71ea6d896d2d85adae7bba2487">alter\_datasink\_true</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a69dfac31dca1748eb94404a31da12f47">alter\_datasink\_s3\_aws\_role\_arn</a>: Amazon IAM Role ARN which has required S3 permissions that can be assumed for the given S3 IAM user. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ab798fd48f8b77e996c4a4c65d2967395">alter\_datasink\_s3\_encryption\_customer\_algorithm</a>: Customer encryption algorithm used encrypting data. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a25c46b801c402251cfaaafd65a798955">alter\_datasink\_s3\_encryption\_customer\_key</a>: Customer encryption key to encrypt or decrypt data. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a17b6839e447e0153fcb835a03f079a4e">alter\_datasink\_s3\_encryption\_type</a>: Server side encryption type. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a3b645c8952af2ec7f0be514075b858a0">alter\_datasink\_s3\_kms\_key\_id</a>: KMS key. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a4565916d715519b80e8918e06ab4d373">alter\_datasink\_hdfs\_kerberos\_keytab</a>: Kerberos keytab file location for the given HDFS user. This may be a KIFS file. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a9f22437c6abe08f43700ae4b148cbebd">alter\_datasink\_hdfs\_delegation\_token</a>: Delegation token for the given HDFS user. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ac7a8e19d121c1a415041107304ccac70">alter\_datasink\_hdfs\_use\_kerberos</a>: Use kerberos authentication for the given HDFS cluster. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#aa5cf0f71ea6d896d2d85adae7bba2487">alter\_datasink\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a6aeccac0ebf48fc56991c2a65a3b2272">alter\_datasink\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a6aeccac0ebf48fc56991c2a65a3b2272">alter\_datasink\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a6fc43867972e58f8ba547343cd9fac94">alter\_datasink\_azure\_storage\_account\_name</a>: Name of the Azure storage account to use as the data sink, this is valid only if tenant\_id is specified. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ab0311625dc87be79ee115bf3971939e6">alter\_datasink\_azure\_container\_name</a>: Name of the Azure storage container to use as the data sink. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a66c75cbec45f62b2eca99ef4fad4dbb7">alter\_datasink\_azure\_tenant\_id</a>: Active Directory tenant ID (or directory ID). </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#abee3c93f7c05c0b61557988422b3d9f2">alter\_datasink\_azure\_sas\_token</a>: Shared access signature token for Azure storage account to use as the data sink. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a12cee8b842b07e7805c3dbc9a0fdd89f">alter\_datasink\_azure\_oauth\_token</a>: OAuth token to access given storage container. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ab443a3dc0af9f6fa60053afe22d1ac91">alter\_datasink\_azure\_use\_virtual\_addressing</a>: Whether to use virtual addressing when referencing the Azure source. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#aa5cf0f71ea6d896d2d85adae7bba2487">alter\_datasink\_true</a>: The requests URI should be specified in virtual-hosted-style format where the bucket name is part of the domain name in the URL. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a6aeccac0ebf48fc56991c2a65a3b2272">alter\_datasink\_false</a>: Use path-style URI for requests. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#aa5cf0f71ea6d896d2d85adae7bba2487">alter\_datasink\_true</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#adbac9d3d999f61393b3cfe6671c00a9b">alter\_datasink\_gcs\_bucket\_name</a>: Name of the Google Cloud Storage bucket to use as the data sink. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aea3fe0340868c921a707b8e38cae696e">alter\_datasink\_gcs\_project\_id</a>: Name of the Google Cloud project to use as the data sink. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ac804cc8c2ff3ff5510482e68db86c6ab">alter\_datasink\_gcs\_service\_account\_keys</a>: Google Cloud service account keys to use for authenticating the data sink. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a99bc70e8ab904940587d65c009c3346c">alter\_datasink\_jdbc\_driver\_jar\_path</a>: JDBC driver jar file location. This may be a KIFS file. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#afffd05e87de3f0f5c3a1e733d251a70f">alter\_datasink\_jdbc\_driver\_class\_name</a>: Name of the JDBC driver class. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a952726ddeca5a96def745416a2e0696f">alter\_datasink\_kafka\_url</a>: The publicly-accessible full path URL to the kafka broker, e.g., '<a href="http://172.123.45.67:9300'">[http://172.123.45.67:9300](http://172.123.45.67:9300)'</a>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ad9c0af60634ffc3e998b04a9a0b03f74">alter\_datasink\_kafka\_topic\_name</a>: Name of the Kafka topic to use for this data sink, if it references a Kafka broker. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a91c2f8678b82b9bd3e44597a7f602d12">alter\_datasink\_anonymous</a>: Create an anonymous connection to the storage provider–DEPRECATED: this is now the default. Specify use\_managed\_credentials for non-anonymous connection. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#aa5cf0f71ea6d896d2d85adae7bba2487">alter\_datasink\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a6aeccac0ebf48fc56991c2a65a3b2272">alter\_datasink\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#aa5cf0f71ea6d896d2d85adae7bba2487">alter\_datasink\_true</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#aa928649c126abfc1a446e0a8a426dead">alter\_datasink\_use\_managed\_credentials</a>: When no credentials are supplied, we use anonymous access by default. If this is set, we will use cloud provider user settings. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#aa5cf0f71ea6d896d2d85adae7bba2487">alter\_datasink\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a6aeccac0ebf48fc56991c2a65a3b2272">alter\_datasink\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a6aeccac0ebf48fc56991c2a65a3b2272">alter\_datasink\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a92c588a54be469b8969e0e52568c6839">alter\_datasink\_use\_https</a>: Use HTTPS to connect to datasink if true, otherwise use HTTP. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#aa5cf0f71ea6d896d2d85adae7bba2487">alter\_datasink\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a6aeccac0ebf48fc56991c2a65a3b2272">alter\_datasink\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#aa5cf0f71ea6d896d2d85adae7bba2487">alter\_datasink\_true</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#ad6145d07105197fae52c8fc87bc8f1b4">alter\_datasink\_max\_batch\_size</a>: Maximum number of records per notification message. The default value is '1'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a529332811f765c8339ede1f81d360b27">alter\_datasink\_max\_message\_size</a>: Maximum size in bytes of each notification message. The default value is '1000000'. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a86f0b3cd992b783cf34fa1998d4ffe18">alter\_datasink\_json\_format</a>: The desired format of JSON encoded notifications message. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a6a7dee0a0304a051b5626c46aee04dfc">alter\_datasink\_flat</a>: A single record is returned per message. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aa1bf7eaedcaa8ed4f98abd100afd30e1">alter\_datasink\_nested</a>: Records are returned as an array per message. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a6a7dee0a0304a051b5626c46aee04dfc">alter\_datasink\_flat</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a8d331eabb1eaa0d017e2dc8c7a61764f">alter\_datasink\_skip\_validation</a>: Bypass validation of connection to this data sink. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#aa5cf0f71ea6d896d2d85adae7bba2487">alter\_datasink\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a6aeccac0ebf48fc56991c2a65a3b2272">alter\_datasink\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a6aeccac0ebf48fc56991c2a65a3b2272">alter\_datasink\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#acd037aa58526d85bd5133adc55350362">alter\_datasink\_schema\_name</a>: Updates the schema name. If <a href="/content/api/cpp/namespacegpudb#acd037aa58526d85bd5133adc55350362">schema\_name</a> doesn't exist, an error will be thrown. If <a href="/content/api/cpp/namespacegpudb#acd037aa58526d85bd5133adc55350362">schema\_name</a> is empty, then the user's default schema will be used. </li>
                  </ul>
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AlterDatasinkResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#aa2db6301075d7952d4dc8d26846ac6fb">◆ </a></span>alterDatasink() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AlterDatasinkResponse">AlterDatasinkResponse</a> & gpudb::GPUdb::alterDatasink </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>datasinkUpdatesMap</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1AlterDatasinkResponse">AlterDatasinkResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Alters the properties of an existing <a href="/content/concepts/data_sinks/">data sink</a>. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>name</td>
                <td>Name of the data sink to be altered. Must be an existing data sink. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>datasinkUpdatesMap</td>

                <td>
                  Map containing the properties of the data sink to be updated. Error if empty.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a4a0d104c0178c4b56f7b03995f058fb1">alter\_datasink\_destination</a>: Destination for the output data in format 'destination\_type://path\[:port]'. Supported destination types are 'azure', 'gcs', 'hdfs', 'http', 'https', 'jdbc', 'kafka', and 's3'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a6a43e5c70a4c21da60ffe78da948329a">alter\_datasink\_connection\_timeout</a>: Timeout in seconds for connecting to this sink. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a3eb2340f0817eec3552c34e557dfeb12">alter\_datasink\_wait\_timeout</a>: Timeout in seconds for waiting for a response from this sink. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a7bd38a886837904caaa90b1446124fc0">alter\_datasink\_credential</a>: Name of the <a href="/content/concepts/credentials/">credential</a> object to be used in this data sink. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a8b092f302ce0ea59d53580f5947b1628">alter\_datasink\_s3\_bucket\_name</a>: Name of the Amazon S3 bucket to use as the data sink. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ac11298cb08ca616f27aaac0cc34bb161">alter\_datasink\_s3\_region</a>: Name of the Amazon S3 region where the given bucket is located. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a30e5b754c8a2df5f6969ef041ab1db3b">alter\_datasink\_s3\_verify\_ssl</a>: Whether to verify SSL connections. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#aa5cf0f71ea6d896d2d85adae7bba2487">alter\_datasink\_true</a>: Connect with SSL verification. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a6aeccac0ebf48fc56991c2a65a3b2272">alter\_datasink\_false</a>: Connect without verifying the SSL connection; for testing purposes, bypassing TLS errors, self-signed certificates, etc. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#aa5cf0f71ea6d896d2d85adae7bba2487">alter\_datasink\_true</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a1db4f002d25d102b7ba31935c2e45d48">alter\_datasink\_s3\_use\_virtual\_addressing</a>: Whether to use virtual addressing when referencing the Amazon S3 sink. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#aa5cf0f71ea6d896d2d85adae7bba2487">alter\_datasink\_true</a>: The requests URI should be specified in virtual-hosted-style format where the bucket name is part of the domain name in the URL. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a6aeccac0ebf48fc56991c2a65a3b2272">alter\_datasink\_false</a>: Use path-style URI for requests. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#aa5cf0f71ea6d896d2d85adae7bba2487">alter\_datasink\_true</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a69dfac31dca1748eb94404a31da12f47">alter\_datasink\_s3\_aws\_role\_arn</a>: Amazon IAM Role ARN which has required S3 permissions that can be assumed for the given S3 IAM user. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ab798fd48f8b77e996c4a4c65d2967395">alter\_datasink\_s3\_encryption\_customer\_algorithm</a>: Customer encryption algorithm used encrypting data. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a25c46b801c402251cfaaafd65a798955">alter\_datasink\_s3\_encryption\_customer\_key</a>: Customer encryption key to encrypt or decrypt data. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a17b6839e447e0153fcb835a03f079a4e">alter\_datasink\_s3\_encryption\_type</a>: Server side encryption type. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a3b645c8952af2ec7f0be514075b858a0">alter\_datasink\_s3\_kms\_key\_id</a>: KMS key. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a4565916d715519b80e8918e06ab4d373">alter\_datasink\_hdfs\_kerberos\_keytab</a>: Kerberos keytab file location for the given HDFS user. This may be a KIFS file. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a9f22437c6abe08f43700ae4b148cbebd">alter\_datasink\_hdfs\_delegation\_token</a>: Delegation token for the given HDFS user. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ac7a8e19d121c1a415041107304ccac70">alter\_datasink\_hdfs\_use\_kerberos</a>: Use kerberos authentication for the given HDFS cluster. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#aa5cf0f71ea6d896d2d85adae7bba2487">alter\_datasink\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a6aeccac0ebf48fc56991c2a65a3b2272">alter\_datasink\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a6aeccac0ebf48fc56991c2a65a3b2272">alter\_datasink\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a6fc43867972e58f8ba547343cd9fac94">alter\_datasink\_azure\_storage\_account\_name</a>: Name of the Azure storage account to use as the data sink, this is valid only if tenant\_id is specified. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ab0311625dc87be79ee115bf3971939e6">alter\_datasink\_azure\_container\_name</a>: Name of the Azure storage container to use as the data sink. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a66c75cbec45f62b2eca99ef4fad4dbb7">alter\_datasink\_azure\_tenant\_id</a>: Active Directory tenant ID (or directory ID). </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#abee3c93f7c05c0b61557988422b3d9f2">alter\_datasink\_azure\_sas\_token</a>: Shared access signature token for Azure storage account to use as the data sink. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a12cee8b842b07e7805c3dbc9a0fdd89f">alter\_datasink\_azure\_oauth\_token</a>: OAuth token to access given storage container. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ab443a3dc0af9f6fa60053afe22d1ac91">alter\_datasink\_azure\_use\_virtual\_addressing</a>: Whether to use virtual addressing when referencing the Azure source. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#aa5cf0f71ea6d896d2d85adae7bba2487">alter\_datasink\_true</a>: The requests URI should be specified in virtual-hosted-style format where the bucket name is part of the domain name in the URL. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a6aeccac0ebf48fc56991c2a65a3b2272">alter\_datasink\_false</a>: Use path-style URI for requests. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#aa5cf0f71ea6d896d2d85adae7bba2487">alter\_datasink\_true</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#adbac9d3d999f61393b3cfe6671c00a9b">alter\_datasink\_gcs\_bucket\_name</a>: Name of the Google Cloud Storage bucket to use as the data sink. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aea3fe0340868c921a707b8e38cae696e">alter\_datasink\_gcs\_project\_id</a>: Name of the Google Cloud project to use as the data sink. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ac804cc8c2ff3ff5510482e68db86c6ab">alter\_datasink\_gcs\_service\_account\_keys</a>: Google Cloud service account keys to use for authenticating the data sink. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a99bc70e8ab904940587d65c009c3346c">alter\_datasink\_jdbc\_driver\_jar\_path</a>: JDBC driver jar file location. This may be a KIFS file. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#afffd05e87de3f0f5c3a1e733d251a70f">alter\_datasink\_jdbc\_driver\_class\_name</a>: Name of the JDBC driver class. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a952726ddeca5a96def745416a2e0696f">alter\_datasink\_kafka\_url</a>: The publicly-accessible full path URL to the kafka broker, e.g., '<a href="http://172.123.45.67:9300'">[http://172.123.45.67:9300](http://172.123.45.67:9300)'</a>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ad9c0af60634ffc3e998b04a9a0b03f74">alter\_datasink\_kafka\_topic\_name</a>: Name of the Kafka topic to use for this data sink, if it references a Kafka broker. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a91c2f8678b82b9bd3e44597a7f602d12">alter\_datasink\_anonymous</a>: Create an anonymous connection to the storage provider–DEPRECATED: this is now the default. Specify use\_managed\_credentials for non-anonymous connection. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#aa5cf0f71ea6d896d2d85adae7bba2487">alter\_datasink\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a6aeccac0ebf48fc56991c2a65a3b2272">alter\_datasink\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#aa5cf0f71ea6d896d2d85adae7bba2487">alter\_datasink\_true</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#aa928649c126abfc1a446e0a8a426dead">alter\_datasink\_use\_managed\_credentials</a>: When no credentials are supplied, we use anonymous access by default. If this is set, we will use cloud provider user settings. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#aa5cf0f71ea6d896d2d85adae7bba2487">alter\_datasink\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a6aeccac0ebf48fc56991c2a65a3b2272">alter\_datasink\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a6aeccac0ebf48fc56991c2a65a3b2272">alter\_datasink\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a92c588a54be469b8969e0e52568c6839">alter\_datasink\_use\_https</a>: Use HTTPS to connect to datasink if true, otherwise use HTTP. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#aa5cf0f71ea6d896d2d85adae7bba2487">alter\_datasink\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a6aeccac0ebf48fc56991c2a65a3b2272">alter\_datasink\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#aa5cf0f71ea6d896d2d85adae7bba2487">alter\_datasink\_true</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#ad6145d07105197fae52c8fc87bc8f1b4">alter\_datasink\_max\_batch\_size</a>: Maximum number of records per notification message. The default value is '1'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a529332811f765c8339ede1f81d360b27">alter\_datasink\_max\_message\_size</a>: Maximum size in bytes of each notification message. The default value is '1000000'. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a86f0b3cd992b783cf34fa1998d4ffe18">alter\_datasink\_json\_format</a>: The desired format of JSON encoded notifications message. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a6a7dee0a0304a051b5626c46aee04dfc">alter\_datasink\_flat</a>: A single record is returned per message. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aa1bf7eaedcaa8ed4f98abd100afd30e1">alter\_datasink\_nested</a>: Records are returned as an array per message. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a6a7dee0a0304a051b5626c46aee04dfc">alter\_datasink\_flat</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a8d331eabb1eaa0d017e2dc8c7a61764f">alter\_datasink\_skip\_validation</a>: Bypass validation of connection to this data sink. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#aa5cf0f71ea6d896d2d85adae7bba2487">alter\_datasink\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a6aeccac0ebf48fc56991c2a65a3b2272">alter\_datasink\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a6aeccac0ebf48fc56991c2a65a3b2272">alter\_datasink\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#acd037aa58526d85bd5133adc55350362">alter\_datasink\_schema\_name</a>: Updates the schema name. If <a href="/content/api/cpp/namespacegpudb#acd037aa58526d85bd5133adc55350362">schema\_name</a> doesn't exist, an error will be thrown. If <a href="/content/api/cpp/namespacegpudb#acd037aa58526d85bd5133adc55350362">schema\_name</a> is empty, then the user's default schema will be used. </li>
                  </ul>
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AlterDatasinkResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AlterDatasinkResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a3b682ba6dcd6140d7d489a9c1b76cf79">◆ </a></span>alterDatasource() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AlterDatasourceResponse">AlterDatasourceResponse</a> gpudb::GPUdb::alterDatasource </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1AlterDatasourceRequest">AlterDatasourceRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Alters the properties of an existing <a href="/content/concepts/data_sources/">data source</a>. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AlterDatasourceRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AlterDatasourceResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ab0c1a104ed6622a2b8ed7f0de4eddb86">◆ </a></span>alterDatasource() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AlterDatasourceResponse">AlterDatasourceResponse</a> & gpudb::GPUdb::alterDatasource </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1AlterDatasourceRequest">AlterDatasourceRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1AlterDatasourceResponse">AlterDatasourceResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Alters the properties of an existing <a href="/content/concepts/data_sources/">data source</a>. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AlterDatasourceRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AlterDatasourceResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AlterDatasourceResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a373cdecccdabad5291381d131f5d1368">◆ </a></span>alterDatasource() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AlterDatasourceResponse">AlterDatasourceResponse</a> gpudb::GPUdb::alterDatasource </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>datasourceUpdatesMap</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Alters the properties of an existing <a href="/content/concepts/data_sources/">data source</a>. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>name</td>
                <td>Name of the data source to be altered. Must be an existing data source. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>datasourceUpdatesMap</td>

                <td>
                  Map containing the properties of the data source to be updated. Error if empty.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#af8497eaf16bc2aea3e553f6a3501b7e2">alter\_datasource\_location</a>: Location of the remote storage in 'storage\_provider\_type://\[storage\_path\[:storage\_port]]' format. Supported storage provider types are 'azure', 'gcs', 'hdfs', 'jdbc', 'kafka', 'confluent', and 's3'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a06012612c3b635c25e068e0533249363">alter\_datasource\_user\_name</a>: Name of the remote system user; may be an empty string. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a3226f4e55cedc9b18e8ce7cce906302f">alter\_datasource\_password</a>: Password for the remote system user; may be an empty string. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#aba1f199ee9f1244f3d6dcbbe6e370500">alter\_datasource\_skip\_validation</a>: Bypass validation of connection to remote source. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad65a7c605d5418a90ecd622b39b08d89">alter\_datasource\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a5dbb5686968f15095c8b26aef709ed45">alter\_datasource\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a5dbb5686968f15095c8b26aef709ed45">alter\_datasource\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#af209ca4cd1ba64854cd11e52ed910152">alter\_datasource\_connection\_timeout</a>: Timeout in seconds for connecting to this storage provider. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a3654059dce581fb3e63e0526bd415a2d">alter\_datasource\_wait\_timeout</a>: Timeout in seconds for reading from this storage provider. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a4f6b541a5152ea0d3794cb27a4782d29">alter\_datasource\_credential</a>: Name of the <a href="/content/concepts/credentials">credential</a> object to be used in data source. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#af98882b9da4954d2aa21f7a91a4c2d43">alter\_datasource\_s3\_bucket\_name</a>: Name of the Amazon S3 bucket to use as the data source. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#afb544f9acdc2341bf63ddacea0c9399d">alter\_datasource\_s3\_region</a>: Name of the Amazon S3 region where the given bucket is located. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a17a3e455fe0c8a54743f4ee37bbb0bce">alter\_datasource\_s3\_verify\_ssl</a>: Whether to verify SSL connections. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad65a7c605d5418a90ecd622b39b08d89">alter\_datasource\_true</a>: Connect with SSL verification. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a5dbb5686968f15095c8b26aef709ed45">alter\_datasource\_false</a>: Connect without verifying the SSL connection; for testing purposes, bypassing TLS errors, self-signed certificates, etc. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ad65a7c605d5418a90ecd622b39b08d89">alter\_datasource\_true</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ae5a7497ba4a26e07e9938d61fe54d7f5">alter\_datasource\_s3\_use\_virtual\_addressing</a>: Whether to use virtual addressing when referencing the Amazon S3 source. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad65a7c605d5418a90ecd622b39b08d89">alter\_datasource\_true</a>: The requests URI should be specified in virtual-hosted-style format where the bucket name is part of the domain name in the URL. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a5dbb5686968f15095c8b26aef709ed45">alter\_datasource\_false</a>: Use path-style URI for requests. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ad65a7c605d5418a90ecd622b39b08d89">alter\_datasource\_true</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a76d7b2dd5078e99de59aefa1bfac614b">alter\_datasource\_s3\_aws\_role\_arn</a>: Amazon IAM Role ARN which has required S3 permissions that can be assumed for the given S3 IAM user. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aa9fa675f796deccb2805644c95898623">alter\_datasource\_s3\_encryption\_customer\_algorithm</a>: Customer encryption algorithm used encrypting data. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a6da8588299b9ee8e6439ce1d2e3327f4">alter\_datasource\_s3\_encryption\_customer\_key</a>: Customer encryption key to encrypt or decrypt data. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a20faf20a9a1bbf2efe986ece3182182c">alter\_datasource\_hdfs\_kerberos\_keytab</a>: Kerberos keytab file location for the given HDFS user. This may be a KIFS file. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ab7224734a4e63696598e503fb310da4f">alter\_datasource\_hdfs\_delegation\_token</a>: Delegation token for the given HDFS user. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a11ad9f37ce99035ff55f23409a0018a9">alter\_datasource\_hdfs\_use\_kerberos</a>: Use kerberos authentication for the given HDFS cluster. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad65a7c605d5418a90ecd622b39b08d89">alter\_datasource\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a5dbb5686968f15095c8b26aef709ed45">alter\_datasource\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a5dbb5686968f15095c8b26aef709ed45">alter\_datasource\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a0b166f996feb54eb6aa2772b374dd392">alter\_datasource\_azure\_storage\_account\_name</a>: Name of the Azure storage account to use as the data source, this is valid only if tenant\_id is specified. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a0236877027c5a809d1b62d2229c6d584">alter\_datasource\_azure\_container\_name</a>: Name of the Azure storage container to use as the data source. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aa77015ad62dbd6d10419174c01523312">alter\_datasource\_azure\_tenant\_id</a>: Active Directory tenant ID (or directory ID). </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ae3be2ab2ec2a18c9649e1276b0915c7e">alter\_datasource\_azure\_sas\_token</a>: Shared access signature token for Azure storage account to use as the data source. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aec538da3127feedcf3717fdc8830652e">alter\_datasource\_azure\_oauth\_token</a>: OAuth token to access given storage container. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#aac94e88fd57259762a48a965a3da605d">alter\_datasource\_azure\_use\_virtual\_addressing</a>: Whether to use virtual addressing when referencing the Azure source. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad65a7c605d5418a90ecd622b39b08d89">alter\_datasource\_true</a>: The requests URI should be specified in virtual-hosted-style format where the bucket name is part of the domain name in the URL. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a5dbb5686968f15095c8b26aef709ed45">alter\_datasource\_false</a>: Use path-style URI for requests. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ad65a7c605d5418a90ecd622b39b08d89">alter\_datasource\_true</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#afc37b10a838c08afb0e6ff32eb09df0a">alter\_datasource\_gcs\_bucket\_name</a>: Name of the Google Cloud Storage bucket to use as the data source. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a7da4deea17fc1d2f9283870299ac75a2">alter\_datasource\_gcs\_project\_id</a>: Name of the Google Cloud project to use as the data source. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ad2f47224c932660d0b28bdb7b737058f">alter\_datasource\_gcs\_service\_account\_keys</a>: Google Cloud service account keys to use for authenticating the data source. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a6ea3edc5cb23521b40871574b3d85b61">alter\_datasource\_jdbc\_driver\_jar\_path</a>: JDBC driver jar file location. This may be a KIFS file. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a7bb2c6d9166576d0fd62cbf7e324dd7f">alter\_datasource\_jdbc\_driver\_class\_name</a>: Name of the JDBC driver class. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a7533eddbbface67e917b1307bca1b9da">alter\_datasource\_kafka\_url</a>: The publicly-accessible full path URL to the Kafka broker, e.g., '<a href="http://172.123.45.67:9300'">[http://172.123.45.67:9300](http://172.123.45.67:9300)'</a>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a051a3ce84dd6c1d95df06bd645812621">alter\_datasource\_kafka\_topic\_name</a>: Name of the Kafka topic to use as the data source. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ad09212fd53c092a5acf1b03177c329b8">alter\_datasource\_anonymous</a>: Create an anonymous connection to the storage provider–DEPRECATED: this is now the default. Specify use\_managed\_credentials for non-anonymous connection. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad65a7c605d5418a90ecd622b39b08d89">alter\_datasource\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a5dbb5686968f15095c8b26aef709ed45">alter\_datasource\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ad65a7c605d5418a90ecd622b39b08d89">alter\_datasource\_true</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#acef615d5fa89eed86339b2355ed7509a">alter\_datasource\_use\_managed\_credentials</a>: When no credentials are supplied, we use anonymous access by default. If this is set, we will use cloud provider user settings. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad65a7c605d5418a90ecd622b39b08d89">alter\_datasource\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a5dbb5686968f15095c8b26aef709ed45">alter\_datasource\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a5dbb5686968f15095c8b26aef709ed45">alter\_datasource\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a9f62457558511fb5806510b8f39765bd">alter\_datasource\_use\_https</a>: Use HTTPS to connect to datasource if true, otherwise use HTTP. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad65a7c605d5418a90ecd622b39b08d89">alter\_datasource\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a5dbb5686968f15095c8b26aef709ed45">alter\_datasource\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ad65a7c605d5418a90ecd622b39b08d89">alter\_datasource\_true</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a5b04e6c0c712a6c522b3fe6aea7fe061">alter\_datasource\_schema\_name</a>: Updates the schema name. If <a href="/content/api/cpp/namespacegpudb#a5b04e6c0c712a6c522b3fe6aea7fe061">schema\_name</a> doesn't exist, an error will be thrown. If <a href="/content/api/cpp/namespacegpudb#a5b04e6c0c712a6c522b3fe6aea7fe061">schema\_name</a> is empty, then the user's default schema will be used. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a936838344693c9f2598f212023284123">alter\_datasource\_schema\_registry\_connection\_retries</a>: Confluent Schema registry connection timeout (in secs). </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a50bdcf0b287a5c6a551edecd5735bd28">alter\_datasource\_schema\_registry\_connection\_timeout</a>: Confluent Schema registry connection timeout (in secs). </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a81c3fe9533b8e35c601890252db60224">alter\_datasource\_schema\_registry\_credential</a>: Confluent Schema Registry <a href="/content/concepts/credentials">credential</a> object name. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a30f762cdc2e8299349a90892c2e86b05">alter\_datasource\_schema\_registry\_location</a>: Location of Confluent Schema Registry in '\[storage\_path\[:storage\_port]]' format. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a542c7df8280abc966bbe8c592921591f">alter\_datasource\_schema\_registry\_port</a>: Confluent Schema Registry port (optional). </li>
                  </ul>
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AlterDatasourceResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ab1dd1115e2c83d49af739259642a95d5">◆ </a></span>alterDatasource() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AlterDatasourceResponse">AlterDatasourceResponse</a> & gpudb::GPUdb::alterDatasource </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>datasourceUpdatesMap</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1AlterDatasourceResponse">AlterDatasourceResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Alters the properties of an existing <a href="/content/concepts/data_sources/">data source</a>. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>name</td>
                <td>Name of the data source to be altered. Must be an existing data source. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>datasourceUpdatesMap</td>

                <td>
                  Map containing the properties of the data source to be updated. Error if empty.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#af8497eaf16bc2aea3e553f6a3501b7e2">alter\_datasource\_location</a>: Location of the remote storage in 'storage\_provider\_type://\[storage\_path\[:storage\_port]]' format. Supported storage provider types are 'azure', 'gcs', 'hdfs', 'jdbc', 'kafka', 'confluent', and 's3'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a06012612c3b635c25e068e0533249363">alter\_datasource\_user\_name</a>: Name of the remote system user; may be an empty string. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a3226f4e55cedc9b18e8ce7cce906302f">alter\_datasource\_password</a>: Password for the remote system user; may be an empty string. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#aba1f199ee9f1244f3d6dcbbe6e370500">alter\_datasource\_skip\_validation</a>: Bypass validation of connection to remote source. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad65a7c605d5418a90ecd622b39b08d89">alter\_datasource\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a5dbb5686968f15095c8b26aef709ed45">alter\_datasource\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a5dbb5686968f15095c8b26aef709ed45">alter\_datasource\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#af209ca4cd1ba64854cd11e52ed910152">alter\_datasource\_connection\_timeout</a>: Timeout in seconds for connecting to this storage provider. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a3654059dce581fb3e63e0526bd415a2d">alter\_datasource\_wait\_timeout</a>: Timeout in seconds for reading from this storage provider. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a4f6b541a5152ea0d3794cb27a4782d29">alter\_datasource\_credential</a>: Name of the <a href="/content/concepts/credentials">credential</a> object to be used in data source. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#af98882b9da4954d2aa21f7a91a4c2d43">alter\_datasource\_s3\_bucket\_name</a>: Name of the Amazon S3 bucket to use as the data source. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#afb544f9acdc2341bf63ddacea0c9399d">alter\_datasource\_s3\_region</a>: Name of the Amazon S3 region where the given bucket is located. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a17a3e455fe0c8a54743f4ee37bbb0bce">alter\_datasource\_s3\_verify\_ssl</a>: Whether to verify SSL connections. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad65a7c605d5418a90ecd622b39b08d89">alter\_datasource\_true</a>: Connect with SSL verification. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a5dbb5686968f15095c8b26aef709ed45">alter\_datasource\_false</a>: Connect without verifying the SSL connection; for testing purposes, bypassing TLS errors, self-signed certificates, etc. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ad65a7c605d5418a90ecd622b39b08d89">alter\_datasource\_true</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ae5a7497ba4a26e07e9938d61fe54d7f5">alter\_datasource\_s3\_use\_virtual\_addressing</a>: Whether to use virtual addressing when referencing the Amazon S3 source. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad65a7c605d5418a90ecd622b39b08d89">alter\_datasource\_true</a>: The requests URI should be specified in virtual-hosted-style format where the bucket name is part of the domain name in the URL. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a5dbb5686968f15095c8b26aef709ed45">alter\_datasource\_false</a>: Use path-style URI for requests. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ad65a7c605d5418a90ecd622b39b08d89">alter\_datasource\_true</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a76d7b2dd5078e99de59aefa1bfac614b">alter\_datasource\_s3\_aws\_role\_arn</a>: Amazon IAM Role ARN which has required S3 permissions that can be assumed for the given S3 IAM user. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aa9fa675f796deccb2805644c95898623">alter\_datasource\_s3\_encryption\_customer\_algorithm</a>: Customer encryption algorithm used encrypting data. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a6da8588299b9ee8e6439ce1d2e3327f4">alter\_datasource\_s3\_encryption\_customer\_key</a>: Customer encryption key to encrypt or decrypt data. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a20faf20a9a1bbf2efe986ece3182182c">alter\_datasource\_hdfs\_kerberos\_keytab</a>: Kerberos keytab file location for the given HDFS user. This may be a KIFS file. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ab7224734a4e63696598e503fb310da4f">alter\_datasource\_hdfs\_delegation\_token</a>: Delegation token for the given HDFS user. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a11ad9f37ce99035ff55f23409a0018a9">alter\_datasource\_hdfs\_use\_kerberos</a>: Use kerberos authentication for the given HDFS cluster. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad65a7c605d5418a90ecd622b39b08d89">alter\_datasource\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a5dbb5686968f15095c8b26aef709ed45">alter\_datasource\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a5dbb5686968f15095c8b26aef709ed45">alter\_datasource\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a0b166f996feb54eb6aa2772b374dd392">alter\_datasource\_azure\_storage\_account\_name</a>: Name of the Azure storage account to use as the data source, this is valid only if tenant\_id is specified. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a0236877027c5a809d1b62d2229c6d584">alter\_datasource\_azure\_container\_name</a>: Name of the Azure storage container to use as the data source. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aa77015ad62dbd6d10419174c01523312">alter\_datasource\_azure\_tenant\_id</a>: Active Directory tenant ID (or directory ID). </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ae3be2ab2ec2a18c9649e1276b0915c7e">alter\_datasource\_azure\_sas\_token</a>: Shared access signature token for Azure storage account to use as the data source. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aec538da3127feedcf3717fdc8830652e">alter\_datasource\_azure\_oauth\_token</a>: OAuth token to access given storage container. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#aac94e88fd57259762a48a965a3da605d">alter\_datasource\_azure\_use\_virtual\_addressing</a>: Whether to use virtual addressing when referencing the Azure source. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad65a7c605d5418a90ecd622b39b08d89">alter\_datasource\_true</a>: The requests URI should be specified in virtual-hosted-style format where the bucket name is part of the domain name in the URL. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a5dbb5686968f15095c8b26aef709ed45">alter\_datasource\_false</a>: Use path-style URI for requests. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ad65a7c605d5418a90ecd622b39b08d89">alter\_datasource\_true</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#afc37b10a838c08afb0e6ff32eb09df0a">alter\_datasource\_gcs\_bucket\_name</a>: Name of the Google Cloud Storage bucket to use as the data source. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a7da4deea17fc1d2f9283870299ac75a2">alter\_datasource\_gcs\_project\_id</a>: Name of the Google Cloud project to use as the data source. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ad2f47224c932660d0b28bdb7b737058f">alter\_datasource\_gcs\_service\_account\_keys</a>: Google Cloud service account keys to use for authenticating the data source. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a6ea3edc5cb23521b40871574b3d85b61">alter\_datasource\_jdbc\_driver\_jar\_path</a>: JDBC driver jar file location. This may be a KIFS file. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a7bb2c6d9166576d0fd62cbf7e324dd7f">alter\_datasource\_jdbc\_driver\_class\_name</a>: Name of the JDBC driver class. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a7533eddbbface67e917b1307bca1b9da">alter\_datasource\_kafka\_url</a>: The publicly-accessible full path URL to the Kafka broker, e.g., '<a href="http://172.123.45.67:9300'">[http://172.123.45.67:9300](http://172.123.45.67:9300)'</a>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a051a3ce84dd6c1d95df06bd645812621">alter\_datasource\_kafka\_topic\_name</a>: Name of the Kafka topic to use as the data source. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ad09212fd53c092a5acf1b03177c329b8">alter\_datasource\_anonymous</a>: Create an anonymous connection to the storage provider–DEPRECATED: this is now the default. Specify use\_managed\_credentials for non-anonymous connection. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad65a7c605d5418a90ecd622b39b08d89">alter\_datasource\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a5dbb5686968f15095c8b26aef709ed45">alter\_datasource\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ad65a7c605d5418a90ecd622b39b08d89">alter\_datasource\_true</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#acef615d5fa89eed86339b2355ed7509a">alter\_datasource\_use\_managed\_credentials</a>: When no credentials are supplied, we use anonymous access by default. If this is set, we will use cloud provider user settings. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad65a7c605d5418a90ecd622b39b08d89">alter\_datasource\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a5dbb5686968f15095c8b26aef709ed45">alter\_datasource\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a5dbb5686968f15095c8b26aef709ed45">alter\_datasource\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a9f62457558511fb5806510b8f39765bd">alter\_datasource\_use\_https</a>: Use HTTPS to connect to datasource if true, otherwise use HTTP. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad65a7c605d5418a90ecd622b39b08d89">alter\_datasource\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a5dbb5686968f15095c8b26aef709ed45">alter\_datasource\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ad65a7c605d5418a90ecd622b39b08d89">alter\_datasource\_true</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a5b04e6c0c712a6c522b3fe6aea7fe061">alter\_datasource\_schema\_name</a>: Updates the schema name. If <a href="/content/api/cpp/namespacegpudb#a5b04e6c0c712a6c522b3fe6aea7fe061">schema\_name</a> doesn't exist, an error will be thrown. If <a href="/content/api/cpp/namespacegpudb#a5b04e6c0c712a6c522b3fe6aea7fe061">schema\_name</a> is empty, then the user's default schema will be used. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a936838344693c9f2598f212023284123">alter\_datasource\_schema\_registry\_connection\_retries</a>: Confluent Schema registry connection timeout (in secs). </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a50bdcf0b287a5c6a551edecd5735bd28">alter\_datasource\_schema\_registry\_connection\_timeout</a>: Confluent Schema registry connection timeout (in secs). </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a81c3fe9533b8e35c601890252db60224">alter\_datasource\_schema\_registry\_credential</a>: Confluent Schema Registry <a href="/content/concepts/credentials">credential</a> object name. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a30f762cdc2e8299349a90892c2e86b05">alter\_datasource\_schema\_registry\_location</a>: Location of Confluent Schema Registry in '\[storage\_path\[:storage\_port]]' format. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a542c7df8280abc966bbe8c592921591f">alter\_datasource\_schema\_registry\_port</a>: Confluent Schema Registry port (optional). </li>
                  </ul>
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AlterDatasourceResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AlterDatasourceResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ad980efe5cc24d3a87cec53c4530b153f">◆ </a></span>alterDirectory() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AlterDirectoryResponse">AlterDirectoryResponse</a> gpudb::GPUdb::alterDirectory </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1AlterDirectoryRequest">AlterDirectoryRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Alters an existing directory in <a href="/content/tools/kifs/">KiFS</a>. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AlterDirectoryRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AlterDirectoryResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a7c13a227235c2670b4f421e2309a277d">◆ </a></span>alterDirectory() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AlterDirectoryResponse">AlterDirectoryResponse</a> & gpudb::GPUdb::alterDirectory </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1AlterDirectoryRequest">AlterDirectoryRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1AlterDirectoryResponse">AlterDirectoryResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Alters an existing directory in <a href="/content/tools/kifs/">KiFS</a>. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AlterDirectoryRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AlterDirectoryResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AlterDirectoryResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a37f7f5e91df5a80b3c600cb69cfa22c6">◆ </a></span>alterDirectory() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AlterDirectoryResponse">AlterDirectoryResponse</a> gpudb::GPUdb::alterDirectory </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>directoryName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>directoryUpdatesMap</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Alters an existing directory in <a href="/content/tools/kifs/">KiFS</a>. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>directoryName</td>
                <td>Name of the directory in KiFS to be altered. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>directoryUpdatesMap</td>

                <td>
                  Map containing the properties of the directory to be altered. Error if empty.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#af9d3f7843f6b692764a91d242451a7f1">alter\_directory\_data\_limit</a>: The maximum capacity, in bytes, to apply to the directory. Set to -1 to indicate no upper limit. </li>
                  </ul>
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AlterDirectoryResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a404cc8288ba6485910fea40740bcd09c">◆ </a></span>alterDirectory() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AlterDirectoryResponse">AlterDirectoryResponse</a> & gpudb::GPUdb::alterDirectory </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>directoryName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>directoryUpdatesMap</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1AlterDirectoryResponse">AlterDirectoryResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Alters an existing directory in <a href="/content/tools/kifs/">KiFS</a>. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>directoryName</td>
                <td>Name of the directory in KiFS to be altered. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>directoryUpdatesMap</td>

                <td>
                  Map containing the properties of the directory to be altered. Error if empty.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#af9d3f7843f6b692764a91d242451a7f1">alter\_directory\_data\_limit</a>: The maximum capacity, in bytes, to apply to the directory. Set to -1 to indicate no upper limit. </li>
                  </ul>
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AlterDirectoryResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AlterDirectoryResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a7ad22467beee2568754047af78a7bf90">◆ </a></span>alterEnvironment() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AlterEnvironmentResponse">AlterEnvironmentResponse</a> gpudb::GPUdb::alterEnvironment </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1AlterEnvironmentRequest">AlterEnvironmentRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Alters an existing environment which can be referenced by a <a href="/content/concepts/udf/">user-defined function</a> (UDF). </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AlterEnvironmentRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AlterEnvironmentResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ae4f9b2cdbdf0fb844a552aa6844af675">◆ </a></span>alterEnvironment() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AlterEnvironmentResponse">AlterEnvironmentResponse</a> & gpudb::GPUdb::alterEnvironment </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1AlterEnvironmentRequest">AlterEnvironmentRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1AlterEnvironmentResponse">AlterEnvironmentResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Alters an existing environment which can be referenced by a <a href="/content/concepts/udf/">user-defined function</a> (UDF). </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AlterEnvironmentRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AlterEnvironmentResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AlterEnvironmentResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a908327f53abc3d0337024fa7adca1f77">◆ </a></span>alterEnvironment() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AlterEnvironmentResponse">AlterEnvironmentResponse</a> gpudb::GPUdb::alterEnvironment </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>environmentName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>action</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>value</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Alters an existing environment which can be referenced by a <a href="/content/concepts/udf/">user-defined function</a> (UDF). </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>environmentName</td>
                <td>Name of the environment to be altered. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>action</td>

                <td>
                  Modification operation to be applied. Supported values:

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#ab0796383a257147cadaef815fc59da5c">alter\_environment\_install\_package</a>: Install a python package from PyPI, an external data source or KiFS. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a87496b3c47fbc0c828b37f727bc2197c">alter\_environment\_install\_requirements</a>: Install packages from a requirements file. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ac46962a17b1b9340f6a8d39e79c04544">alter\_environment\_uninstall\_package</a>: Uninstall a python package. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#adf6ca34b954ccde01c5fbbccf6c30678">alter\_environment\_uninstall\_requirements</a>: Uninstall packages from a requirements file. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ac99f67abc4aadaf8b73ffff173a6c5b1">alter\_environment\_reset</a>: Uninstalls all packages in the environment and resets it to the original state at time of creation. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#afe2895fb56b140a32ce6660f3c6108a6">alter\_environment\_rebuild</a>: Recreates the environment and re-installs all packages, upgrades the packages if necessary based on dependencies. </li>
                  </ul>
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>value</td>
                <td>The value of the modification, depending on <span>action</span>. For example, if <span>action</span> is <a href="/content/api/cpp/namespacegpudb#ab0796383a257147cadaef815fc59da5c">install\_package</a>, this would be the python package name. If <span>action</span> is <a href="/content/api/cpp/namespacegpudb#a87496b3c47fbc0c828b37f727bc2197c">install\_requirements</a>, this would be the path of a requirements file from which to install packages. If an external data source is specified in <a href="/content/api/cpp/namespacegpudb#aac83bd2736cec62f9efbbea87fdfbe86">datasource\_name</a>, this can be the path to a wheel file or source archive. Alternatively, if installing from a file (wheel or source archive), the value may be a reference to a file in <a href="/content/tools/kifs/">KiFS</a>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#aac83bd2736cec62f9efbbea87fdfbe86">alter\_environment\_datasource\_name</a>: Name of an existing external data source from which packages specified in <span>value</span> can be loaded. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AlterEnvironmentResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a27395e3418456675335c8547725fe5af">◆ </a></span>alterEnvironment() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AlterEnvironmentResponse">AlterEnvironmentResponse</a> & gpudb::GPUdb::alterEnvironment </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>environmentName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>action</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>value</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1AlterEnvironmentResponse">AlterEnvironmentResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Alters an existing environment which can be referenced by a <a href="/content/concepts/udf/">user-defined function</a> (UDF). </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>environmentName</td>
                <td>Name of the environment to be altered. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>action</td>

                <td>
                  Modification operation to be applied. Supported values:

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#ab0796383a257147cadaef815fc59da5c">alter\_environment\_install\_package</a>: Install a python package from PyPI, an external data source or KiFS. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a87496b3c47fbc0c828b37f727bc2197c">alter\_environment\_install\_requirements</a>: Install packages from a requirements file. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ac46962a17b1b9340f6a8d39e79c04544">alter\_environment\_uninstall\_package</a>: Uninstall a python package. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#adf6ca34b954ccde01c5fbbccf6c30678">alter\_environment\_uninstall\_requirements</a>: Uninstall packages from a requirements file. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ac99f67abc4aadaf8b73ffff173a6c5b1">alter\_environment\_reset</a>: Uninstalls all packages in the environment and resets it to the original state at time of creation. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#afe2895fb56b140a32ce6660f3c6108a6">alter\_environment\_rebuild</a>: Recreates the environment and re-installs all packages, upgrades the packages if necessary based on dependencies. </li>
                  </ul>
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>value</td>
                <td>The value of the modification, depending on <span>action</span>. For example, if <span>action</span> is <a href="/content/api/cpp/namespacegpudb#ab0796383a257147cadaef815fc59da5c">install\_package</a>, this would be the python package name. If <span>action</span> is <a href="/content/api/cpp/namespacegpudb#a87496b3c47fbc0c828b37f727bc2197c">install\_requirements</a>, this would be the path of a requirements file from which to install packages. If an external data source is specified in <a href="/content/api/cpp/namespacegpudb#aac83bd2736cec62f9efbbea87fdfbe86">datasource\_name</a>, this can be the path to a wheel file or source archive. Alternatively, if installing from a file (wheel or source archive), the value may be a reference to a file in <a href="/content/tools/kifs/">KiFS</a>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#aac83bd2736cec62f9efbbea87fdfbe86">alter\_environment\_datasource\_name</a>: Name of an existing external data source from which packages specified in <span>value</span> can be loaded. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AlterEnvironmentResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AlterEnvironmentResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a52be74f95cad4c445058fd741a9f4599">◆ </a></span>alterResourceGroup() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AlterResourceGroupResponse">AlterResourceGroupResponse</a> gpudb::GPUdb::alterResourceGroup </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1AlterResourceGroupRequest">AlterResourceGroupRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Alters the properties of an existing resource group to facilitate resource management. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AlterResourceGroupRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AlterResourceGroupResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a13779227bf194104ef206c1fc7664a60">◆ </a></span>alterResourceGroup() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AlterResourceGroupResponse">AlterResourceGroupResponse</a> & gpudb::GPUdb::alterResourceGroup </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1AlterResourceGroupRequest">AlterResourceGroupRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1AlterResourceGroupResponse">AlterResourceGroupResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Alters the properties of an existing resource group to facilitate resource management. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AlterResourceGroupRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AlterResourceGroupResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AlterResourceGroupResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a82dd3d7d904bd8a75b2e768f4e51ac0a">◆ </a></span>alterResourceGroup() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AlterResourceGroupResponse">AlterResourceGroupResponse</a> gpudb::GPUdb::alterResourceGroup </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::map\< std::string, std::string > > &</td>
            <td><span><span>tierAttributes</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>ranking</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>adjoiningResourceGroup</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Alters the properties of an existing resource group to facilitate resource management. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>name</td>
                <td>Name of the group to be altered. Must be an existing resource group name or an empty string when used in conjunction with <a href="/content/api/cpp/namespacegpudb#ae7bace90096897d9ac67de6a4ecf2c47">is\_default\_group</a>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>tierAttributes</td>

                <td>
                  Optional map containing tier names and their respective attribute group limits. The only valid attribute limit that can be set is max\_memory (in bytes) for the VRAM and RAM tiers. For instance, to set max VRAM capacity to 1GB per rank per GPU and max RAM capacity to 10GB per rank, use: 'VRAM':'max\_memory':'1000000000', 'RAM':'max\_memory':'10000000000'.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a9505096b4f3ca47c18378798fac69e0c">alter\_resource\_group\_max\_memory</a>: Maximum amount of memory usable at one time, per rank, per GPU, for the VRAM tier; or maximum amount of memory usable at one time, per rank, for the RAM tier. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>ranking</td>

                <td>
                  If the resource group ranking is to be updated, this indicates the relative ranking among existing resource groups where this resource group will be placed. Supported values:

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#ab84008b311a3c0de43fb79e05f17cf77">alter\_resource\_group\_empty\_string</a>: Don't change the ranking. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a28e9daf99c777b5600b60af817bf0e74">alter\_resource\_group\_first</a>: Make this resource group the new first one in the ordering. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#af042b5bdec31914771d46b5c70f8093e">alter\_resource\_group\_last</a>: Make this resource group the new last one in the ordering. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aa22da639c2ab8040c05b6bb6233fc085">alter\_resource\_group\_before</a>: Place this resource group before the one specified by <span>adjoiningResourceGroup</span> in the ordering. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#af8ec3209a305a2c45a4c5c4b1b67d1a0">alter\_resource\_group\_after</a>: Place this resource group after the one specified by <span>adjoiningResourceGroup</span> in the ordering. </li>
                  </ul>

                  The default value is <a href="/content/api/cpp/namespacegpudb#ab84008b311a3c0de43fb79e05f17cf77">alter\_resource\_group\_empty\_string</a>.
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>adjoiningResourceGroup</td>
                <td>If <span>ranking</span> is <a href="/content/api/cpp/namespacegpudb#aa22da639c2ab8040c05b6bb6233fc085">before</a> or <a href="/content/api/cpp/namespacegpudb#af8ec3209a305a2c45a4c5c4b1b67d1a0">after</a>, this field indicates the resource group before or after which the current group will be placed; otherwise, leave blank. The default value is ''. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#ae85325b9c2b9cba00342245656129f01">alter\_resource\_group\_max\_cpu\_concurrency</a>: Maximum number of simultaneous threads that will be used to execute a request, per rank, for this group. The minimum allowed value is '4'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a7d31eb81c542c5b63a1eea7be20e972e">alter\_resource\_group\_max\_data</a>: Maximum amount of data, per rank, in bytes, that can be used by all database objects within this group. Set to -1 to indicate no upper limit. The minimum allowed value is '-1'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a8c0d76bd87f17fe514ba75a33fd8d79e">alter\_resource\_group\_max\_scheduling\_priority</a>: Maximum priority of a scheduled task for this group. The minimum allowed value is '1'. The maximum allowed value is '100'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ac4d34b2dbcf64f7e163e1f3590311cfc">alter\_resource\_group\_max\_tier\_priority</a>: Maximum priority of a tiered object for this group. The minimum allowed value is '1'. The maximum allowed value is '10'. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ae7bace90096897d9ac67de6a4ecf2c47">alter\_resource\_group\_is\_default\_group</a>: If <a href="/content/api/cpp/namespacegpudb#ae7d6d38e54409e72444655827e54add6">true</a>, this request applies to the global default resource group. It is an error for this field to be <a href="/content/api/cpp/namespacegpudb#ae7d6d38e54409e72444655827e54add6">true</a> when the <span>name</span> field is also populated. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ae7d6d38e54409e72444655827e54add6">alter\_resource\_group\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a1e4d840806364a59926597a579e9e2e5">alter\_resource\_group\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a1e4d840806364a59926597a579e9e2e5">alter\_resource\_group\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a3bae506f50d08ca3158479f36b82b4ce">alter\_resource\_group\_persist</a>: If <a href="/content/api/cpp/namespacegpudb#ae7d6d38e54409e72444655827e54add6">true</a> and a system-level change was requested, the system configuration will be written to disk upon successful application of this request. This will commit the changes from this request and any additional in-memory modifications. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ae7d6d38e54409e72444655827e54add6">alter\_resource\_group\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a1e4d840806364a59926597a579e9e2e5">alter\_resource\_group\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ae7d6d38e54409e72444655827e54add6">alter\_resource\_group\_true</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AlterResourceGroupResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a57bf15b9abc04e0d2bbd03aa67fb4239">◆ </a></span>alterResourceGroup() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AlterResourceGroupResponse">AlterResourceGroupResponse</a> & gpudb::GPUdb::alterResourceGroup </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::map\< std::string, std::string > > &</td>
            <td><span><span>tierAttributes</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>ranking</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>adjoiningResourceGroup</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1AlterResourceGroupResponse">AlterResourceGroupResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Alters the properties of an existing resource group to facilitate resource management. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>name</td>
                <td>Name of the group to be altered. Must be an existing resource group name or an empty string when used in conjunction with <a href="/content/api/cpp/namespacegpudb#ae7bace90096897d9ac67de6a4ecf2c47">is\_default\_group</a>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>tierAttributes</td>

                <td>
                  Optional map containing tier names and their respective attribute group limits. The only valid attribute limit that can be set is max\_memory (in bytes) for the VRAM and RAM tiers. For instance, to set max VRAM capacity to 1GB per rank per GPU and max RAM capacity to 10GB per rank, use: 'VRAM':'max\_memory':'1000000000', 'RAM':'max\_memory':'10000000000'.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a9505096b4f3ca47c18378798fac69e0c">alter\_resource\_group\_max\_memory</a>: Maximum amount of memory usable at one time, per rank, per GPU, for the VRAM tier; or maximum amount of memory usable at one time, per rank, for the RAM tier. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>ranking</td>

                <td>
                  If the resource group ranking is to be updated, this indicates the relative ranking among existing resource groups where this resource group will be placed. Supported values:

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#ab84008b311a3c0de43fb79e05f17cf77">alter\_resource\_group\_empty\_string</a>: Don't change the ranking. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a28e9daf99c777b5600b60af817bf0e74">alter\_resource\_group\_first</a>: Make this resource group the new first one in the ordering. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#af042b5bdec31914771d46b5c70f8093e">alter\_resource\_group\_last</a>: Make this resource group the new last one in the ordering. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aa22da639c2ab8040c05b6bb6233fc085">alter\_resource\_group\_before</a>: Place this resource group before the one specified by <span>adjoiningResourceGroup</span> in the ordering. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#af8ec3209a305a2c45a4c5c4b1b67d1a0">alter\_resource\_group\_after</a>: Place this resource group after the one specified by <span>adjoiningResourceGroup</span> in the ordering. </li>
                  </ul>

                  The default value is <a href="/content/api/cpp/namespacegpudb#ab84008b311a3c0de43fb79e05f17cf77">alter\_resource\_group\_empty\_string</a>.
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>adjoiningResourceGroup</td>
                <td>If <span>ranking</span> is <a href="/content/api/cpp/namespacegpudb#aa22da639c2ab8040c05b6bb6233fc085">before</a> or <a href="/content/api/cpp/namespacegpudb#af8ec3209a305a2c45a4c5c4b1b67d1a0">after</a>, this field indicates the resource group before or after which the current group will be placed; otherwise, leave blank. The default value is ''. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#ae85325b9c2b9cba00342245656129f01">alter\_resource\_group\_max\_cpu\_concurrency</a>: Maximum number of simultaneous threads that will be used to execute a request, per rank, for this group. The minimum allowed value is '4'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a7d31eb81c542c5b63a1eea7be20e972e">alter\_resource\_group\_max\_data</a>: Maximum amount of data, per rank, in bytes, that can be used by all database objects within this group. Set to -1 to indicate no upper limit. The minimum allowed value is '-1'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a8c0d76bd87f17fe514ba75a33fd8d79e">alter\_resource\_group\_max\_scheduling\_priority</a>: Maximum priority of a scheduled task for this group. The minimum allowed value is '1'. The maximum allowed value is '100'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ac4d34b2dbcf64f7e163e1f3590311cfc">alter\_resource\_group\_max\_tier\_priority</a>: Maximum priority of a tiered object for this group. The minimum allowed value is '1'. The maximum allowed value is '10'. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ae7bace90096897d9ac67de6a4ecf2c47">alter\_resource\_group\_is\_default\_group</a>: If <a href="/content/api/cpp/namespacegpudb#ae7d6d38e54409e72444655827e54add6">true</a>, this request applies to the global default resource group. It is an error for this field to be <a href="/content/api/cpp/namespacegpudb#ae7d6d38e54409e72444655827e54add6">true</a> when the <span>name</span> field is also populated. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ae7d6d38e54409e72444655827e54add6">alter\_resource\_group\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a1e4d840806364a59926597a579e9e2e5">alter\_resource\_group\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a1e4d840806364a59926597a579e9e2e5">alter\_resource\_group\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a3bae506f50d08ca3158479f36b82b4ce">alter\_resource\_group\_persist</a>: If <a href="/content/api/cpp/namespacegpudb#ae7d6d38e54409e72444655827e54add6">true</a> and a system-level change was requested, the system configuration will be written to disk upon successful application of this request. This will commit the changes from this request and any additional in-memory modifications. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ae7d6d38e54409e72444655827e54add6">alter\_resource\_group\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a1e4d840806364a59926597a579e9e2e5">alter\_resource\_group\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ae7d6d38e54409e72444655827e54add6">alter\_resource\_group\_true</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AlterResourceGroupResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AlterResourceGroupResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#afa8f2a294e46d5e721e16056e6decd6a">◆ </a></span>alterRole() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AlterRoleResponse">AlterRoleResponse</a> gpudb::GPUdb::alterRole </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1AlterRoleRequest">AlterRoleRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Alters a Role. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AlterRoleRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AlterRoleResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a52ab59dced4e08c16a2fb4199d7e0ba4">◆ </a></span>alterRole() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AlterRoleResponse">AlterRoleResponse</a> & gpudb::GPUdb::alterRole </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1AlterRoleRequest">AlterRoleRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1AlterRoleResponse">AlterRoleResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Alters a Role. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AlterRoleRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AlterRoleResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AlterRoleResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a68bca33d047ff23768cb913a2d6f210f">◆ </a></span>alterRole() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AlterRoleResponse">AlterRoleResponse</a> gpudb::GPUdb::alterRole </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>action</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>value</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Alters a Role. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>name</td>
                <td>Name of the role to be altered. Must be an existing role. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>action</td>

                <td>
                  Modification operation to be applied to the role. Supported values:

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a3ffa1862e6873d815b78b757ce5f5bc9">alter\_role\_set\_comment</a>: Sets the comment for an internal role. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a503f073cf4cf7d2b914c42b2250546b8">alter\_role\_set\_resource\_group</a>: Sets the resource group for an internal role. The resource group must exist, otherwise, an empty string assigns the role to the default resource group. </li>
                  </ul>
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>value</td>
                <td>The value of the modification, depending on <span>action</span>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AlterRoleResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a316c3cbc12eb0e418e43d5872f5767ec">◆ </a></span>alterRole() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AlterRoleResponse">AlterRoleResponse</a> & gpudb::GPUdb::alterRole </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>action</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>value</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1AlterRoleResponse">AlterRoleResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Alters a Role. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>name</td>
                <td>Name of the role to be altered. Must be an existing role. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>action</td>

                <td>
                  Modification operation to be applied to the role. Supported values:

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a3ffa1862e6873d815b78b757ce5f5bc9">alter\_role\_set\_comment</a>: Sets the comment for an internal role. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a503f073cf4cf7d2b914c42b2250546b8">alter\_role\_set\_resource\_group</a>: Sets the resource group for an internal role. The resource group must exist, otherwise, an empty string assigns the role to the default resource group. </li>
                  </ul>
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>value</td>
                <td>The value of the modification, depending on <span>action</span>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AlterRoleResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AlterRoleResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a6d8737eef0ac5964bafee8168c7001c2">◆ </a></span>alterSchema() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AlterSchemaResponse">AlterSchemaResponse</a> gpudb::GPUdb::alterSchema </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1AlterSchemaRequest">AlterSchemaRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Used to change the name of a SQL-style <a href="/content/concepts/schemas/">schema</a>, specified in <a href="/content/api/cpp/structgpudb_1_1AlterSchemaRequest#a5d2aa8bd3561ad50e0ff38b0fb54e188">schemaName</a>. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AlterSchemaRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AlterSchemaResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#afe7e4516bdc03ae78bcac0da1eab7308">◆ </a></span>alterSchema() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AlterSchemaResponse">AlterSchemaResponse</a> & gpudb::GPUdb::alterSchema </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1AlterSchemaRequest">AlterSchemaRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1AlterSchemaResponse">AlterSchemaResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Used to change the name of a SQL-style <a href="/content/concepts/schemas/">schema</a>, specified in <a href="/content/api/cpp/structgpudb_1_1AlterSchemaRequest#a5d2aa8bd3561ad50e0ff38b0fb54e188">schemaName</a>. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AlterSchemaRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AlterSchemaResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AlterSchemaResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ac3b14375b824755702348959f65b809b">◆ </a></span>alterSchema() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AlterSchemaResponse">AlterSchemaResponse</a> gpudb::GPUdb::alterSchema </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>schemaName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>action</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>value</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Used to change the name of a SQL-style <a href="/content/concepts/schemas/">schema</a>, specified in <span>schemaName</span>. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>schemaName</td>
                <td>Name of the schema to be altered. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>action</td>

                <td>
                  Modification operation to be applied. Supported values:

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a215bf1e57bd8f9f909b7239f69646f85">alter\_schema\_add\_comment</a>: Adds a comment describing the schema. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ad4b093863b91bdd60ffe707d7e063072">alter\_schema\_rename\_schema</a>: Renames a schema to <span>value</span>. Has the same naming restrictions as <a href="/content/concepts/tables/">tables</a>. </li>
                  </ul>
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>value</td>
                <td>The value of the modification, depending on <span>action</span>. For now the only value of <span>action</span> is <a href="/content/api/cpp/namespacegpudb#ad4b093863b91bdd60ffe707d7e063072">rename\_schema</a>. In this case the value is the new name of the schema. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AlterSchemaResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a06fbae44bfb19d07d0336d2fa2baa9de">◆ </a></span>alterSchema() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AlterSchemaResponse">AlterSchemaResponse</a> & gpudb::GPUdb::alterSchema </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>schemaName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>action</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>value</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1AlterSchemaResponse">AlterSchemaResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Used to change the name of a SQL-style <a href="/content/concepts/schemas/">schema</a>, specified in <span>schemaName</span>. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>schemaName</td>
                <td>Name of the schema to be altered. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>action</td>

                <td>
                  Modification operation to be applied. Supported values:

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a215bf1e57bd8f9f909b7239f69646f85">alter\_schema\_add\_comment</a>: Adds a comment describing the schema. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ad4b093863b91bdd60ffe707d7e063072">alter\_schema\_rename\_schema</a>: Renames a schema to <span>value</span>. Has the same naming restrictions as <a href="/content/concepts/tables/">tables</a>. </li>
                  </ul>
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>value</td>
                <td>The value of the modification, depending on <span>action</span>. For now the only value of <span>action</span> is <a href="/content/api/cpp/namespacegpudb#ad4b093863b91bdd60ffe707d7e063072">rename\_schema</a>. In this case the value is the new name of the schema. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AlterSchemaResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AlterSchemaResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a9e3cf621f47f06fb5211ae54f1e46f93">◆ </a></span>alterSystemProperties() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AlterSystemPropertiesResponse">AlterSystemPropertiesResponse</a> gpudb::GPUdb::alterSystemProperties </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1AlterSystemPropertiesRequest">AlterSystemPropertiesRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>The <a href="#a9e3cf621f47f06fb5211ae54f1e46f93">alterSystemProperties</a> endpoint is primarily used to simplify the testing of the system and is not expected to be used during normal execution. </p>
        <p>Commands are given through the <a href="/content/api/cpp/structgpudb_1_1AlterSystemPropertiesRequest#a37127a187e0bd2aa16c0777e98560e69">propertyUpdatesMap</a> whose keys are commands and values are strings representing integer values (for example '8000') or boolean values ('true' or 'false').</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AlterSystemPropertiesRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AlterSystemPropertiesResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a725871fdb042d46d3ba27650b0cbd6d4">◆ </a></span>alterSystemProperties() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AlterSystemPropertiesResponse">AlterSystemPropertiesResponse</a> & gpudb::GPUdb::alterSystemProperties </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1AlterSystemPropertiesRequest">AlterSystemPropertiesRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1AlterSystemPropertiesResponse">AlterSystemPropertiesResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>The <a href="#a9e3cf621f47f06fb5211ae54f1e46f93">alterSystemProperties</a> endpoint is primarily used to simplify the testing of the system and is not expected to be used during normal execution. </p>
        <p>Commands are given through the <a href="/content/api/cpp/structgpudb_1_1AlterSystemPropertiesRequest#a37127a187e0bd2aa16c0777e98560e69">propertyUpdatesMap</a> whose keys are commands and values are strings representing integer values (for example '8000') or boolean values ('true' or 'false').</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AlterSystemPropertiesRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AlterSystemPropertiesResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AlterSystemPropertiesResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a3c2c2636d3219216039c6ea52176acfd">◆ </a></span>alterSystemProperties() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AlterSystemPropertiesResponse">AlterSystemPropertiesResponse</a> gpudb::GPUdb::alterSystemProperties </td>
            <td>(</td>
            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>propertyUpdatesMap</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>The <a href="#a3c2c2636d3219216039c6ea52176acfd">alterSystemProperties</a> endpoint is primarily used to simplify the testing of the system and is not expected to be used during normal execution. </p>
        <p>Commands are given through the <span>propertyUpdatesMap</span> whose keys are commands and values are strings representing integer values (for example '8000') or boolean values ('true' or 'false').</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>propertyUpdatesMap</td>

                <td>
                  Map containing the properties of the system to be updated. Error if empty.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a22850a051b782f78fb8b3e2eeff44295">alter\_system\_properties\_concurrent\_kernel\_execution</a>: Enables concurrent kernel execution if the value is <a href="/content/api/cpp/namespacegpudb#a0e9062d07411faa828964cf824ee42aa">true</a> and disables it if the value is <a href="/content/api/cpp/namespacegpudb#ad3d908e9e936e52db5736fe08079c472">false</a>. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a0e9062d07411faa828964cf824ee42aa">alter\_system\_properties\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad3d908e9e936e52db5736fe08079c472">alter\_system\_properties\_false</a> </li>
                      </ul>
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a5f0d2c881c38007d414e286edeea27a8">alter\_system\_properties\_subtask\_concurrency\_limit</a>: Sets the maximum number of simultaneous threads allocated to a given request, on each rank. Note that thread allocation may also be limited by resource group limits and/or system load. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a0bbda36574dbd742118d883e67f40173">alter\_system\_properties\_chunk\_size</a>: Sets the number of records per chunk to be used for all new tables. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#af1f417b747c72687bb4a49e6d2d7747b">alter\_system\_properties\_chunk\_column\_max\_memory</a>: Sets the target maximum data size for each column in a chunk to be used for all new tables. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a2a918290a2696c92cf6260ae5a003397">alter\_system\_properties\_chunk\_max\_memory</a>: Indicates the target maximum data size for all columns in a chunk to be used for all new tables. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a1667a688917436da05bdf49bd23aa0eb">alter\_system\_properties\_execution\_mode</a>: Sets the execution\_mode for kernel executions to the specified string value. Possible values are host, device, default (engine decides) or an integer value that indicates max chunk size to exec on host. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ae11ec4253fa290777d9fd2837967d72b">alter\_system\_properties\_external\_files\_directory</a>: Sets the root directory path where external table data files are accessed from. Path must exist on the head node. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ace6ae643f8e0ca48bec6bf1453987439">alter\_system\_properties\_request\_timeout</a>: Number of minutes after which filtering (e.g., <a href="#ac5b65e73c01c331f1fcfb21b0e8d67ce">filter</a>) and aggregating (e.g., <a href="#a30cac962c6aedc8efc312e2b4217ff31">aggregateGroupBy</a>) queries will timeout. The default value is '20'. The minimum allowed value is '0'. The maximum allowed value is '1440'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a9d19bc5aa29d4682fb8210265a60dd3b">alter\_system\_properties\_max\_get\_records\_size</a>: The maximum number of records the database will serve for a given data retrieval call. The default value is '20000'. The minimum allowed value is '0'. The maximum allowed value is '1000000'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ad1ec975031a69ed06235e7fb5fbafe7c">alter\_system\_properties\_enable\_audit</a>: Enable or disable auditing. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a18fff2ce51b68a792cb8bea59a6555f6">alter\_system\_properties\_audit\_headers</a>: Enable or disable auditing of request headers. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a862b7d472d415962e441b4fc4450c257">alter\_system\_properties\_audit\_body</a>: Enable or disable auditing of request bodies. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a60d78ff1762a9f4fcc5c4dd68626c8df">alter\_system\_properties\_audit\_data</a>: Enable or disable auditing of request data. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a2311d85c0ac58442245b61e3761a232b">alter\_system\_properties\_audit\_response</a>: Enable or disable auditing of response information. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ac7e6701f944d6f0d8bbba79b47f13273">alter\_system\_properties\_shadow\_agg\_size</a>: Size of the shadow aggregate chunk cache in bytes. The default value is '10000000'. The minimum allowed value is '0'. The maximum allowed value is '2147483647'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a4a095115f9775eaac8fe8ff985c53a01">alter\_system\_properties\_shadow\_filter\_size</a>: Size of the shadow filter chunk cache in bytes. The default value is '10000000'. The minimum allowed value is '0'. The maximum allowed value is '2147483647'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ac828935a7629f2ca598294dc19f1148b">alter\_system\_properties\_enable\_overlapped\_equi\_join</a>: Enable overlapped-equi-join filter. The default value is 'true'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a386a4759aebd93ff665db6891935c2c1">alter\_system\_properties\_enable\_one\_step\_compound\_equi\_join</a>: Enable the one\_step compound-equi-join algorithm. The default value is 'true'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a0774082ecd58b64e9c7713309acdfae1">alter\_system\_properties\_kafka\_batch\_size</a>: Maximum number of records to be ingested in a single batch. The default value is '1000'. The minimum allowed value is '1'. The maximum allowed value is '10000000'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ae72a30f76a129dda553966b2b8cf2057">alter\_system\_properties\_kafka\_poll\_timeout</a>: Maximum time (milliseconds) for each poll to get records from Kafka. The default value is '0'. The minimum allowed value is '0'. The maximum allowed value is '1000'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ae17254a139c63273c2d7f2af2ea74d2e">alter\_system\_properties\_kafka\_wait\_time</a>: Maximum time (seconds) to buffer records received from Kafka before ingestion. The default value is '30'. The minimum allowed value is '1'. The maximum allowed value is '120'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a85d404d7a18381ef9afbd83097ccc215">alter\_system\_properties\_datalake\_table\_metadata\_cache\_enabled</a>: Enable caching of datalake table metadata. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#af0177491dd15d97dc84545eef27f96e5">alter\_system\_properties\_datalake\_table\_metadata\_cache\_size</a>: Maximum number of datalake table metadata entries to cache. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aa3716051baf36cd7fab9aaa61b9f9f6b">alter\_system\_properties\_datalake\_table\_metadata\_cache\_ttl</a>: Time-to-live (seconds) for cached datalake table metadata entries. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a4f7d879804559b8251b8035ac2422a44">alter\_system\_properties\_datalake\_table\_metadata\_cache\_snapshot\_check</a>: When enabled, check the current datalake snapshot on cache hits and invalidate entries that have changed. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ab6d5302e1c2206ee7852c353ac19d8f2">alter\_system\_properties\_datalake\_catalog\_connection\_cache\_size</a>: Maximum number of cached datalake REST catalog connections. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a452bf7919583a09d4b5ae4aee1fdd22b">alter\_system\_properties\_iceberg\_manifest\_cache\_enabled</a>: Enable caching of parsed Iceberg manifest and manifest-list files. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a8c3480527c4de651c93e694e4cb81b91">alter\_system\_properties\_egress\_parquet\_compression</a>: Parquet file compression type. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ab5703cbdaeb566b9fe6a3aecd54d7049">alter\_system\_properties\_uncompressed</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aba3f53f48f98ea6358be653e82703456">alter\_system\_properties\_snappy</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a6c48fa5a6d5562c1d2a9c4d3cd9522d8">alter\_system\_properties\_gzip</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#aba3f53f48f98ea6358be653e82703456">alter\_system\_properties\_snappy</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a9d662bb0a8b616ead8e3baf55e0a3580">alter\_system\_properties\_egress\_single\_file\_max\_size</a>: Max file size (in MB) to allow saving to a single file. May be overridden by target limitations. The default value is '10000'. The minimum allowed value is '1'. The maximum allowed value is '200000'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aadb28310a3215b948fb0940a3a5a5f7f">alter\_system\_properties\_max\_concurrent\_kernels</a>: Sets the max\_concurrent\_kernels value of the conf. The minimum allowed value is '0'. The maximum allowed value is '256'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a1741aff06a18466c951582bff4eaf382">alter\_system\_properties\_system\_metadata\_retention\_period</a>: Sets the system\_metadata.retention\_period value of the conf. The minimum allowed value is '1'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ad351579fddd53208f6f7dddefad0a0a8">alter\_system\_properties\_tcs\_per\_tom</a>: Size of the worker rank data calculation thread pool. This is primarily used for computation-based operations such as aggregates and record retrieval. The minimum allowed value is '2'. The maximum allowed value is '8192'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a649f9cb1527592e2a3db237cbdfe3525">alter\_system\_properties\_tps\_per\_tom</a>: Size of the worker rank data processing thread pool. This includes operations such as inserts, updates, and deletes on table data. Multi-head inserts are not affected by this limit. The minimum allowed value is '2'. The maximum allowed value is '8192'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a85622441fec9b9790ef72e17db99f1c5">alter\_system\_properties\_remote\_io\_threads</a>: Size of the worker rank IO thread pool. This is used for blocking IO operations such as reads from object storage or external file systems. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a34ecd6bdf51217b2b3adaefed2964fe6">alter\_system\_properties\_background\_worker\_threads</a>: Size of the worker rank background thread pool. This includes background operations such as watermark evictions catalog table updates. The minimum allowed value is '1'. The maximum allowed value is '8192'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a9a4db71e34c6ad80a4b9588bf26625fe">alter\_system\_properties\_log\_debug\_job\_info</a>: Outputs various job-related information to the rank logs. Used for troubleshooting. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a6f4e03f352f107842f06e5f240a17cf7">alter\_system\_properties\_enable\_thread\_hang\_logging</a>: Log a stack trace for any thread that runs longer than a defined threshold. Used for troubleshooting. The default value is 'true'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a609ed0fa0949d51d085c8a01b34e95aa">alter\_system\_properties\_ai\_enable\_rag</a>: Enable RAG. The default value is 'false'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aab7d775fc6d131009bcb30471b575359">alter\_system\_properties\_ai\_api\_provider</a>: AI API provider type. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a0bd5c9c6ed35803da5dee2a0b06d09be">alter\_system\_properties\_ai\_api\_url</a>: AI API URL. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a81868a961c879e6cd9438944145fa5cd">alter\_system\_properties\_ai\_api\_key</a>: AI API key. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ace0f3e6c175fd132fe1c9a33c2bc7717">alter\_system\_properties\_ai\_api\_connection\_timeout</a>: AI API connection timeout in seconds. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#abac5f9f26776e4f4ee4658aedd1b03d5">alter\_system\_properties\_ai\_api\_embeddings\_model</a>: AI API model name. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a14b8d0203e2e39f2d6be95af5ef35e88">alter\_system\_properties\_telm\_persist\_query\_metrics</a>: Enable or disable persisting of query metrics. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a3a500d46bff89bddb9f584533e553063">alter\_system\_properties\_telm\_force\_metrics\_duration</a>: Capture metrics for any query exceeding this duration in seconds. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a7995b35a8289b987c262f94d57a41bb1">alter\_system\_properties\_postgres\_proxy\_idle\_connection\_timeout</a>: Idle connection timeout in seconds. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a743d04922fbb1816913aca06a6a95680">alter\_system\_properties\_postgres\_proxy\_keep\_alive</a>: Enable postgres proxy keep alive. The default value is 'false'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a7c3c1033aebede98d42fc6a526472e62">alter\_system\_properties\_kifs\_directory\_data\_limit</a>: The default maximum capacity to apply when creating a KiFS directory (bytes). The minimum allowed value is '-1'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a066c28103dafad970fd31f5a4877a11e">alter\_system\_properties\_compression\_codec</a>: The default <a href="/content/concepts/column_compression/">compression algorithm</a> applied to any column without a column-level or table-level default compression specified at the time it was created. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a0f5098870fe6aa5227c9d460e07c610f">alter\_system\_properties\_disk\_auto\_optimize\_timeout</a>: Time interval in seconds after which the database will apply optimizations/transformations to persisted data, such as compression. The minimum allowed value is '0'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a9afc6469497c3fd3a22d2077ee43f496">alter\_system\_properties\_ha\_consumer\_replay\_offset</a>: Initializes HA replay from the given timestamp (as milliseconds since unix epoch). The minimum allowed value is '-1'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a5453715e68f2cd12c9159e87cae830a0">alter\_system\_properties\_admin\_access\_only</a>: Restricts access to system admin users only. The default value is 'false'. </li>
                  </ul>
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ae3c5f4d2c3729918d15cc0c75e117005">alter\_system\_properties\_evict\_to\_cold</a>: If <a href="/content/api/cpp/namespacegpudb#a0e9062d07411faa828964cf824ee42aa">true</a> and evict\_columns is specified, the given objects will be evicted to cold storage (if such a tier exists). Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a0e9062d07411faa828964cf824ee42aa">alter\_system\_properties\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad3d908e9e936e52db5736fe08079c472">alter\_system\_properties\_false</a> </li>
                      </ul>
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a9644f40aabe27fa1fab75860aceebded">alter\_system\_properties\_persist</a>: If <a href="/content/api/cpp/namespacegpudb#a0e9062d07411faa828964cf824ee42aa">true</a> the system configuration will be written to disk upon successful application of this request. This will commit the changes from this request and any additional in-memory modifications. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a0e9062d07411faa828964cf824ee42aa">alter\_system\_properties\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad3d908e9e936e52db5736fe08079c472">alter\_system\_properties\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a0e9062d07411faa828964cf824ee42aa">alter\_system\_properties\_true</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AlterSystemPropertiesResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a4bdc47a1dd96b3a0af606a967eb8b00a">◆ </a></span>alterSystemProperties() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AlterSystemPropertiesResponse">AlterSystemPropertiesResponse</a> & gpudb::GPUdb::alterSystemProperties </td>
            <td>(</td>
            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>propertyUpdatesMap</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1AlterSystemPropertiesResponse">AlterSystemPropertiesResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>The <a href="#a3c2c2636d3219216039c6ea52176acfd">alterSystemProperties</a> endpoint is primarily used to simplify the testing of the system and is not expected to be used during normal execution. </p>
        <p>Commands are given through the <span>propertyUpdatesMap</span> whose keys are commands and values are strings representing integer values (for example '8000') or boolean values ('true' or 'false').</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>propertyUpdatesMap</td>

                <td>
                  Map containing the properties of the system to be updated. Error if empty.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a22850a051b782f78fb8b3e2eeff44295">alter\_system\_properties\_concurrent\_kernel\_execution</a>: Enables concurrent kernel execution if the value is <a href="/content/api/cpp/namespacegpudb#a0e9062d07411faa828964cf824ee42aa">true</a> and disables it if the value is <a href="/content/api/cpp/namespacegpudb#ad3d908e9e936e52db5736fe08079c472">false</a>. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a0e9062d07411faa828964cf824ee42aa">alter\_system\_properties\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad3d908e9e936e52db5736fe08079c472">alter\_system\_properties\_false</a> </li>
                      </ul>
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a5f0d2c881c38007d414e286edeea27a8">alter\_system\_properties\_subtask\_concurrency\_limit</a>: Sets the maximum number of simultaneous threads allocated to a given request, on each rank. Note that thread allocation may also be limited by resource group limits and/or system load. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a0bbda36574dbd742118d883e67f40173">alter\_system\_properties\_chunk\_size</a>: Sets the number of records per chunk to be used for all new tables. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#af1f417b747c72687bb4a49e6d2d7747b">alter\_system\_properties\_chunk\_column\_max\_memory</a>: Sets the target maximum data size for each column in a chunk to be used for all new tables. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a2a918290a2696c92cf6260ae5a003397">alter\_system\_properties\_chunk\_max\_memory</a>: Indicates the target maximum data size for all columns in a chunk to be used for all new tables. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a1667a688917436da05bdf49bd23aa0eb">alter\_system\_properties\_execution\_mode</a>: Sets the execution\_mode for kernel executions to the specified string value. Possible values are host, device, default (engine decides) or an integer value that indicates max chunk size to exec on host. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ae11ec4253fa290777d9fd2837967d72b">alter\_system\_properties\_external\_files\_directory</a>: Sets the root directory path where external table data files are accessed from. Path must exist on the head node. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ace6ae643f8e0ca48bec6bf1453987439">alter\_system\_properties\_request\_timeout</a>: Number of minutes after which filtering (e.g., <a href="#ac5b65e73c01c331f1fcfb21b0e8d67ce">filter</a>) and aggregating (e.g., <a href="#a30cac962c6aedc8efc312e2b4217ff31">aggregateGroupBy</a>) queries will timeout. The default value is '20'. The minimum allowed value is '0'. The maximum allowed value is '1440'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a9d19bc5aa29d4682fb8210265a60dd3b">alter\_system\_properties\_max\_get\_records\_size</a>: The maximum number of records the database will serve for a given data retrieval call. The default value is '20000'. The minimum allowed value is '0'. The maximum allowed value is '1000000'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ad1ec975031a69ed06235e7fb5fbafe7c">alter\_system\_properties\_enable\_audit</a>: Enable or disable auditing. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a18fff2ce51b68a792cb8bea59a6555f6">alter\_system\_properties\_audit\_headers</a>: Enable or disable auditing of request headers. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a862b7d472d415962e441b4fc4450c257">alter\_system\_properties\_audit\_body</a>: Enable or disable auditing of request bodies. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a60d78ff1762a9f4fcc5c4dd68626c8df">alter\_system\_properties\_audit\_data</a>: Enable or disable auditing of request data. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a2311d85c0ac58442245b61e3761a232b">alter\_system\_properties\_audit\_response</a>: Enable or disable auditing of response information. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ac7e6701f944d6f0d8bbba79b47f13273">alter\_system\_properties\_shadow\_agg\_size</a>: Size of the shadow aggregate chunk cache in bytes. The default value is '10000000'. The minimum allowed value is '0'. The maximum allowed value is '2147483647'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a4a095115f9775eaac8fe8ff985c53a01">alter\_system\_properties\_shadow\_filter\_size</a>: Size of the shadow filter chunk cache in bytes. The default value is '10000000'. The minimum allowed value is '0'. The maximum allowed value is '2147483647'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ac828935a7629f2ca598294dc19f1148b">alter\_system\_properties\_enable\_overlapped\_equi\_join</a>: Enable overlapped-equi-join filter. The default value is 'true'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a386a4759aebd93ff665db6891935c2c1">alter\_system\_properties\_enable\_one\_step\_compound\_equi\_join</a>: Enable the one\_step compound-equi-join algorithm. The default value is 'true'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a0774082ecd58b64e9c7713309acdfae1">alter\_system\_properties\_kafka\_batch\_size</a>: Maximum number of records to be ingested in a single batch. The default value is '1000'. The minimum allowed value is '1'. The maximum allowed value is '10000000'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ae72a30f76a129dda553966b2b8cf2057">alter\_system\_properties\_kafka\_poll\_timeout</a>: Maximum time (milliseconds) for each poll to get records from Kafka. The default value is '0'. The minimum allowed value is '0'. The maximum allowed value is '1000'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ae17254a139c63273c2d7f2af2ea74d2e">alter\_system\_properties\_kafka\_wait\_time</a>: Maximum time (seconds) to buffer records received from Kafka before ingestion. The default value is '30'. The minimum allowed value is '1'. The maximum allowed value is '120'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a85d404d7a18381ef9afbd83097ccc215">alter\_system\_properties\_datalake\_table\_metadata\_cache\_enabled</a>: Enable caching of datalake table metadata. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#af0177491dd15d97dc84545eef27f96e5">alter\_system\_properties\_datalake\_table\_metadata\_cache\_size</a>: Maximum number of datalake table metadata entries to cache. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aa3716051baf36cd7fab9aaa61b9f9f6b">alter\_system\_properties\_datalake\_table\_metadata\_cache\_ttl</a>: Time-to-live (seconds) for cached datalake table metadata entries. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a4f7d879804559b8251b8035ac2422a44">alter\_system\_properties\_datalake\_table\_metadata\_cache\_snapshot\_check</a>: When enabled, check the current datalake snapshot on cache hits and invalidate entries that have changed. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ab6d5302e1c2206ee7852c353ac19d8f2">alter\_system\_properties\_datalake\_catalog\_connection\_cache\_size</a>: Maximum number of cached datalake REST catalog connections. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a452bf7919583a09d4b5ae4aee1fdd22b">alter\_system\_properties\_iceberg\_manifest\_cache\_enabled</a>: Enable caching of parsed Iceberg manifest and manifest-list files. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a8c3480527c4de651c93e694e4cb81b91">alter\_system\_properties\_egress\_parquet\_compression</a>: Parquet file compression type. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ab5703cbdaeb566b9fe6a3aecd54d7049">alter\_system\_properties\_uncompressed</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aba3f53f48f98ea6358be653e82703456">alter\_system\_properties\_snappy</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a6c48fa5a6d5562c1d2a9c4d3cd9522d8">alter\_system\_properties\_gzip</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#aba3f53f48f98ea6358be653e82703456">alter\_system\_properties\_snappy</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a9d662bb0a8b616ead8e3baf55e0a3580">alter\_system\_properties\_egress\_single\_file\_max\_size</a>: Max file size (in MB) to allow saving to a single file. May be overridden by target limitations. The default value is '10000'. The minimum allowed value is '1'. The maximum allowed value is '200000'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aadb28310a3215b948fb0940a3a5a5f7f">alter\_system\_properties\_max\_concurrent\_kernels</a>: Sets the max\_concurrent\_kernels value of the conf. The minimum allowed value is '0'. The maximum allowed value is '256'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a1741aff06a18466c951582bff4eaf382">alter\_system\_properties\_system\_metadata\_retention\_period</a>: Sets the system\_metadata.retention\_period value of the conf. The minimum allowed value is '1'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ad351579fddd53208f6f7dddefad0a0a8">alter\_system\_properties\_tcs\_per\_tom</a>: Size of the worker rank data calculation thread pool. This is primarily used for computation-based operations such as aggregates and record retrieval. The minimum allowed value is '2'. The maximum allowed value is '8192'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a649f9cb1527592e2a3db237cbdfe3525">alter\_system\_properties\_tps\_per\_tom</a>: Size of the worker rank data processing thread pool. This includes operations such as inserts, updates, and deletes on table data. Multi-head inserts are not affected by this limit. The minimum allowed value is '2'. The maximum allowed value is '8192'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a85622441fec9b9790ef72e17db99f1c5">alter\_system\_properties\_remote\_io\_threads</a>: Size of the worker rank IO thread pool. This is used for blocking IO operations such as reads from object storage or external file systems. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a34ecd6bdf51217b2b3adaefed2964fe6">alter\_system\_properties\_background\_worker\_threads</a>: Size of the worker rank background thread pool. This includes background operations such as watermark evictions catalog table updates. The minimum allowed value is '1'. The maximum allowed value is '8192'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a9a4db71e34c6ad80a4b9588bf26625fe">alter\_system\_properties\_log\_debug\_job\_info</a>: Outputs various job-related information to the rank logs. Used for troubleshooting. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a6f4e03f352f107842f06e5f240a17cf7">alter\_system\_properties\_enable\_thread\_hang\_logging</a>: Log a stack trace for any thread that runs longer than a defined threshold. Used for troubleshooting. The default value is 'true'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a609ed0fa0949d51d085c8a01b34e95aa">alter\_system\_properties\_ai\_enable\_rag</a>: Enable RAG. The default value is 'false'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aab7d775fc6d131009bcb30471b575359">alter\_system\_properties\_ai\_api\_provider</a>: AI API provider type. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a0bd5c9c6ed35803da5dee2a0b06d09be">alter\_system\_properties\_ai\_api\_url</a>: AI API URL. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a81868a961c879e6cd9438944145fa5cd">alter\_system\_properties\_ai\_api\_key</a>: AI API key. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ace0f3e6c175fd132fe1c9a33c2bc7717">alter\_system\_properties\_ai\_api\_connection\_timeout</a>: AI API connection timeout in seconds. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#abac5f9f26776e4f4ee4658aedd1b03d5">alter\_system\_properties\_ai\_api\_embeddings\_model</a>: AI API model name. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a14b8d0203e2e39f2d6be95af5ef35e88">alter\_system\_properties\_telm\_persist\_query\_metrics</a>: Enable or disable persisting of query metrics. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a3a500d46bff89bddb9f584533e553063">alter\_system\_properties\_telm\_force\_metrics\_duration</a>: Capture metrics for any query exceeding this duration in seconds. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a7995b35a8289b987c262f94d57a41bb1">alter\_system\_properties\_postgres\_proxy\_idle\_connection\_timeout</a>: Idle connection timeout in seconds. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a743d04922fbb1816913aca06a6a95680">alter\_system\_properties\_postgres\_proxy\_keep\_alive</a>: Enable postgres proxy keep alive. The default value is 'false'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a7c3c1033aebede98d42fc6a526472e62">alter\_system\_properties\_kifs\_directory\_data\_limit</a>: The default maximum capacity to apply when creating a KiFS directory (bytes). The minimum allowed value is '-1'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a066c28103dafad970fd31f5a4877a11e">alter\_system\_properties\_compression\_codec</a>: The default <a href="/content/concepts/column_compression/">compression algorithm</a> applied to any column without a column-level or table-level default compression specified at the time it was created. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a0f5098870fe6aa5227c9d460e07c610f">alter\_system\_properties\_disk\_auto\_optimize\_timeout</a>: Time interval in seconds after which the database will apply optimizations/transformations to persisted data, such as compression. The minimum allowed value is '0'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a9afc6469497c3fd3a22d2077ee43f496">alter\_system\_properties\_ha\_consumer\_replay\_offset</a>: Initializes HA replay from the given timestamp (as milliseconds since unix epoch). The minimum allowed value is '-1'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a5453715e68f2cd12c9159e87cae830a0">alter\_system\_properties\_admin\_access\_only</a>: Restricts access to system admin users only. The default value is 'false'. </li>
                  </ul>
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ae3c5f4d2c3729918d15cc0c75e117005">alter\_system\_properties\_evict\_to\_cold</a>: If <a href="/content/api/cpp/namespacegpudb#a0e9062d07411faa828964cf824ee42aa">true</a> and evict\_columns is specified, the given objects will be evicted to cold storage (if such a tier exists). Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a0e9062d07411faa828964cf824ee42aa">alter\_system\_properties\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad3d908e9e936e52db5736fe08079c472">alter\_system\_properties\_false</a> </li>
                      </ul>
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a9644f40aabe27fa1fab75860aceebded">alter\_system\_properties\_persist</a>: If <a href="/content/api/cpp/namespacegpudb#a0e9062d07411faa828964cf824ee42aa">true</a> the system configuration will be written to disk upon successful application of this request. This will commit the changes from this request and any additional in-memory modifications. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a0e9062d07411faa828964cf824ee42aa">alter\_system\_properties\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad3d908e9e936e52db5736fe08079c472">alter\_system\_properties\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a0e9062d07411faa828964cf824ee42aa">alter\_system\_properties\_true</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AlterSystemPropertiesResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AlterSystemPropertiesResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#aeddf28ff22f4a296e4b00864bf251f79">◆ </a></span>alterTable() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AlterTableResponse">AlterTableResponse</a> gpudb::GPUdb::alterTable </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1AlterTableRequest">AlterTableRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Apply various modifications to a table or view. </p>
        <p>The available modifications include the following:</p>
        <p>Manage a table's columns–a column can be added, removed, or have its <a href="/content/concepts/types/">type and properties</a> modified, including whether it is <a href="/content/concepts/dictionary_encoding/">dictionary encoded</a> or not.</p>
        <p>External tables cannot be modified except for their refresh method.</p>
        <p>Create or delete a <a href="/content/concepts/indexes/#column-index">column</a>, <a href="/content/concepts/indexes/#low-cardinality-index">low-cardinality index</a>, <a href="/content/concepts/indexes/#chunk-skip-index">chunk skip</a>, <a href="/content/concepts/indexes/#geospatial-index">geospatial</a>, <a href="/content/concepts/indexes/#cagra-index">CAGRA</a>, or <a href="/content/concepts/indexes/#hnsw-index">HNSW</a> index. This can speed up certain operations when using expressions containing equality or relational operators on indexed columns. This only applies to tables.</p>
        <p>Create or delete a <a href="/content/concepts/tables/#foreign-key">foreign key</a> on a particular column.</p>
        <p>Manage a <a href="/content/concepts/tables/#partitioning-by-range">range-partitioned</a> or a <a href="/content/concepts/tables/#partitioning-by-list-manual">manual list-partitioned</a> table's partitions.</p>
        <p>Set (or reset) the <a href="/content/rm/concepts/#tier-strategies">tier strategy</a> of a table or view.</p>
        <p>Refresh and manage the refresh mode of a <a href="/content/concepts/materialized_views/">materialized view</a> or an <a href="/content/concepts/external_tables/">external table</a>.</p>
        <p>Set the <a href="/content/concepts/ttl/">time-to-live (TTL)</a>. This can be applied to tables or views.</p>
        <p>Set the global access mode (i.e. locking) for a table. This setting trumps any role-based access controls that may be in place; e.g., a user with write access to a table marked read-only will not be able to insert records into it. The mode can be set to read-only, write-only, read/write, and no access.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AlterTableRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AlterTableResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#af5f1590fded46609425461f4b8ce06c4">◆ </a></span>alterTable() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AlterTableResponse">AlterTableResponse</a> & gpudb::GPUdb::alterTable </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1AlterTableRequest">AlterTableRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1AlterTableResponse">AlterTableResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Apply various modifications to a table or view. </p>
        <p>The available modifications include the following:</p>
        <p>Manage a table's columns–a column can be added, removed, or have its <a href="/content/concepts/types/">type and properties</a> modified, including whether it is <a href="/content/concepts/dictionary_encoding/">dictionary encoded</a> or not.</p>
        <p>External tables cannot be modified except for their refresh method.</p>
        <p>Create or delete a <a href="/content/concepts/indexes/#column-index">column</a>, <a href="/content/concepts/indexes/#low-cardinality-index">low-cardinality index</a>, <a href="/content/concepts/indexes/#chunk-skip-index">chunk skip</a>, <a href="/content/concepts/indexes/#geospatial-index">geospatial</a>, <a href="/content/concepts/indexes/#cagra-index">CAGRA</a>, or <a href="/content/concepts/indexes/#hnsw-index">HNSW</a> index. This can speed up certain operations when using expressions containing equality or relational operators on indexed columns. This only applies to tables.</p>
        <p>Create or delete a <a href="/content/concepts/tables/#foreign-key">foreign key</a> on a particular column.</p>
        <p>Manage a <a href="/content/concepts/tables/#partitioning-by-range">range-partitioned</a> or a <a href="/content/concepts/tables/#partitioning-by-list-manual">manual list-partitioned</a> table's partitions.</p>
        <p>Set (or reset) the <a href="/content/rm/concepts/#tier-strategies">tier strategy</a> of a table or view.</p>
        <p>Refresh and manage the refresh mode of a <a href="/content/concepts/materialized_views/">materialized view</a> or an <a href="/content/concepts/external_tables/">external table</a>.</p>
        <p>Set the <a href="/content/concepts/ttl/">time-to-live (TTL)</a>. This can be applied to tables or views.</p>
        <p>Set the global access mode (i.e. locking) for a table. This setting trumps any role-based access controls that may be in place; e.g., a user with write access to a table marked read-only will not be able to insert records into it. The mode can be set to read-only, write-only, read/write, and no access.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AlterTableRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AlterTableResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AlterTableResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a25df43fa85e02f0cdb3dab9e498995ce">◆ </a></span>alterTable() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AlterTableResponse">AlterTableResponse</a> gpudb::GPUdb::alterTable </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>action</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>value</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Apply various modifications to a table or view. </p>
        <p>The available modifications include the following:</p>
        <p>Manage a table's columns–a column can be added, removed, or have its <a href="/content/concepts/types/">type and properties</a> modified, including whether it is <a href="/content/concepts/dictionary_encoding/">dictionary encoded</a> or not.</p>
        <p>External tables cannot be modified except for their refresh method.</p>
        <p>Create or delete a <a href="/content/concepts/indexes/#column-index">column</a>, <a href="/content/concepts/indexes/#low-cardinality-index">low-cardinality index</a>, <a href="/content/concepts/indexes/#chunk-skip-index">chunk skip</a>, <a href="/content/concepts/indexes/#geospatial-index">geospatial</a>, <a href="/content/concepts/indexes/#cagra-index">CAGRA</a>, or <a href="/content/concepts/indexes/#hnsw-index">HNSW</a> index. This can speed up certain operations when using expressions containing equality or relational operators on indexed columns. This only applies to tables.</p>
        <p>Create or delete a <a href="/content/concepts/tables/#foreign-key">foreign key</a> on a particular column.</p>
        <p>Manage a <a href="/content/concepts/tables/#partitioning-by-range">range-partitioned</a> or a <a href="/content/concepts/tables/#partitioning-by-list-manual">manual list-partitioned</a> table's partitions.</p>
        <p>Set (or reset) the <a href="/content/rm/concepts/#tier-strategies">tier strategy</a> of a table or view.</p>
        <p>Refresh and manage the refresh mode of a <a href="/content/concepts/materialized_views/">materialized view</a> or an <a href="/content/concepts/external_tables/">external table</a>.</p>
        <p>Set the <a href="/content/concepts/ttl/">time-to-live (TTL)</a>. This can be applied to tables or views.</p>
        <p>Set the global access mode (i.e. locking) for a table. This setting trumps any role-based access controls that may be in place; e.g., a user with write access to a table marked read-only will not be able to insert records into it. The mode can be set to read-only, write-only, read/write, and no access.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Table on which the operation will be performed, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. Must be an existing table or view. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>action</td>

                <td>
                  Modification operation to be applied. Supported values:

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a61a3d3555d776e54a22d87b9eb246eec">alter\_table\_create\_index</a>: Creates a <a href="/content/concepts/indexes/#column-index">column (attribute) index</a>, <a href="/content/concepts/indexes/#low-cardinality-index">low-cardinality index</a>, <a href="/content/concepts/indexes/#chunk-skip-index">chunk skip index</a>, <a href="/content/concepts/indexes/#geospatial-index">geospatial index</a>, <a href="/content/concepts/indexes/#cagra-index">CAGRA index</a>, or <a href="/content/concepts/indexes/#hnsw-index">HNSW index</a> (depending on the specified <a href="/content/api/cpp/namespacegpudb#ae45d91b6b09aac66c4d164f6eceaa029">index\_type</a>), on the column name specified in <span>value</span>. If this column already has the specified index, an error will be returned. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a6cbb52f844d813d2d63dc411cf89e92d">alter\_table\_refresh\_index</a>: Refreshes an index identified by <a href="/content/api/cpp/namespacegpudb#ae45d91b6b09aac66c4d164f6eceaa029">index\_type</a>, on the column name specified in <span>value</span>. Currently applicable only to CAGRA indices. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aea087240e49b139892b1c5190354d82d">alter\_table\_delete\_index</a>: Deletes a <a href="/content/concepts/indexes/#column-index">column (attribute) index</a>, <a href="/content/concepts/indexes/#low-cardinality-index">low-cardinality index</a>, <a href="/content/concepts/indexes/#chunk-skip-index">chunk skip index</a>, <a href="/content/concepts/indexes/#geospatial-index">geospatial index</a>, <a href="/content/concepts/indexes/#cagra-index">CAGRA index</a>, or <a href="/content/concepts/indexes/#hnsw-index">HNSW index</a> (depending on the specified <a href="/content/api/cpp/namespacegpudb#ae45d91b6b09aac66c4d164f6eceaa029">index\_type</a>), on the column name specified in <span>value</span>. If this column does not have the specified index, an error will be returned. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a1e24a0c927b47860647fc4bfdc36f5a0">alter\_table\_move\_to\_collection</a>: \[DEPRECATED–please use <a href="/content/api/cpp/namespacegpudb#af4c4949400af0018bd906272ba715f05">move\_to\_schema</a> and use <a href="#a33d9a0a8e738d14b688f9f869f9640ad">createSchema</a> to create the schema if non-existent] Moves a table or view into a schema named <span>value</span>. If the schema provided is non-existent, it will be automatically created. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#af4c4949400af0018bd906272ba715f05">alter\_table\_move\_to\_schema</a>: Moves a table or view into a schema named <span>value</span>. If the schema provided is nonexistent, an error will be thrown. If <span>value</span> is empty, then the table or view will be placed in the user's default schema. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#acbd920363573eaaf3f6532939bd79382">alter\_table\_protected</a>: No longer used. Previously set whether the given <span>tableName</span> should be protected or not. The <span>value</span> would have been either 'true' or 'false'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a33a4ebfcaf7ff881527272eb865e7fd0">alter\_table\_rename\_table</a>: Renames a table or view to <span>value</span>. Has the same naming restrictions as <a href="/content/concepts/tables/">tables</a>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ae2428730bb25f05d1d1498d0353cc437">alter\_table\_ttl</a>: Sets the <a href="/content/concepts/ttl/">time-to-live</a> in minutes of the table or view specified in <span>tableName</span>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a6c3f0f2d750ce0b65a38d02d68b32505">alter\_table\_add\_comment</a>: Adds the comment specified in <span>value</span> to the table specified in <span>tableName</span>. Use <a href="/content/api/cpp/namespacegpudb#a5d176b935e01fadbaf89b1399c9927d6">column\_name</a> to set the comment for a column. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ab26622ef8cb73d6ebdbc8617a23c919a">alter\_table\_add\_column</a>: Adds the column specified in <span>value</span> to the table specified in <span>tableName</span>. Use <a href="/content/api/cpp/namespacegpudb#ade84c63352d9cf5f7afa95060ba72ce7">column\_type</a> and <a href="/content/api/cpp/namespacegpudb#ab8967385a2df912ad40083fa2d502c37">column\_properties</a> in <span>options</span> to set the column's type and properties, respectively. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aa8db13cca2ed30ee66298f68676f17e8">alter\_table\_change\_column</a>: Changes type and properties of the column specified in <span>value</span>. Use <a href="/content/api/cpp/namespacegpudb#ade84c63352d9cf5f7afa95060ba72ce7">column\_type</a> and <a href="/content/api/cpp/namespacegpudb#ab8967385a2df912ad40083fa2d502c37">column\_properties</a> in <span>options</span> to set the column's type and properties, respectively. Note that primary key and/or shard key columns cannot be changed. All unchanging column properties must be listed for the change to take place, e.g., to add dictionary encoding to an existing 'char4' column, both 'char4' and 'dict' must be specified in the <span>options</span> map. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a53129ded98f799f9a026d95ffd6f7993">alter\_table\_delete\_column</a>: Deletes the column specified in <span>value</span> from the table specified in <span>tableName</span>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ac816ddca3ced809662864e38962062a8">alter\_table\_set\_default</a>: Sets or replaces the default value expression for the column specified in <span>value</span>. The new default is taken from <a href="/content/api/cpp/namespacegpudb#ad1fbccc3359d4a8e1dc19fedf593c09e">add\_column\_expression</a>. Existing properties on the column are preserved. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a51b6858f57dc3670daa5c9c0b06f13fc">alter\_table\_delete\_default</a>: Removes the default value expression from the column specified in <span>value</span>. Other column properties are preserved. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ad2a7f7bf4f05a0a454486179b6f77eb4">alter\_table\_create\_foreign\_key</a>: Creates a <a href="/content/concepts/tables/#foreign-key">foreign key</a> specified in <span>value</span> using the format '(source\_column\_name \[, ...]) references target\_table\_name(primary\_key\_column\_name \[, ...]) \[as foreign\_key\_name]'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ac658d84660e2a6b1becb78868d630370">alter\_table\_delete\_foreign\_key</a>: Deletes a <a href="/content/concepts/tables/#foreign-key">foreign key</a>. The <span>value</span> should be the foreign\_key\_name specified when creating the key or the complete string used to define it. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a1582445698ace2af0684b57096748ad2">alter\_table\_add\_partition</a>: Adds the partition specified in <span>value</span>, to either a <a href="/content/concepts/tables/#partitioning-by-range">range-partitioned</a> or <a href="/content/concepts/tables/#partitioning-by-list-manual">manual list-partitioned</a> table. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aca5c017766ac81d518341467c6f05a6f">alter\_table\_remove\_partition</a>: Removes the partition specified in <span>value</span> (and relocates all of its data to the default partition) from either a <a href="/content/concepts/tables/#partitioning-by-range">range-partitioned</a> or <a href="/content/concepts/tables/#partitioning-by-list-manual">manual list-partitioned</a> table. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ac2ed317f76b92d6b350d9bc4d3b22d5e">alter\_table\_delete\_partition</a>: Deletes the partition specified in <span>value</span> (and all of its data) from either a <a href="/content/concepts/tables/#partitioning-by-range">range-partitioned</a> or <a href="/content/concepts/tables/#partitioning-by-list-manual">manual list-partitioned</a> table. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a464b6ea3f2247ace2e23b46f23d79046">alter\_table\_set\_global\_access\_mode</a>: Sets the global access mode (i.e. locking) for the table specified in <span>tableName</span>. Specify the access mode in <span>value</span>. Valid modes are 'no\_access', 'read\_only', 'write\_only' and 'read\_write'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a8d759c0d75c8a2a3613aee73455073d3">alter\_table\_refresh</a>: For a <a href="/content/concepts/materialized_views/">materialized view</a>, replays all the table creation commands required to create the view. For an <a href="/content/concepts/external_tables/">external table</a>, reloads all data in the table from its associated source files or <a href="/content/concepts/data_sources/">data source</a>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a4a432c4c81f16fa40b77966ee2f8fb89">alter\_table\_set\_refresh\_method</a>: For a <a href="/content/concepts/materialized_views/">materialized view</a>, sets the method by which the view is refreshed to the method specified in <span>value</span> - one of 'manual', 'periodic', or 'on\_change'. For an <a href="/content/concepts/external_tables/">external table</a>, sets the method by which the table is refreshed to the method specified in <span>value</span> - either 'manual' or 'on\_start'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a0bc213f6974474fc3b9e8efe002ad312">alter\_table\_set\_refresh\_start\_time</a>: Sets the time to start periodic refreshes of this <a href="/content/concepts/materialized_views/">materialized view</a> to the datetime string specified in <span>value</span> with format 'YYYY-MM-DD HH:MM:SS'. Subsequent refreshes occur at the specified time + N \* the refresh period. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a6cb6b0ba725240e56a3a9b2f1a9f742b">alter\_table\_set\_refresh\_stop\_time</a>: Sets the time to stop periodic refreshes of this <a href="/content/concepts/materialized_views/">materialized view</a> to the datetime string specified in <span>value</span> with format 'YYYY-MM-DD HH:MM:SS'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aece060613249681fc3f7f2480f70a489">alter\_table\_set\_refresh\_period</a>: Sets the time interval in seconds at which to refresh this <a href="/content/concepts/materialized_views/">materialized view</a> to the value specified in <span>value</span>. Also, sets the refresh method to periodic if not already set. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a17c04447e6065303dbae9c6c4e6d8049">alter\_table\_set\_refresh\_span</a>: Sets the future time-offset(in seconds) for the view refresh to stop. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a715c3791e9cb75d82a72c44928a7e126">alter\_table\_set\_refresh\_execute\_as</a>: Sets the user name to refresh this <a href="/content/concepts/materialized_views/">materialized view</a> to the value specified in <span>value</span>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a417e3980ec9597b0decdd5a23ed7fb9e">alter\_table\_remove\_text\_search\_attributes</a>: Removes <a href="/content/concepts/full_text_search/">text search</a> attribute from all columns. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a9fb836f46fa9b85a368cfcf275f7686e">alter\_table\_remove\_shard\_keys</a>: Removes the shard key property from all columns, so that the table will be considered randomly sharded. The data is not moved. The <span>value</span> is ignored. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aa704cf1d95cab2869445fcdeb6016f57">alter\_table\_set\_strategy\_definition</a>: Sets the <a href="/content/rm/concepts/#tier-strategies">tier strategy</a> for the table and its columns to the one specified in <span>value</span>, replacing the existing tier strategy in its entirety. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a6d217f80058dc7e6b5f298c000d2e979">alter\_table\_cancel\_datasource\_subscription</a>: Permanently unsubscribe a data source that is loading continuously as a stream. The data source can be Kafka / S3 / Azure / GCS. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a35b780acb1b2835c1a5b4dc844d0fae8">alter\_table\_drop\_datasource\_subscription</a>: Permanently delete a cancelled data source subscription. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a153cc82400703940e6019ffe616f911e">alter\_table\_pause\_datasource\_subscription</a>: Temporarily unsubscribe a data source that is loading continuously as a stream. The data source can be Kafka / S3 / Azure / GCS. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ab078a450111aa405c12460e8067a7845">alter\_table\_resume\_datasource\_subscription</a>: Resubscribe to a paused data source subscription. The data source can be Kafka / S3 / Azure / GCS. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ac6fc917bc78a667b261334745b72ecda">alter\_table\_change\_owner</a>: Change the owner resource group of the table. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aaee282b8ce507cd894083204cf8e1385">alter\_table\_set\_load\_vectors\_policy</a>: Set startup data loading scheme for the table; see description of 'load\_vectors\_policy' in <a href="#afa4ded9fdb07b49b4b1cb0835b5ac52a">createTable</a> for possible values for <span>value</span>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a659310c4c57c90d58a562f4f3a4b7634">alter\_table\_set\_build\_pk\_index\_policy</a>: Set startup primary key generation scheme for the table; see description of 'build\_pk\_index\_policy' in <a href="#afa4ded9fdb07b49b4b1cb0835b5ac52a">createTable</a> for possible values for <span>value</span>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ab1bee14a4b34e7b27d3e480f9c567c53">alter\_table\_set\_build\_materialized\_view\_policy</a>: Set startup rebuilding scheme for the materialized view; see description of 'build\_materialized\_view\_policy' in <a href="#a4c585a19766a2de5755448429f034b61">createMaterializedView</a> for possible values for <span>value</span>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#af864c0816b4ded83d36ff4938ec57d12">alter\_table\_rebuild\_text\_search\_index</a>: Drops and rebuilds the <a href="/content/concepts/full_text_search/">text search</a> index for the table from current type metadata and chunk storage. Use this to repair a text-search index left incomplete by an interrupted or failed rebuild (for example, after a crash during an add-column that requested text search): re-running the original add\_column will not work because the column already exists. This action is also dispatched automatically by <a href="#a9ce980a546b63a37ceed13ad5fa137c6">alterTableColumns</a> after add\_column completions that require a full re-index. The <span>value</span> is ignored. </li>
                  </ul>
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>value</td>
                <td>The value of the modification, depending on <span>action</span>. For example, if <span>action</span> is <a href="/content/api/cpp/namespacegpudb#ab26622ef8cb73d6ebdbc8617a23c919a">add\_column</a>, this would be the column name; while the column's definition would be covered by the <a href="/content/api/cpp/namespacegpudb#ade84c63352d9cf5f7afa95060ba72ce7">column\_type</a>, <a href="/content/api/cpp/namespacegpudb#ab8967385a2df912ad40083fa2d502c37">column\_properties</a>, <a href="/content/api/cpp/namespacegpudb#ac183a60b3d94fa535d9a2704dab254e3">column\_default\_value</a>, and <a href="/content/api/cpp/namespacegpudb#ad1fbccc3359d4a8e1dc19fedf593c09e">add\_column\_expression</a> in <span>options</span>. If <span>action</span> is <a href="/content/api/cpp/namespacegpudb#ae2428730bb25f05d1d1498d0353cc437">ttl</a>, it would be the number of minutes for the new TTL. If <span>action</span> is <a href="/content/api/cpp/namespacegpudb#a8d759c0d75c8a2a3613aee73455073d3">refresh</a>, this field would be blank. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#ad9757356f8c54d003da66770b9423b1a">alter\_table\_action</a> </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a5d176b935e01fadbaf89b1399c9927d6">alter\_table\_column\_name</a> </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#af771c45c75e79bbdad5c0223d11b93fa">alter\_table\_table\_name</a> </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ac183a60b3d94fa535d9a2704dab254e3">alter\_table\_column\_default\_value</a>: When adding a column, set a literal default value for existing records. For nullable columns, the default value will be null, regardless of data type. Also persisted as the column's default for future inserts that omit the column. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ab8967385a2df912ad40083fa2d502c37">alter\_table\_column\_properties</a>: When adding or changing a column, set the column properties (strings, separated by a comma: data, text\_search, char8, int8 etc). </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ade84c63352d9cf5f7afa95060ba72ce7">alter\_table\_column\_type</a>: When adding or changing a column, set the column type (strings, separated by a comma: int, double, string, null etc). </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a3e637eeb359b539c25a2cec6e3ec9624">alter\_table\_copy\_values\_from\_column</a>: \[DEPRECATED] Please use <a href="/content/api/cpp/namespacegpudb#ad1fbccc3359d4a8e1dc19fedf593c09e">add\_column\_expression</a> instead. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a5ab2b041e1e2e951b16982011251ca2c">alter\_table\_rename\_column</a>: When changing a column, specify new column name. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#aaa264d934ae214ceb6c2953b3adbfc78">alter\_table\_validate\_change\_column</a>: When changing a column, validate the change before applying it (or not). Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a33d3f81532f0849fd6c710ed8a1e7d9b">alter\_table\_true</a>: Validate all values. A value too large (or too long) for the new type will prevent any change. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a0fdf6e8d4a69a4f89a3c3a5460c044bb">alter\_table\_false</a>: When a value is too large or long, it will be truncated. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a33d3f81532f0849fd6c710ed8a1e7d9b">alter\_table\_true</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ac98b8c510e709580a7d50ba2ff6f590f">alter\_table\_update\_last\_access\_time</a>: Indicates whether the <a href="/content/concepts/ttl/">time-to-live</a> (TTL) expiration countdown timer should be reset to the table's TTL. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a33d3f81532f0849fd6c710ed8a1e7d9b">alter\_table\_true</a>: Reset the expiration countdown timer to the table's configured TTL. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a0fdf6e8d4a69a4f89a3c3a5460c044bb">alter\_table\_false</a>: Don't reset the timer; expiration countdown will continue from where it is, as if the table had not been accessed. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a33d3f81532f0849fd6c710ed8a1e7d9b">alter\_table\_true</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#ad1fbccc3359d4a8e1dc19fedf593c09e">alter\_table\_add\_column\_expression</a>: When adding a column or setting a new default with <span>action</span> set to <a href="/content/api/cpp/namespacegpudb#ac816ddca3ced809662864e38962062a8">set\_default</a>, the new default expression (GPUdb-syntax) for the column. Any valid expression may be used, including one containing references to existing columns in the same table. Persisted as the column's default for future inserts that omit the column; for add\_column, also used to backfill existing rows. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a6ffb0dd7003c31772cc3258cafd19eb1">alter\_table\_add\_column\_expression\_sql</a>: Optional SQL-syntax form of <a href="/content/api/cpp/namespacegpudb#ad1fbccc3359d4a8e1dc19fedf593c09e">add\_column\_expression</a>, used only when the SQL syntax differs from the <a href="/content/api/cpp/classgpudb_1_1GPUdb">GPUdb</a> syntax. Persisted alongside the <a href="/content/api/cpp/classgpudb_1_1GPUdb">GPUdb</a> form so SHOW CREATE TABLE / information\_schema can reproduce the original SQL. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a84d34939de1e02c56d31e5c48edd5572">alter\_table\_strategy\_definition</a>: Parameter for specifying the <a href="/content/rm/concepts/#tier-strategies">tier strategy</a> for the table and its columns when <span>action</span> is <a href="/content/api/cpp/namespacegpudb#aa704cf1d95cab2869445fcdeb6016f57">set\_strategy\_definition</a>, replacing the existing tier strategy in its entirety. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ae45d91b6b09aac66c4d164f6eceaa029">alter\_table\_index\_type</a>: <a href="/content/api/cpp/classgpudb_1_1Type">Type</a> of index to create, when <span>action</span> is <a href="/content/api/cpp/namespacegpudb#a61a3d3555d776e54a22d87b9eb246eec">create\_index</a>; to refresh, when <span>action</span> is <a href="/content/api/cpp/namespacegpudb#a6cbb52f844d813d2d63dc411cf89e92d">refresh\_index</a>; or to delete, when <span>action</span> is <a href="/content/api/cpp/namespacegpudb#aea087240e49b139892b1c5190354d82d">delete\_index</a>. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a80f1703a203a5b90e1050af52496c604">alter\_table\_column</a>: Create or delete a <a href="/content/concepts/indexes/#column-index">column (attribute) index</a>. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a844c2b60a2199d9a589b187cabdf36d5">alter\_table\_low\_cardinality</a>: Create a <a href="/content/concepts/indexes/#low-cardinality-index">low-cardinality column (attribute) index</a>. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a920b7eb00e30386edc674aae2eeec5f8">alter\_table\_chunk\_skip</a>: Create or delete a <a href="/content/concepts/indexes/#chunk-skip-index">chunk skip index</a>. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a738abe2afa03e373b41c0eee8bc797da">alter\_table\_geospatial</a>: Create or delete a <a href="/content/concepts/indexes/#geospatial-index">geospatial index</a>. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aa4cb4163ec9c6faf5b18eaabf932824c">alter\_table\_cagra</a>: Create or delete a <a href="/content/concepts/indexes/#cagra-index">CAGRA index</a> on a <a href="/content/vector_search/#vector-type">vector column</a>. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a929362ad1dcd2c7d9863ca8388b2516b">alter\_table\_hnsw</a>: Create or delete an <a href="/content/concepts/indexes/#hnsw-index">HNSW index</a> on a <a href="/content/vector_search/#vector-type">vector column</a>. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a80f1703a203a5b90e1050af52496c604">alter\_table\_column</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#aa49b8ad4b8bbc614b4fe22aa90e48bb9">alter\_table\_index\_options</a>: <a href="/content/api/cpp/classgpudb_1_1GPUdb_1_1Options">Options</a> to use when creating an index, in the format "key: value \[, key: value \[, ...]]". Valid options vary by index type. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AlterTableResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ad081259f73604987cb28a53d129a3774">◆ </a></span>alterTable() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AlterTableResponse">AlterTableResponse</a> & gpudb::GPUdb::alterTable </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>action</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>value</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1AlterTableResponse">AlterTableResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Apply various modifications to a table or view. </p>
        <p>The available modifications include the following:</p>
        <p>Manage a table's columns–a column can be added, removed, or have its <a href="/content/concepts/types/">type and properties</a> modified, including whether it is <a href="/content/concepts/dictionary_encoding/">dictionary encoded</a> or not.</p>
        <p>External tables cannot be modified except for their refresh method.</p>
        <p>Create or delete a <a href="/content/concepts/indexes/#column-index">column</a>, <a href="/content/concepts/indexes/#low-cardinality-index">low-cardinality index</a>, <a href="/content/concepts/indexes/#chunk-skip-index">chunk skip</a>, <a href="/content/concepts/indexes/#geospatial-index">geospatial</a>, <a href="/content/concepts/indexes/#cagra-index">CAGRA</a>, or <a href="/content/concepts/indexes/#hnsw-index">HNSW</a> index. This can speed up certain operations when using expressions containing equality or relational operators on indexed columns. This only applies to tables.</p>
        <p>Create or delete a <a href="/content/concepts/tables/#foreign-key">foreign key</a> on a particular column.</p>
        <p>Manage a <a href="/content/concepts/tables/#partitioning-by-range">range-partitioned</a> or a <a href="/content/concepts/tables/#partitioning-by-list-manual">manual list-partitioned</a> table's partitions.</p>
        <p>Set (or reset) the <a href="/content/rm/concepts/#tier-strategies">tier strategy</a> of a table or view.</p>
        <p>Refresh and manage the refresh mode of a <a href="/content/concepts/materialized_views/">materialized view</a> or an <a href="/content/concepts/external_tables/">external table</a>.</p>
        <p>Set the <a href="/content/concepts/ttl/">time-to-live (TTL)</a>. This can be applied to tables or views.</p>
        <p>Set the global access mode (i.e. locking) for a table. This setting trumps any role-based access controls that may be in place; e.g., a user with write access to a table marked read-only will not be able to insert records into it. The mode can be set to read-only, write-only, read/write, and no access.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Table on which the operation will be performed, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. Must be an existing table or view. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>action</td>

                <td>
                  Modification operation to be applied. Supported values:

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a61a3d3555d776e54a22d87b9eb246eec">alter\_table\_create\_index</a>: Creates a <a href="/content/concepts/indexes/#column-index">column (attribute) index</a>, <a href="/content/concepts/indexes/#low-cardinality-index">low-cardinality index</a>, <a href="/content/concepts/indexes/#chunk-skip-index">chunk skip index</a>, <a href="/content/concepts/indexes/#geospatial-index">geospatial index</a>, <a href="/content/concepts/indexes/#cagra-index">CAGRA index</a>, or <a href="/content/concepts/indexes/#hnsw-index">HNSW index</a> (depending on the specified <a href="/content/api/cpp/namespacegpudb#ae45d91b6b09aac66c4d164f6eceaa029">index\_type</a>), on the column name specified in <span>value</span>. If this column already has the specified index, an error will be returned. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a6cbb52f844d813d2d63dc411cf89e92d">alter\_table\_refresh\_index</a>: Refreshes an index identified by <a href="/content/api/cpp/namespacegpudb#ae45d91b6b09aac66c4d164f6eceaa029">index\_type</a>, on the column name specified in <span>value</span>. Currently applicable only to CAGRA indices. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aea087240e49b139892b1c5190354d82d">alter\_table\_delete\_index</a>: Deletes a <a href="/content/concepts/indexes/#column-index">column (attribute) index</a>, <a href="/content/concepts/indexes/#low-cardinality-index">low-cardinality index</a>, <a href="/content/concepts/indexes/#chunk-skip-index">chunk skip index</a>, <a href="/content/concepts/indexes/#geospatial-index">geospatial index</a>, <a href="/content/concepts/indexes/#cagra-index">CAGRA index</a>, or <a href="/content/concepts/indexes/#hnsw-index">HNSW index</a> (depending on the specified <a href="/content/api/cpp/namespacegpudb#ae45d91b6b09aac66c4d164f6eceaa029">index\_type</a>), on the column name specified in <span>value</span>. If this column does not have the specified index, an error will be returned. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a1e24a0c927b47860647fc4bfdc36f5a0">alter\_table\_move\_to\_collection</a>: \[DEPRECATED–please use <a href="/content/api/cpp/namespacegpudb#af4c4949400af0018bd906272ba715f05">move\_to\_schema</a> and use <a href="#a33d9a0a8e738d14b688f9f869f9640ad">createSchema</a> to create the schema if non-existent] Moves a table or view into a schema named <span>value</span>. If the schema provided is non-existent, it will be automatically created. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#af4c4949400af0018bd906272ba715f05">alter\_table\_move\_to\_schema</a>: Moves a table or view into a schema named <span>value</span>. If the schema provided is nonexistent, an error will be thrown. If <span>value</span> is empty, then the table or view will be placed in the user's default schema. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#acbd920363573eaaf3f6532939bd79382">alter\_table\_protected</a>: No longer used. Previously set whether the given <span>tableName</span> should be protected or not. The <span>value</span> would have been either 'true' or 'false'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a33a4ebfcaf7ff881527272eb865e7fd0">alter\_table\_rename\_table</a>: Renames a table or view to <span>value</span>. Has the same naming restrictions as <a href="/content/concepts/tables/">tables</a>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ae2428730bb25f05d1d1498d0353cc437">alter\_table\_ttl</a>: Sets the <a href="/content/concepts/ttl/">time-to-live</a> in minutes of the table or view specified in <span>tableName</span>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a6c3f0f2d750ce0b65a38d02d68b32505">alter\_table\_add\_comment</a>: Adds the comment specified in <span>value</span> to the table specified in <span>tableName</span>. Use <a href="/content/api/cpp/namespacegpudb#a5d176b935e01fadbaf89b1399c9927d6">column\_name</a> to set the comment for a column. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ab26622ef8cb73d6ebdbc8617a23c919a">alter\_table\_add\_column</a>: Adds the column specified in <span>value</span> to the table specified in <span>tableName</span>. Use <a href="/content/api/cpp/namespacegpudb#ade84c63352d9cf5f7afa95060ba72ce7">column\_type</a> and <a href="/content/api/cpp/namespacegpudb#ab8967385a2df912ad40083fa2d502c37">column\_properties</a> in <span>options</span> to set the column's type and properties, respectively. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aa8db13cca2ed30ee66298f68676f17e8">alter\_table\_change\_column</a>: Changes type and properties of the column specified in <span>value</span>. Use <a href="/content/api/cpp/namespacegpudb#ade84c63352d9cf5f7afa95060ba72ce7">column\_type</a> and <a href="/content/api/cpp/namespacegpudb#ab8967385a2df912ad40083fa2d502c37">column\_properties</a> in <span>options</span> to set the column's type and properties, respectively. Note that primary key and/or shard key columns cannot be changed. All unchanging column properties must be listed for the change to take place, e.g., to add dictionary encoding to an existing 'char4' column, both 'char4' and 'dict' must be specified in the <span>options</span> map. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a53129ded98f799f9a026d95ffd6f7993">alter\_table\_delete\_column</a>: Deletes the column specified in <span>value</span> from the table specified in <span>tableName</span>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ac816ddca3ced809662864e38962062a8">alter\_table\_set\_default</a>: Sets or replaces the default value expression for the column specified in <span>value</span>. The new default is taken from <a href="/content/api/cpp/namespacegpudb#ad1fbccc3359d4a8e1dc19fedf593c09e">add\_column\_expression</a>. Existing properties on the column are preserved. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a51b6858f57dc3670daa5c9c0b06f13fc">alter\_table\_delete\_default</a>: Removes the default value expression from the column specified in <span>value</span>. Other column properties are preserved. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ad2a7f7bf4f05a0a454486179b6f77eb4">alter\_table\_create\_foreign\_key</a>: Creates a <a href="/content/concepts/tables/#foreign-key">foreign key</a> specified in <span>value</span> using the format '(source\_column\_name \[, ...]) references target\_table\_name(primary\_key\_column\_name \[, ...]) \[as foreign\_key\_name]'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ac658d84660e2a6b1becb78868d630370">alter\_table\_delete\_foreign\_key</a>: Deletes a <a href="/content/concepts/tables/#foreign-key">foreign key</a>. The <span>value</span> should be the foreign\_key\_name specified when creating the key or the complete string used to define it. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a1582445698ace2af0684b57096748ad2">alter\_table\_add\_partition</a>: Adds the partition specified in <span>value</span>, to either a <a href="/content/concepts/tables/#partitioning-by-range">range-partitioned</a> or <a href="/content/concepts/tables/#partitioning-by-list-manual">manual list-partitioned</a> table. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aca5c017766ac81d518341467c6f05a6f">alter\_table\_remove\_partition</a>: Removes the partition specified in <span>value</span> (and relocates all of its data to the default partition) from either a <a href="/content/concepts/tables/#partitioning-by-range">range-partitioned</a> or <a href="/content/concepts/tables/#partitioning-by-list-manual">manual list-partitioned</a> table. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ac2ed317f76b92d6b350d9bc4d3b22d5e">alter\_table\_delete\_partition</a>: Deletes the partition specified in <span>value</span> (and all of its data) from either a <a href="/content/concepts/tables/#partitioning-by-range">range-partitioned</a> or <a href="/content/concepts/tables/#partitioning-by-list-manual">manual list-partitioned</a> table. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a464b6ea3f2247ace2e23b46f23d79046">alter\_table\_set\_global\_access\_mode</a>: Sets the global access mode (i.e. locking) for the table specified in <span>tableName</span>. Specify the access mode in <span>value</span>. Valid modes are 'no\_access', 'read\_only', 'write\_only' and 'read\_write'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a8d759c0d75c8a2a3613aee73455073d3">alter\_table\_refresh</a>: For a <a href="/content/concepts/materialized_views/">materialized view</a>, replays all the table creation commands required to create the view. For an <a href="/content/concepts/external_tables/">external table</a>, reloads all data in the table from its associated source files or <a href="/content/concepts/data_sources/">data source</a>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a4a432c4c81f16fa40b77966ee2f8fb89">alter\_table\_set\_refresh\_method</a>: For a <a href="/content/concepts/materialized_views/">materialized view</a>, sets the method by which the view is refreshed to the method specified in <span>value</span> - one of 'manual', 'periodic', or 'on\_change'. For an <a href="/content/concepts/external_tables/">external table</a>, sets the method by which the table is refreshed to the method specified in <span>value</span> - either 'manual' or 'on\_start'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a0bc213f6974474fc3b9e8efe002ad312">alter\_table\_set\_refresh\_start\_time</a>: Sets the time to start periodic refreshes of this <a href="/content/concepts/materialized_views/">materialized view</a> to the datetime string specified in <span>value</span> with format 'YYYY-MM-DD HH:MM:SS'. Subsequent refreshes occur at the specified time + N \* the refresh period. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a6cb6b0ba725240e56a3a9b2f1a9f742b">alter\_table\_set\_refresh\_stop\_time</a>: Sets the time to stop periodic refreshes of this <a href="/content/concepts/materialized_views/">materialized view</a> to the datetime string specified in <span>value</span> with format 'YYYY-MM-DD HH:MM:SS'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aece060613249681fc3f7f2480f70a489">alter\_table\_set\_refresh\_period</a>: Sets the time interval in seconds at which to refresh this <a href="/content/concepts/materialized_views/">materialized view</a> to the value specified in <span>value</span>. Also, sets the refresh method to periodic if not already set. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a17c04447e6065303dbae9c6c4e6d8049">alter\_table\_set\_refresh\_span</a>: Sets the future time-offset(in seconds) for the view refresh to stop. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a715c3791e9cb75d82a72c44928a7e126">alter\_table\_set\_refresh\_execute\_as</a>: Sets the user name to refresh this <a href="/content/concepts/materialized_views/">materialized view</a> to the value specified in <span>value</span>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a417e3980ec9597b0decdd5a23ed7fb9e">alter\_table\_remove\_text\_search\_attributes</a>: Removes <a href="/content/concepts/full_text_search/">text search</a> attribute from all columns. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a9fb836f46fa9b85a368cfcf275f7686e">alter\_table\_remove\_shard\_keys</a>: Removes the shard key property from all columns, so that the table will be considered randomly sharded. The data is not moved. The <span>value</span> is ignored. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aa704cf1d95cab2869445fcdeb6016f57">alter\_table\_set\_strategy\_definition</a>: Sets the <a href="/content/rm/concepts/#tier-strategies">tier strategy</a> for the table and its columns to the one specified in <span>value</span>, replacing the existing tier strategy in its entirety. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a6d217f80058dc7e6b5f298c000d2e979">alter\_table\_cancel\_datasource\_subscription</a>: Permanently unsubscribe a data source that is loading continuously as a stream. The data source can be Kafka / S3 / Azure / GCS. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a35b780acb1b2835c1a5b4dc844d0fae8">alter\_table\_drop\_datasource\_subscription</a>: Permanently delete a cancelled data source subscription. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a153cc82400703940e6019ffe616f911e">alter\_table\_pause\_datasource\_subscription</a>: Temporarily unsubscribe a data source that is loading continuously as a stream. The data source can be Kafka / S3 / Azure / GCS. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ab078a450111aa405c12460e8067a7845">alter\_table\_resume\_datasource\_subscription</a>: Resubscribe to a paused data source subscription. The data source can be Kafka / S3 / Azure / GCS. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ac6fc917bc78a667b261334745b72ecda">alter\_table\_change\_owner</a>: Change the owner resource group of the table. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aaee282b8ce507cd894083204cf8e1385">alter\_table\_set\_load\_vectors\_policy</a>: Set startup data loading scheme for the table; see description of 'load\_vectors\_policy' in <a href="#afa4ded9fdb07b49b4b1cb0835b5ac52a">createTable</a> for possible values for <span>value</span>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a659310c4c57c90d58a562f4f3a4b7634">alter\_table\_set\_build\_pk\_index\_policy</a>: Set startup primary key generation scheme for the table; see description of 'build\_pk\_index\_policy' in <a href="#afa4ded9fdb07b49b4b1cb0835b5ac52a">createTable</a> for possible values for <span>value</span>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ab1bee14a4b34e7b27d3e480f9c567c53">alter\_table\_set\_build\_materialized\_view\_policy</a>: Set startup rebuilding scheme for the materialized view; see description of 'build\_materialized\_view\_policy' in <a href="#a4c585a19766a2de5755448429f034b61">createMaterializedView</a> for possible values for <span>value</span>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#af864c0816b4ded83d36ff4938ec57d12">alter\_table\_rebuild\_text\_search\_index</a>: Drops and rebuilds the <a href="/content/concepts/full_text_search/">text search</a> index for the table from current type metadata and chunk storage. Use this to repair a text-search index left incomplete by an interrupted or failed rebuild (for example, after a crash during an add-column that requested text search): re-running the original add\_column will not work because the column already exists. This action is also dispatched automatically by <a href="#a9ce980a546b63a37ceed13ad5fa137c6">alterTableColumns</a> after add\_column completions that require a full re-index. The <span>value</span> is ignored. </li>
                  </ul>
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>value</td>
                <td>The value of the modification, depending on <span>action</span>. For example, if <span>action</span> is <a href="/content/api/cpp/namespacegpudb#ab26622ef8cb73d6ebdbc8617a23c919a">add\_column</a>, this would be the column name; while the column's definition would be covered by the <a href="/content/api/cpp/namespacegpudb#ade84c63352d9cf5f7afa95060ba72ce7">column\_type</a>, <a href="/content/api/cpp/namespacegpudb#ab8967385a2df912ad40083fa2d502c37">column\_properties</a>, <a href="/content/api/cpp/namespacegpudb#ac183a60b3d94fa535d9a2704dab254e3">column\_default\_value</a>, and <a href="/content/api/cpp/namespacegpudb#ad1fbccc3359d4a8e1dc19fedf593c09e">add\_column\_expression</a> in <span>options</span>. If <span>action</span> is <a href="/content/api/cpp/namespacegpudb#ae2428730bb25f05d1d1498d0353cc437">ttl</a>, it would be the number of minutes for the new TTL. If <span>action</span> is <a href="/content/api/cpp/namespacegpudb#a8d759c0d75c8a2a3613aee73455073d3">refresh</a>, this field would be blank. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#ad9757356f8c54d003da66770b9423b1a">alter\_table\_action</a> </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a5d176b935e01fadbaf89b1399c9927d6">alter\_table\_column\_name</a> </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#af771c45c75e79bbdad5c0223d11b93fa">alter\_table\_table\_name</a> </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ac183a60b3d94fa535d9a2704dab254e3">alter\_table\_column\_default\_value</a>: When adding a column, set a literal default value for existing records. For nullable columns, the default value will be null, regardless of data type. Also persisted as the column's default for future inserts that omit the column. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ab8967385a2df912ad40083fa2d502c37">alter\_table\_column\_properties</a>: When adding or changing a column, set the column properties (strings, separated by a comma: data, text\_search, char8, int8 etc). </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ade84c63352d9cf5f7afa95060ba72ce7">alter\_table\_column\_type</a>: When adding or changing a column, set the column type (strings, separated by a comma: int, double, string, null etc). </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a3e637eeb359b539c25a2cec6e3ec9624">alter\_table\_copy\_values\_from\_column</a>: \[DEPRECATED] Please use <a href="/content/api/cpp/namespacegpudb#ad1fbccc3359d4a8e1dc19fedf593c09e">add\_column\_expression</a> instead. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a5ab2b041e1e2e951b16982011251ca2c">alter\_table\_rename\_column</a>: When changing a column, specify new column name. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#aaa264d934ae214ceb6c2953b3adbfc78">alter\_table\_validate\_change\_column</a>: When changing a column, validate the change before applying it (or not). Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a33d3f81532f0849fd6c710ed8a1e7d9b">alter\_table\_true</a>: Validate all values. A value too large (or too long) for the new type will prevent any change. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a0fdf6e8d4a69a4f89a3c3a5460c044bb">alter\_table\_false</a>: When a value is too large or long, it will be truncated. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a33d3f81532f0849fd6c710ed8a1e7d9b">alter\_table\_true</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ac98b8c510e709580a7d50ba2ff6f590f">alter\_table\_update\_last\_access\_time</a>: Indicates whether the <a href="/content/concepts/ttl/">time-to-live</a> (TTL) expiration countdown timer should be reset to the table's TTL. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a33d3f81532f0849fd6c710ed8a1e7d9b">alter\_table\_true</a>: Reset the expiration countdown timer to the table's configured TTL. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a0fdf6e8d4a69a4f89a3c3a5460c044bb">alter\_table\_false</a>: Don't reset the timer; expiration countdown will continue from where it is, as if the table had not been accessed. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a33d3f81532f0849fd6c710ed8a1e7d9b">alter\_table\_true</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#ad1fbccc3359d4a8e1dc19fedf593c09e">alter\_table\_add\_column\_expression</a>: When adding a column or setting a new default with <span>action</span> set to <a href="/content/api/cpp/namespacegpudb#ac816ddca3ced809662864e38962062a8">set\_default</a>, the new default expression (GPUdb-syntax) for the column. Any valid expression may be used, including one containing references to existing columns in the same table. Persisted as the column's default for future inserts that omit the column; for add\_column, also used to backfill existing rows. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a6ffb0dd7003c31772cc3258cafd19eb1">alter\_table\_add\_column\_expression\_sql</a>: Optional SQL-syntax form of <a href="/content/api/cpp/namespacegpudb#ad1fbccc3359d4a8e1dc19fedf593c09e">add\_column\_expression</a>, used only when the SQL syntax differs from the <a href="/content/api/cpp/classgpudb_1_1GPUdb">GPUdb</a> syntax. Persisted alongside the <a href="/content/api/cpp/classgpudb_1_1GPUdb">GPUdb</a> form so SHOW CREATE TABLE / information\_schema can reproduce the original SQL. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a84d34939de1e02c56d31e5c48edd5572">alter\_table\_strategy\_definition</a>: Parameter for specifying the <a href="/content/rm/concepts/#tier-strategies">tier strategy</a> for the table and its columns when <span>action</span> is <a href="/content/api/cpp/namespacegpudb#aa704cf1d95cab2869445fcdeb6016f57">set\_strategy\_definition</a>, replacing the existing tier strategy in its entirety. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ae45d91b6b09aac66c4d164f6eceaa029">alter\_table\_index\_type</a>: <a href="/content/api/cpp/classgpudb_1_1Type">Type</a> of index to create, when <span>action</span> is <a href="/content/api/cpp/namespacegpudb#a61a3d3555d776e54a22d87b9eb246eec">create\_index</a>; to refresh, when <span>action</span> is <a href="/content/api/cpp/namespacegpudb#a6cbb52f844d813d2d63dc411cf89e92d">refresh\_index</a>; or to delete, when <span>action</span> is <a href="/content/api/cpp/namespacegpudb#aea087240e49b139892b1c5190354d82d">delete\_index</a>. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a80f1703a203a5b90e1050af52496c604">alter\_table\_column</a>: Create or delete a <a href="/content/concepts/indexes/#column-index">column (attribute) index</a>. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a844c2b60a2199d9a589b187cabdf36d5">alter\_table\_low\_cardinality</a>: Create a <a href="/content/concepts/indexes/#low-cardinality-index">low-cardinality column (attribute) index</a>. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a920b7eb00e30386edc674aae2eeec5f8">alter\_table\_chunk\_skip</a>: Create or delete a <a href="/content/concepts/indexes/#chunk-skip-index">chunk skip index</a>. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a738abe2afa03e373b41c0eee8bc797da">alter\_table\_geospatial</a>: Create or delete a <a href="/content/concepts/indexes/#geospatial-index">geospatial index</a>. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aa4cb4163ec9c6faf5b18eaabf932824c">alter\_table\_cagra</a>: Create or delete a <a href="/content/concepts/indexes/#cagra-index">CAGRA index</a> on a <a href="/content/vector_search/#vector-type">vector column</a>. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a929362ad1dcd2c7d9863ca8388b2516b">alter\_table\_hnsw</a>: Create or delete an <a href="/content/concepts/indexes/#hnsw-index">HNSW index</a> on a <a href="/content/vector_search/#vector-type">vector column</a>. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a80f1703a203a5b90e1050af52496c604">alter\_table\_column</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#aa49b8ad4b8bbc614b4fe22aa90e48bb9">alter\_table\_index\_options</a>: <a href="/content/api/cpp/classgpudb_1_1GPUdb_1_1Options">Options</a> to use when creating an index, in the format "key: value \[, key: value \[, ...]]". Valid options vary by index type. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AlterTableResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AlterTableResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a8ec207082dc6a0254352082c611ec00f">◆ </a></span>alterTableColumns() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AlterTableColumnsResponse">AlterTableColumnsResponse</a> gpudb::GPUdb::alterTableColumns </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1AlterTableColumnsRequest">AlterTableColumnsRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Apply various modifications to columns in a table, view. </p>
        <p>The available modifications include the following:</p>
        <p>Create or delete an <a href="/content/concepts/indexes/#column-index">index</a> on a particular column. This can speed up certain operations when using expressions containing equality or relational operators on indexed columns. This only applies to tables.</p>
        <p>Manage a table's columns–a column can be added, removed, or have its <a href="/content/concepts/types/">type and properties</a> modified, including whether it is <a href="/content/concepts/dictionary_encoding/">dictionary encoded</a> or not.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AlterTableColumnsRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AlterTableColumnsResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a93339aac570739da8946cab714a37c4f">◆ </a></span>alterTableColumns() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AlterTableColumnsResponse">AlterTableColumnsResponse</a> & gpudb::GPUdb::alterTableColumns </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1AlterTableColumnsRequest">AlterTableColumnsRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1AlterTableColumnsResponse">AlterTableColumnsResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Apply various modifications to columns in a table, view. </p>
        <p>The available modifications include the following:</p>
        <p>Create or delete an <a href="/content/concepts/indexes/#column-index">index</a> on a particular column. This can speed up certain operations when using expressions containing equality or relational operators on indexed columns. This only applies to tables.</p>
        <p>Manage a table's columns–a column can be added, removed, or have its <a href="/content/concepts/types/">type and properties</a> modified, including whether it is <a href="/content/concepts/dictionary_encoding/">dictionary encoded</a> or not.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AlterTableColumnsRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AlterTableColumnsResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AlterTableColumnsResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a9ce980a546b63a37ceed13ad5fa137c6">◆ </a></span>alterTableColumns() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AlterTableColumnsResponse">AlterTableColumnsResponse</a> gpudb::GPUdb::alterTableColumns </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< std::map\< std::string, std::string > > &</td>
            <td><span><span>columnAlterations</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Apply various modifications to columns in a table, view. </p>
        <p>The available modifications include the following:</p>
        <p>Create or delete an <a href="/content/concepts/indexes/#column-index">index</a> on a particular column. This can speed up certain operations when using expressions containing equality or relational operators on indexed columns. This only applies to tables.</p>
        <p>Manage a table's columns–a column can be added, removed, or have its <a href="/content/concepts/types/">type and properties</a> modified, including whether it is <a href="/content/concepts/dictionary_encoding/">dictionary encoded</a> or not.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Table on which the operation will be performed. Must be an existing table or view, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>columnAlterations</td>
                <td>List of alter table add/delete/change column requests - all for the same table. Each request is a map that includes 'column\_name', 'action' and the options specific for the action. Note that the same options as in alter table requests but in the same map as the column name and the action. For example: \['column\_name':'col\_1','action':'change\_column','rename\_column':'col\_2','column\_name':'col\_1','action':'add\_column', 'type':'int','default\_value':'1']. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AlterTableColumnsResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ae09fa70851a84483c624d215193de11e">◆ </a></span>alterTableColumns() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AlterTableColumnsResponse">AlterTableColumnsResponse</a> & gpudb::GPUdb::alterTableColumns </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< std::map\< std::string, std::string > > &</td>
            <td><span><span>columnAlterations</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1AlterTableColumnsResponse">AlterTableColumnsResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Apply various modifications to columns in a table, view. </p>
        <p>The available modifications include the following:</p>
        <p>Create or delete an <a href="/content/concepts/indexes/#column-index">index</a> on a particular column. This can speed up certain operations when using expressions containing equality or relational operators on indexed columns. This only applies to tables.</p>
        <p>Manage a table's columns–a column can be added, removed, or have its <a href="/content/concepts/types/">type and properties</a> modified, including whether it is <a href="/content/concepts/dictionary_encoding/">dictionary encoded</a> or not.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Table on which the operation will be performed. Must be an existing table or view, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>columnAlterations</td>
                <td>List of alter table add/delete/change column requests - all for the same table. Each request is a map that includes 'column\_name', 'action' and the options specific for the action. Note that the same options as in alter table requests but in the same map as the column name and the action. For example: \['column\_name':'col\_1','action':'change\_column','rename\_column':'col\_2','column\_name':'col\_1','action':'add\_column', 'type':'int','default\_value':'1']. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AlterTableColumnsResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AlterTableColumnsResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a4fbed5af394ba543a8722e34e0ca8aa4">◆ </a></span>alterTableMetadata() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AlterTableMetadataResponse">AlterTableMetadataResponse</a> gpudb::GPUdb::alterTableMetadata </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1AlterTableMetadataRequest">AlterTableMetadataRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Updates (adds or changes) metadata for tables. </p>
        <p>The metadata key and values must both be strings. This is an easy way to annotate whole tables rather than single records within tables. Some examples of metadata are owner of the table, table creation timestamp etc.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AlterTableMetadataRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AlterTableMetadataResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ab7b4faf8b1176e08efdd4fca9a263856">◆ </a></span>alterTableMetadata() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AlterTableMetadataResponse">AlterTableMetadataResponse</a> & gpudb::GPUdb::alterTableMetadata </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1AlterTableMetadataRequest">AlterTableMetadataRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1AlterTableMetadataResponse">AlterTableMetadataResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Updates (adds or changes) metadata for tables. </p>
        <p>The metadata key and values must both be strings. This is an easy way to annotate whole tables rather than single records within tables. Some examples of metadata are owner of the table, table creation timestamp etc.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AlterTableMetadataRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AlterTableMetadataResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AlterTableMetadataResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a5ef861b64a087a87b2f545dbe6f83f6f">◆ </a></span>alterTableMetadata() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AlterTableMetadataResponse">AlterTableMetadataResponse</a> gpudb::GPUdb::alterTableMetadata </td>
            <td>(</td>
            <td>const std::vector\< std::string > &</td>
            <td><span><span>tableNames</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>metadataMap</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Updates (adds or changes) metadata for tables. </p>
        <p>The metadata key and values must both be strings. This is an easy way to annotate whole tables rather than single records within tables. Some examples of metadata are owner of the table, table creation timestamp etc.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableNames</td>
                <td>Names of the tables whose metadata will be updated, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. All specified tables must exist, or an error will be returned. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>metadataMap</td>
                <td>A map which contains the metadata of the tables that are to be updated. Note that only one map is provided for all the tables; so the change will be applied to every table. If the provided map is empty, then all existing metadata for the table(s) will be cleared. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AlterTableMetadataResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a8712c324d3df8f291685f62b9e1b7cb6">◆ </a></span>alterTableMetadata() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AlterTableMetadataResponse">AlterTableMetadataResponse</a> & gpudb::GPUdb::alterTableMetadata </td>
            <td>(</td>
            <td>const std::vector\< std::string > &</td>
            <td><span><span>tableNames</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>metadataMap</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1AlterTableMetadataResponse">AlterTableMetadataResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Updates (adds or changes) metadata for tables. </p>
        <p>The metadata key and values must both be strings. This is an easy way to annotate whole tables rather than single records within tables. Some examples of metadata are owner of the table, table creation timestamp etc.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableNames</td>
                <td>Names of the tables whose metadata will be updated, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. All specified tables must exist, or an error will be returned. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>metadataMap</td>
                <td>A map which contains the metadata of the tables that are to be updated. Note that only one map is provided for all the tables; so the change will be applied to every table. If the provided map is empty, then all existing metadata for the table(s) will be cleared. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AlterTableMetadataResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AlterTableMetadataResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#aea7ba4ba63117605613ac472447e3380">◆ </a></span>alterTableMonitor() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AlterTableMonitorResponse">AlterTableMonitorResponse</a> gpudb::GPUdb::alterTableMonitor </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1AlterTableMonitorRequest">AlterTableMonitorRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Alters a table monitor previously created with <a href="#ab379d6656d94cb2e54be2671ecd05d6c">createTableMonitor</a>. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AlterTableMonitorRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AlterTableMonitorResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#aad0c37c21cebb342fce591c2175979fd">◆ </a></span>alterTableMonitor() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AlterTableMonitorResponse">AlterTableMonitorResponse</a> & gpudb::GPUdb::alterTableMonitor </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1AlterTableMonitorRequest">AlterTableMonitorRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1AlterTableMonitorResponse">AlterTableMonitorResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Alters a table monitor previously created with <a href="#ab379d6656d94cb2e54be2671ecd05d6c">createTableMonitor</a>. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AlterTableMonitorRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AlterTableMonitorResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AlterTableMonitorResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a4d8ad3c726a24bebbe3d100c17bf9e00">◆ </a></span>alterTableMonitor() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AlterTableMonitorResponse">AlterTableMonitorResponse</a> gpudb::GPUdb::alterTableMonitor </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>topicId</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>monitorUpdatesMap</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Alters a table monitor previously created with <a href="#a562dc443f79f57ea572cb5ec0f2e8093">createTableMonitor</a>. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>topicId</td>
                <td>The topic ID returned by <a href="#a562dc443f79f57ea572cb5ec0f2e8093">createTableMonitor</a>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>monitorUpdatesMap</td>

                <td>
                  Map containing the properties of the table monitor to be updated. Error if empty.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a700479d64d4466c3f7fbeab7e7160bdf">alter\_table\_monitor\_schema\_name</a>: Updates the schema name. If <a href="/content/api/cpp/namespacegpudb#a700479d64d4466c3f7fbeab7e7160bdf">schema\_name</a> doesn't exist, an error will be thrown. If <a href="/content/api/cpp/namespacegpudb#a700479d64d4466c3f7fbeab7e7160bdf">schema\_name</a> is empty, then the user's default schema will be used. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ad27123590acf58dc7b6d0a4a73b8fe8f">alter\_table\_monitor\_max\_consecutive\_failures</a>: Updates the maximum number of consecutive failures before suspending the stream. A value of '-1' to disables auto-suspend. This value is by rank and not overall. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a246d16f19ada92aea10008b331c583c5">alter\_table\_monitor\_notifications</a>: Updates the state of the monitor. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a8a46b2271ccd6dc3975dc1b82170fe66">alter\_table\_monitor\_resume</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ae9828b3dfdb87c5425e45fce2c9e8f18">alter\_table\_monitor\_suspend</a> </li>
                      </ul>

                      The default value is an empty map.
                    </li>
                  </ul>
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AlterTableMonitorResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ad9cbebd143dc0b393c44a3edcb181746">◆ </a></span>alterTableMonitor() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AlterTableMonitorResponse">AlterTableMonitorResponse</a> & gpudb::GPUdb::alterTableMonitor </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>topicId</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>monitorUpdatesMap</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1AlterTableMonitorResponse">AlterTableMonitorResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Alters a table monitor previously created with <a href="#a562dc443f79f57ea572cb5ec0f2e8093">createTableMonitor</a>. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>topicId</td>
                <td>The topic ID returned by <a href="#a562dc443f79f57ea572cb5ec0f2e8093">createTableMonitor</a>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>monitorUpdatesMap</td>

                <td>
                  Map containing the properties of the table monitor to be updated. Error if empty.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a700479d64d4466c3f7fbeab7e7160bdf">alter\_table\_monitor\_schema\_name</a>: Updates the schema name. If <a href="/content/api/cpp/namespacegpudb#a700479d64d4466c3f7fbeab7e7160bdf">schema\_name</a> doesn't exist, an error will be thrown. If <a href="/content/api/cpp/namespacegpudb#a700479d64d4466c3f7fbeab7e7160bdf">schema\_name</a> is empty, then the user's default schema will be used. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ad27123590acf58dc7b6d0a4a73b8fe8f">alter\_table\_monitor\_max\_consecutive\_failures</a>: Updates the maximum number of consecutive failures before suspending the stream. A value of '-1' to disables auto-suspend. This value is by rank and not overall. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a246d16f19ada92aea10008b331c583c5">alter\_table\_monitor\_notifications</a>: Updates the state of the monitor. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a8a46b2271ccd6dc3975dc1b82170fe66">alter\_table\_monitor\_resume</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ae9828b3dfdb87c5425e45fce2c9e8f18">alter\_table\_monitor\_suspend</a> </li>
                      </ul>

                      The default value is an empty map.
                    </li>
                  </ul>
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AlterTableMonitorResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AlterTableMonitorResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ae73f596fa5539fff857b7312f5627a52">◆ </a></span>alterTier() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AlterTierResponse">AlterTierResponse</a> gpudb::GPUdb::alterTier </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1AlterTierRequest">AlterTierRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Alters properties of an existing <a href="/content/rm/concepts/#storage-tiers">tier</a> to facilitate <a href="/content/rm/concepts/">resource management</a>. </p>
        <p>To disable <a href="/content/rm/concepts/#watermark-based-eviction">watermark-based eviction</a>, set both <a href="/content/api/cpp/namespacegpudb#a698971465a627d3e0cc83af7f40e4b1c">high\_watermark</a> and <a href="/content/api/cpp/namespacegpudb#a7170f7b48a6c8a4f7c81262fcfed673e">low\_watermark</a> to 100.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AlterTierRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AlterTierResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a1a309e9177463c0e04236d41d7862a7d">◆ </a></span>alterTier() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AlterTierResponse">AlterTierResponse</a> & gpudb::GPUdb::alterTier </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1AlterTierRequest">AlterTierRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1AlterTierResponse">AlterTierResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Alters properties of an existing <a href="/content/rm/concepts/#storage-tiers">tier</a> to facilitate <a href="/content/rm/concepts/">resource management</a>. </p>
        <p>To disable <a href="/content/rm/concepts/#watermark-based-eviction">watermark-based eviction</a>, set both <a href="/content/api/cpp/namespacegpudb#a698971465a627d3e0cc83af7f40e4b1c">high\_watermark</a> and <a href="/content/api/cpp/namespacegpudb#a7170f7b48a6c8a4f7c81262fcfed673e">low\_watermark</a> to 100.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AlterTierRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AlterTierResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AlterTierResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ad0ef8535f3d31c0ed146d697ef1e524e">◆ </a></span>alterTier() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AlterTierResponse">AlterTierResponse</a> gpudb::GPUdb::alterTier </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Alters properties of an existing <a href="/content/rm/concepts/#storage-tiers">tier</a> to facilitate <a href="/content/rm/concepts/">resource management</a>. </p>
        <p>To disable <a href="/content/rm/concepts/#watermark-based-eviction">watermark-based eviction</a>, set both <a href="/content/api/cpp/namespacegpudb#a698971465a627d3e0cc83af7f40e4b1c">high\_watermark</a> and <a href="/content/api/cpp/namespacegpudb#a7170f7b48a6c8a4f7c81262fcfed673e">low\_watermark</a> to 100.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>name</td>
                <td>Name of the tier to be altered. Must be an existing tier group name: vram, ram, disk\[n], persist, cold\[n]. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a84a36879b48735a4305c4b100116ec6f">alter\_tier\_capacity</a>: Maximum size in bytes this tier may hold at once, per rank. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a698971465a627d3e0cc83af7f40e4b1c">alter\_tier\_high\_watermark</a>: Threshold of usage of this tier's resource that once exceeded, will trigger watermark-based eviction from this tier. The minimum allowed value is '0'. The maximum allowed value is '100'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a7170f7b48a6c8a4f7c81262fcfed673e">alter\_tier\_low\_watermark</a>: Threshold of resource usage that once fallen below after crossing the <a href="/content/api/cpp/namespacegpudb#a698971465a627d3e0cc83af7f40e4b1c">high\_watermark</a>, will cease watermark-based eviction from this tier. The minimum allowed value is '0'. The maximum allowed value is '100'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a3823dab89a8e56d4107ef8b972f5f385">alter\_tier\_wait\_timeout</a>: Timeout in seconds for reading from or writing to this resource. Applies to cold storage tiers only. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a03ee64646f0352c7ccd149aefb04a410">alter\_tier\_persist</a>: If <a href="/content/api/cpp/namespacegpudb#a6b8337e1aa0cf172804f9cea33667000">true</a> the system configuration will be written to disk upon successful application of this request. This will commit the changes from this request and any additional in-memory modifications. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a6b8337e1aa0cf172804f9cea33667000">alter\_tier\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ace135c6229542d6a76a58883f4380db5">alter\_tier\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a6b8337e1aa0cf172804f9cea33667000">alter\_tier\_true</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a55d8e4c06f440717ae7f42553b677a2f">alter\_tier\_rank</a>: Apply the requested change only to a specific rank. The minimum allowed value is '0'. The maximum allowed value is '10000'. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AlterTierResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a13674a20aec621b0560ea8d896b270f8">◆ </a></span>alterTier() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AlterTierResponse">AlterTierResponse</a> & gpudb::GPUdb::alterTier </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1AlterTierResponse">AlterTierResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Alters properties of an existing <a href="/content/rm/concepts/#storage-tiers">tier</a> to facilitate <a href="/content/rm/concepts/">resource management</a>. </p>
        <p>To disable <a href="/content/rm/concepts/#watermark-based-eviction">watermark-based eviction</a>, set both <a href="/content/api/cpp/namespacegpudb#a698971465a627d3e0cc83af7f40e4b1c">high\_watermark</a> and <a href="/content/api/cpp/namespacegpudb#a7170f7b48a6c8a4f7c81262fcfed673e">low\_watermark</a> to 100.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>name</td>
                <td>Name of the tier to be altered. Must be an existing tier group name: vram, ram, disk\[n], persist, cold\[n]. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a84a36879b48735a4305c4b100116ec6f">alter\_tier\_capacity</a>: Maximum size in bytes this tier may hold at once, per rank. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a698971465a627d3e0cc83af7f40e4b1c">alter\_tier\_high\_watermark</a>: Threshold of usage of this tier's resource that once exceeded, will trigger watermark-based eviction from this tier. The minimum allowed value is '0'. The maximum allowed value is '100'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a7170f7b48a6c8a4f7c81262fcfed673e">alter\_tier\_low\_watermark</a>: Threshold of resource usage that once fallen below after crossing the <a href="/content/api/cpp/namespacegpudb#a698971465a627d3e0cc83af7f40e4b1c">high\_watermark</a>, will cease watermark-based eviction from this tier. The minimum allowed value is '0'. The maximum allowed value is '100'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a3823dab89a8e56d4107ef8b972f5f385">alter\_tier\_wait\_timeout</a>: Timeout in seconds for reading from or writing to this resource. Applies to cold storage tiers only. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a03ee64646f0352c7ccd149aefb04a410">alter\_tier\_persist</a>: If <a href="/content/api/cpp/namespacegpudb#a6b8337e1aa0cf172804f9cea33667000">true</a> the system configuration will be written to disk upon successful application of this request. This will commit the changes from this request and any additional in-memory modifications. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a6b8337e1aa0cf172804f9cea33667000">alter\_tier\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ace135c6229542d6a76a58883f4380db5">alter\_tier\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a6b8337e1aa0cf172804f9cea33667000">alter\_tier\_true</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a55d8e4c06f440717ae7f42553b677a2f">alter\_tier\_rank</a>: Apply the requested change only to a specific rank. The minimum allowed value is '0'. The maximum allowed value is '10000'. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AlterTierResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AlterTierResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a4677397b6e719dfa44657790d64bc6ae">◆ </a></span>alterUser() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AlterUserResponse">AlterUserResponse</a> gpudb::GPUdb::alterUser </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1AlterUserRequest">AlterUserRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Alters a user. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AlterUserRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AlterUserResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a927df937dad09d422fe2c60e4f41d1e6">◆ </a></span>alterUser() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AlterUserResponse">AlterUserResponse</a> & gpudb::GPUdb::alterUser </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1AlterUserRequest">AlterUserRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1AlterUserResponse">AlterUserResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Alters a user. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AlterUserRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AlterUserResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AlterUserResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a39c7b6e35407837c195f99e004e6c000">◆ </a></span>alterUser() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AlterUserResponse">AlterUserResponse</a> gpudb::GPUdb::alterUser </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>action</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>value</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Alters a user. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>name</td>
                <td>Name of the user to be altered. Must be an existing user. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>action</td>

                <td>
                  Modification operation to be applied to the user. Supported values:

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a01a7ce037957ff2b629ebc5a6d12ce7a">alter\_user\_set\_activated</a>: Is the user allowed to login. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ad0995349ef75aee0da07e6651c4654f9">alter\_user\_true</a>: User may login. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a27a8ceeaf66449512148fd40ec1c81b1">alter\_user\_false</a>: User may not login. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#acbb95ae0ca0b9c5fa9b614e3c81a6df6">alter\_user\_set\_comment</a>: Sets the comment for an internal user. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a7ed399093838e20e656ac8aed9077269">alter\_user\_set\_default\_schema</a>: Set the default\_schema for an internal user. An empty string means the user will have no default schema. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a3a2dc1bfe8a2329c2a1f42ee8e9d5128">alter\_user\_set\_password</a>: Sets the password of the user. The user must be an internal user. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a337ee98324e65cce1f62a37301fd9c2a">alter\_user\_set\_resource\_group</a>: Sets the resource group for an internal user. The resource group must exist, otherwise, an empty string assigns the user to the default resource group. </li>
                  </ul>
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>value</td>
                <td>The value of the modification, depending on <span>action</span>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AlterUserResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#aed7c48162601a63c3a8331740de86645">◆ </a></span>alterUser() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AlterUserResponse">AlterUserResponse</a> & gpudb::GPUdb::alterUser </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>action</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>value</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1AlterUserResponse">AlterUserResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Alters a user. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>name</td>
                <td>Name of the user to be altered. Must be an existing user. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>action</td>

                <td>
                  Modification operation to be applied to the user. Supported values:

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a01a7ce037957ff2b629ebc5a6d12ce7a">alter\_user\_set\_activated</a>: Is the user allowed to login. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ad0995349ef75aee0da07e6651c4654f9">alter\_user\_true</a>: User may login. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a27a8ceeaf66449512148fd40ec1c81b1">alter\_user\_false</a>: User may not login. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#acbb95ae0ca0b9c5fa9b614e3c81a6df6">alter\_user\_set\_comment</a>: Sets the comment for an internal user. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a7ed399093838e20e656ac8aed9077269">alter\_user\_set\_default\_schema</a>: Set the default\_schema for an internal user. An empty string means the user will have no default schema. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a3a2dc1bfe8a2329c2a1f42ee8e9d5128">alter\_user\_set\_password</a>: Sets the password of the user. The user must be an internal user. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a337ee98324e65cce1f62a37301fd9c2a">alter\_user\_set\_resource\_group</a>: Sets the resource group for an internal user. The resource group must exist, otherwise, an empty string assigns the user to the default resource group. </li>
                  </ul>
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>value</td>
                <td>The value of the modification, depending on <span>action</span>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AlterUserResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AlterUserResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#affb51f3e7d9b872b955d0737b3273902">◆ </a></span>alterVideo() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AlterVideoResponse">AlterVideoResponse</a> gpudb::GPUdb::alterVideo </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1AlterVideoRequest">AlterVideoRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Alters a video. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AlterVideoRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AlterVideoResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#afab1da5e43c5aeb1c56c986546571c45">◆ </a></span>alterVideo() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AlterVideoResponse">AlterVideoResponse</a> & gpudb::GPUdb::alterVideo </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1AlterVideoRequest">AlterVideoRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1AlterVideoResponse">AlterVideoResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Alters a video. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AlterVideoRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AlterVideoResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AlterVideoResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ac28c02fe9b43db4d270948b741c2c866">◆ </a></span>alterVideo() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AlterVideoResponse">AlterVideoResponse</a> gpudb::GPUdb::alterVideo </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>path</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Alters a video. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>path</td>
                <td>Fully-qualified <a href="/content/tools/kifs/">KiFS</a> path to the video to be altered. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a6f0ffd1cab01e01bfa4ca1617bd0e57f">alter\_video\_ttl</a>: Sets the <a href="/content/concepts/ttl/">TTL</a> of the video. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AlterVideoResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a7588fad781eeea0770caf70f4b3a9317">◆ </a></span>alterVideo() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AlterVideoResponse">AlterVideoResponse</a> & gpudb::GPUdb::alterVideo </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>path</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1AlterVideoResponse">AlterVideoResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Alters a video. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>path</td>
                <td>Fully-qualified <a href="/content/tools/kifs/">KiFS</a> path to the video to be altered. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a6f0ffd1cab01e01bfa4ca1617bd0e57f">alter\_video\_ttl</a>: Sets the <a href="/content/concepts/ttl/">TTL</a> of the video. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AlterVideoResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AlterVideoResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a982dab90baf6bd12035b69342f8187a3">◆ </a></span>alterWal() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AlterWalResponse">AlterWalResponse</a> gpudb::GPUdb::alterWal </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1AlterWalRequest">AlterWalRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Alters table write-ahead log (WAL) settings. </p>
        <p>Returns information about the requested table WAL modifications.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AlterWalRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AlterWalResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#af3d0a716ce6da913df55c114c99d7cb1">◆ </a></span>alterWal() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AlterWalResponse">AlterWalResponse</a> & gpudb::GPUdb::alterWal </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1AlterWalRequest">AlterWalRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1AlterWalResponse">AlterWalResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Alters table write-ahead log (WAL) settings. </p>
        <p>Returns information about the requested table WAL modifications.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AlterWalRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AlterWalResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AlterWalResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ae392fc22d368ad7a63525ad09fb333b8">◆ </a></span>alterWal() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AlterWalResponse">AlterWalResponse</a> gpudb::GPUdb::alterWal </td>
            <td>(</td>
            <td>const std::vector\< std::string > &</td>
            <td><span><span>tableNames</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Alters table write-ahead log (WAL) settings. </p>
        <p>Returns information about the requested table WAL modifications.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableNames</td>
                <td>List of tables to modify. An asterisk changes the system settings. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a11243780573269b0188f43086fefd487">alter\_wal\_max\_segment\_size</a>: Maximum size of an individual segment file. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a2cc00dc1d5af908a8cb471d1672a047b">alter\_wal\_segment\_count</a>: Approximate number of segment files to split the WAL across. Must be at least two. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ae521bb194a9ce38e75609142cd93becf">alter\_wal\_sync\_policy</a>: Maximum size of an individual segment file. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a91d162ed444e2e9085c605c28c877e00">alter\_wal\_none</a>: Disables the WAL. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad2fe01c6f5978e3e7236facab116f4a2">alter\_wal\_background</a>: WAL entries are periodically written instead of immediately after each operation. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ae10a93be3787862b80aab1897fb52e33">alter\_wal\_flush</a>: Protects entries in the event of a database crash. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aae23b82ae4ff72a7ea1a7086fa15a02b">alter\_wal\_fsync</a>: Protects entries in the event of an OS crash. </li>
                      </ul>
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#ac171e13c8202fc9465715d3b417db8f0">alter\_wal\_flush\_frequency</a>: Specifies how frequently WAL entries are written with background sync. This is a global setting and can only be used with the system options.table\_names specifier '\*'. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#afda614e8703a8cbfcbd7341c53356a80">alter\_wal\_checksum</a>: If <a href="/content/api/cpp/namespacegpudb#a05b6ab935abe46b7ad7f3d3be3bee137">true</a> each entry will be checked against a protective checksum. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a05b6ab935abe46b7ad7f3d3be3bee137">alter\_wal\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#afd2618a1b1b25668ee515a4f44133c9f">alter\_wal\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a05b6ab935abe46b7ad7f3d3be3bee137">alter\_wal\_true</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a3bf4a86f684e5f72efca3f49eb6606c7">alter\_wal\_override\_non\_default</a>: If <a href="/content/api/cpp/namespacegpudb#a05b6ab935abe46b7ad7f3d3be3bee137">true</a> tables with unique WAL settings will be overridden when applying a system level change. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a05b6ab935abe46b7ad7f3d3be3bee137">alter\_wal\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#afd2618a1b1b25668ee515a4f44133c9f">alter\_wal\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#afd2618a1b1b25668ee515a4f44133c9f">alter\_wal\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ae1945c992a9ac4f5a9e6d7182ad084f5">alter\_wal\_restore\_system\_settings</a>: If <a href="/content/api/cpp/namespacegpudb#a05b6ab935abe46b7ad7f3d3be3bee137">true</a> tables with unique WAL settings will be reverted to the current global settings. Cannot be used in conjunction with any other option. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a05b6ab935abe46b7ad7f3d3be3bee137">alter\_wal\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#afd2618a1b1b25668ee515a4f44133c9f">alter\_wal\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#afd2618a1b1b25668ee515a4f44133c9f">alter\_wal\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#af6747739be3b5833037159b5e848e54e">alter\_wal\_persist</a>: If <a href="/content/api/cpp/namespacegpudb#a05b6ab935abe46b7ad7f3d3be3bee137">true</a> and a system-level change was requested, the system configuration will be written to disk upon successful application of this request. This will commit the changes from this request and any additional in-memory modifications. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a05b6ab935abe46b7ad7f3d3be3bee137">alter\_wal\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#afd2618a1b1b25668ee515a4f44133c9f">alter\_wal\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a05b6ab935abe46b7ad7f3d3be3bee137">alter\_wal\_true</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AlterWalResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a87d7bf3ba965adcab6f283754f470c94">◆ </a></span>alterWal() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AlterWalResponse">AlterWalResponse</a> & gpudb::GPUdb::alterWal </td>
            <td>(</td>
            <td>const std::vector\< std::string > &</td>
            <td><span><span>tableNames</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1AlterWalResponse">AlterWalResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Alters table write-ahead log (WAL) settings. </p>
        <p>Returns information about the requested table WAL modifications.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableNames</td>
                <td>List of tables to modify. An asterisk changes the system settings. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a11243780573269b0188f43086fefd487">alter\_wal\_max\_segment\_size</a>: Maximum size of an individual segment file. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a2cc00dc1d5af908a8cb471d1672a047b">alter\_wal\_segment\_count</a>: Approximate number of segment files to split the WAL across. Must be at least two. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ae521bb194a9ce38e75609142cd93becf">alter\_wal\_sync\_policy</a>: Maximum size of an individual segment file. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a91d162ed444e2e9085c605c28c877e00">alter\_wal\_none</a>: Disables the WAL. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad2fe01c6f5978e3e7236facab116f4a2">alter\_wal\_background</a>: WAL entries are periodically written instead of immediately after each operation. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ae10a93be3787862b80aab1897fb52e33">alter\_wal\_flush</a>: Protects entries in the event of a database crash. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aae23b82ae4ff72a7ea1a7086fa15a02b">alter\_wal\_fsync</a>: Protects entries in the event of an OS crash. </li>
                      </ul>
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#ac171e13c8202fc9465715d3b417db8f0">alter\_wal\_flush\_frequency</a>: Specifies how frequently WAL entries are written with background sync. This is a global setting and can only be used with the system options.table\_names specifier '\*'. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#afda614e8703a8cbfcbd7341c53356a80">alter\_wal\_checksum</a>: If <a href="/content/api/cpp/namespacegpudb#a05b6ab935abe46b7ad7f3d3be3bee137">true</a> each entry will be checked against a protective checksum. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a05b6ab935abe46b7ad7f3d3be3bee137">alter\_wal\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#afd2618a1b1b25668ee515a4f44133c9f">alter\_wal\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a05b6ab935abe46b7ad7f3d3be3bee137">alter\_wal\_true</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a3bf4a86f684e5f72efca3f49eb6606c7">alter\_wal\_override\_non\_default</a>: If <a href="/content/api/cpp/namespacegpudb#a05b6ab935abe46b7ad7f3d3be3bee137">true</a> tables with unique WAL settings will be overridden when applying a system level change. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a05b6ab935abe46b7ad7f3d3be3bee137">alter\_wal\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#afd2618a1b1b25668ee515a4f44133c9f">alter\_wal\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#afd2618a1b1b25668ee515a4f44133c9f">alter\_wal\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ae1945c992a9ac4f5a9e6d7182ad084f5">alter\_wal\_restore\_system\_settings</a>: If <a href="/content/api/cpp/namespacegpudb#a05b6ab935abe46b7ad7f3d3be3bee137">true</a> tables with unique WAL settings will be reverted to the current global settings. Cannot be used in conjunction with any other option. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a05b6ab935abe46b7ad7f3d3be3bee137">alter\_wal\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#afd2618a1b1b25668ee515a4f44133c9f">alter\_wal\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#afd2618a1b1b25668ee515a4f44133c9f">alter\_wal\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#af6747739be3b5833037159b5e848e54e">alter\_wal\_persist</a>: If <a href="/content/api/cpp/namespacegpudb#a05b6ab935abe46b7ad7f3d3be3bee137">true</a> and a system-level change was requested, the system configuration will be written to disk upon successful application of this request. This will commit the changes from this request and any additional in-memory modifications. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a05b6ab935abe46b7ad7f3d3be3bee137">alter\_wal\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#afd2618a1b1b25668ee515a4f44133c9f">alter\_wal\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a05b6ab935abe46b7ad7f3d3be3bee137">alter\_wal\_true</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AlterWalResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AlterWalResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ac902ab53fb7c2f952e232315b7cb6536">◆ </a></span>appendRecords() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AppendRecordsResponse">AppendRecordsResponse</a> gpudb::GPUdb::appendRecords </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1AppendRecordsRequest">AppendRecordsRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Append (or insert) all records from a source table (specified by <a href="/content/api/cpp/structgpudb_1_1AppendRecordsRequest#a007088ffb6142dd12803205edb8772ff">sourceTableName</a>) to a particular target table (specified by <a href="/content/api/cpp/structgpudb_1_1AppendRecordsRequest#a1f38b6189aefb233a3a6820263f063ac">tableName</a>). </p>
        <p>The field map (specified by <a href="/content/api/cpp/structgpudb_1_1AppendRecordsRequest#a2cf9a4beaa61e288eaf21061283eeb2c">fieldMap</a>) holds the user specified map of target table column names with their mapped source column names.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AppendRecordsRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AppendRecordsResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a20ee0685b5f6505eb483d369c8649f9b">◆ </a></span>appendRecords() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AppendRecordsResponse">AppendRecordsResponse</a> & gpudb::GPUdb::appendRecords </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1AppendRecordsRequest">AppendRecordsRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1AppendRecordsResponse">AppendRecordsResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Append (or insert) all records from a source table (specified by <a href="/content/api/cpp/structgpudb_1_1AppendRecordsRequest#a007088ffb6142dd12803205edb8772ff">sourceTableName</a>) to a particular target table (specified by <a href="/content/api/cpp/structgpudb_1_1AppendRecordsRequest#a1f38b6189aefb233a3a6820263f063ac">tableName</a>). </p>
        <p>The field map (specified by <a href="/content/api/cpp/structgpudb_1_1AppendRecordsRequest#a2cf9a4beaa61e288eaf21061283eeb2c">fieldMap</a>) holds the user specified map of target table column names with their mapped source column names.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AppendRecordsRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AppendRecordsResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AppendRecordsResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ad2068df53aa2615c45e9bb2586387a27">◆ </a></span>appendRecords() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AppendRecordsResponse">AppendRecordsResponse</a> gpudb::GPUdb::appendRecords </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>sourceTableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>fieldMap</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Append (or insert) all records from a source table (specified by <span>sourceTableName</span>) to a particular target table (specified by <span>tableName</span>). </p>
        <p>The field map (specified by <span>fieldMap</span>) holds the user specified map of target table column names with their mapped source column names.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>The table name for the records to be appended, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. Must be an existing table. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>sourceTableName</td>
                <td>The source table name to get records from, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. Must be an existing table name. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>fieldMap</td>
                <td>Contains the mapping of column names from the target table (specified by <span>tableName</span>) as the keys, and corresponding column names or expressions (e.g., 'col\_name+1') from the source table (specified by <span>sourceTableName</span>). Must be existing column names in source table and target table, and their types must be matched. For details on using expressions, see <a href="/content/concepts/expressions/">Expressions</a>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#ac7a5feee95ce26edc3b564a1fffee08d">append\_records\_offset</a>: A positive integer indicating the number of initial results to skip from <span>sourceTableName</span>. Default is 0. The minimum allowed value is 0. The maximum allowed value is MAX\_INT. The default value is '0'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#afe4f2882fd7e45971a280abe883ea6ac">append\_records\_limit</a>: A positive integer indicating the maximum number of results to be returned from <span>sourceTableName</span>. Or END\_OF\_SET (-9999) to indicate that the max number of results should be returned. The default value is '-9999'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a2f1dbdc4c899b222e30af6b5556a052e">append\_records\_expression</a>: Filter expression to apply to the <span>sourceTableName</span>. The default value is ''. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a07602ab890c84b3862164232fe78d6ec">append\_records\_order\_by</a>: Comma-separated list of the columns to be sorted by from source table (specified by <span>sourceTableName</span>), e.g., 'timestamp asc, x desc'. The <a href="/content/api/cpp/namespacegpudb#a07602ab890c84b3862164232fe78d6ec">order\_by</a> columns do not have to be present in <span>fieldMap</span>. The default value is ''. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a6846d34da4d90dbaf91c3fadbe480e68">append\_records\_error\_handling</a>: Specifies how record errors are handled while appending source table records into the target table. Currently this governs primary-key collision behavior: <a href="/content/api/cpp/namespacegpudb#a30355488a5940174966e9f91e6b6c2d6">skip</a> and <a href="/content/api/cpp/namespacegpudb#a13aaa87c4c4c2d34d895111ba44938f0">permissive</a> drop the colliding source records and continue, while <a href="/content/api/cpp/namespacegpudb#ab3a13dce9bd21fff14a7cb408362cfc6">abort</a> rejects the batch. Explicit <a href="/content/api/cpp/namespacegpudb#a20a1fe73ce67985b994e3f7e2b0fe62b">update\_on\_existing\_pk</a> or <a href="/content/api/cpp/namespacegpudb#a9316eeb63a5e01730174d5b39e4cdc07">ignore\_existing\_pk</a> take precedence over this option. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a13aaa87c4c4c2d34d895111ba44938f0">append\_records\_permissive</a>: Source records that cannot be appended (e.g. a primary-key collision) are skipped and reported; the rest of the batch is appended. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a30355488a5940174966e9f91e6b6c2d6">append\_records\_skip</a>: Source records that cannot be appended are skipped and reported; the rest of the batch is appended. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ab3a13dce9bd21fff14a7cb408362cfc6">append\_records\_abort</a>: A source record that cannot be appended (e.g. a primary-key collision) raises an error. This is the default. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ab3a13dce9bd21fff14a7cb408362cfc6">append\_records\_abort</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a20a1fe73ce67985b994e3f7e2b0fe62b">append\_records\_update\_on\_existing\_pk</a>: Specifies the record collision policy for inserting source table records (specified by <span>sourceTableName</span>) into a target table (specified by <span>tableName</span>) with a <a href="/content/concepts/tables/#primary-keys">primary key</a>. If set to <a href="/content/api/cpp/namespacegpudb#a4dc510a6c94513c747849fccae2921f1">true</a>, any existing table record with primary key values that match those of a source table record being inserted will be replaced by that new record (the new data will be "upserted"). If set to <a href="/content/api/cpp/namespacegpudb#a2a6ce357b6b7f28848b9cb643c21ddc9">false</a>, any existing table record with primary key values that match those of a source table record being inserted will remain unchanged, while the source record will be rejected and an error handled as determined by <a href="/content/api/cpp/namespacegpudb#a9316eeb63a5e01730174d5b39e4cdc07">ignore\_existing\_pk</a>. If the specified table does not have a primary key, then this option has no effect. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a4dc510a6c94513c747849fccae2921f1">append\_records\_true</a>: Upsert new records when primary keys match existing records. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a2a6ce357b6b7f28848b9cb643c21ddc9">append\_records\_false</a>: Reject new records when primary keys match existing records. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a2a6ce357b6b7f28848b9cb643c21ddc9">append\_records\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a05126a08aa3e2a694e354112d3cd4a5d">append\_records\_enable\_inplace\_updates</a>: Applies only when upserting (when <a href="/content/api/cpp/namespacegpudb#a20a1fe73ce67985b994e3f7e2b0fe62b">update\_on\_existing\_pk</a> is <a href="/content/api/cpp/namespacegpudb#a4dc510a6c94513c747849fccae2921f1">true</a>). If set to <a href="/content/api/cpp/namespacegpudb#a4dc510a6c94513c747849fccae2921f1">true</a>, an existing record matched by primary key is modified in place. If set to <a href="/content/api/cpp/namespacegpudb#a2a6ce357b6b7f28848b9cb643c21ddc9">false</a>, it is updated by deleting the existing record and inserting a replacement (delete and insert), which prevents the change from being reflected in dependent materialized views until they are refreshed. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a4dc510a6c94513c747849fccae2921f1">append\_records\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a2a6ce357b6b7f28848b9cb643c21ddc9">append\_records\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a4dc510a6c94513c747849fccae2921f1">append\_records\_true</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a9316eeb63a5e01730174d5b39e4cdc07">append\_records\_ignore\_existing\_pk</a>: Specifies the record collision error-suppression policy for inserting source table records (specified by <span>sourceTableName</span>) into a target table (specified by <span>tableName</span>) with a <a href="/content/concepts/tables/#primary-keys">primary key</a>, only used when not in upsert mode (upsert mode is disabled when <a href="/content/api/cpp/namespacegpudb#a20a1fe73ce67985b994e3f7e2b0fe62b">update\_on\_existing\_pk</a> is <a href="/content/api/cpp/namespacegpudb#a2a6ce357b6b7f28848b9cb643c21ddc9">false</a>). If set to <a href="/content/api/cpp/namespacegpudb#a4dc510a6c94513c747849fccae2921f1">true</a>, any source table record being inserted that is rejected for having primary key values that match those of an existing target table record will be ignored with no error generated. If <a href="/content/api/cpp/namespacegpudb#a2a6ce357b6b7f28848b9cb643c21ddc9">false</a>, the rejection of any source table record for having primary key values matching an existing target table record will result in an error being raised. If the specified table does not have a primary key or if upsert mode is in effect (<a href="/content/api/cpp/namespacegpudb#a20a1fe73ce67985b994e3f7e2b0fe62b">update\_on\_existing\_pk</a> is <a href="/content/api/cpp/namespacegpudb#a4dc510a6c94513c747849fccae2921f1">true</a>), then this option has no effect. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a4dc510a6c94513c747849fccae2921f1">append\_records\_true</a>: Ignore source table records whose primary key values collide with those of target table records. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a2a6ce357b6b7f28848b9cb643c21ddc9">append\_records\_false</a>: Raise an error for any source table record whose primary key values collide with those of a target table record. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a2a6ce357b6b7f28848b9cb643c21ddc9">append\_records\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a728940d01e8466552445f439d78d098a">append\_records\_pk\_conflict\_predicate\_higher</a>: The record with higher value for the column resolves the primary-key insert conflict. The default value is ''. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a2783d0cf15d9c702b25d4c7f2571f4aa">append\_records\_pk\_conflict\_predicate\_lower</a>: The record with lower value for the column resolves the primary-key insert conflict. The default value is ''. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a4403e70c31ca39faafe51ea1e9a78c95">append\_records\_truncate\_strings</a>: If set to <a href="/content/api/cpp/namespacegpudb#a4dc510a6c94513c747849fccae2921f1">true</a>, it allows inserting longer strings into smaller charN string columns by truncating the longer strings to fit. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a4dc510a6c94513c747849fccae2921f1">append\_records\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a2a6ce357b6b7f28848b9cb643c21ddc9">append\_records\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a2a6ce357b6b7f28848b9cb643c21ddc9">append\_records\_false</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AppendRecordsResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#acebe4ac75a8f120e5de64daa9535b25e">◆ </a></span>appendRecords() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1AppendRecordsResponse">AppendRecordsResponse</a> & gpudb::GPUdb::appendRecords </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>sourceTableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>fieldMap</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1AppendRecordsResponse">AppendRecordsResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Append (or insert) all records from a source table (specified by <span>sourceTableName</span>) to a particular target table (specified by <span>tableName</span>). </p>
        <p>The field map (specified by <span>fieldMap</span>) holds the user specified map of target table column names with their mapped source column names.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>The table name for the records to be appended, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. Must be an existing table. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>sourceTableName</td>
                <td>The source table name to get records from, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. Must be an existing table name. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>fieldMap</td>
                <td>Contains the mapping of column names from the target table (specified by <span>tableName</span>) as the keys, and corresponding column names or expressions (e.g., 'col\_name+1') from the source table (specified by <span>sourceTableName</span>). Must be existing column names in source table and target table, and their types must be matched. For details on using expressions, see <a href="/content/concepts/expressions/">Expressions</a>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#ac7a5feee95ce26edc3b564a1fffee08d">append\_records\_offset</a>: A positive integer indicating the number of initial results to skip from <span>sourceTableName</span>. Default is 0. The minimum allowed value is 0. The maximum allowed value is MAX\_INT. The default value is '0'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#afe4f2882fd7e45971a280abe883ea6ac">append\_records\_limit</a>: A positive integer indicating the maximum number of results to be returned from <span>sourceTableName</span>. Or END\_OF\_SET (-9999) to indicate that the max number of results should be returned. The default value is '-9999'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a2f1dbdc4c899b222e30af6b5556a052e">append\_records\_expression</a>: Filter expression to apply to the <span>sourceTableName</span>. The default value is ''. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a07602ab890c84b3862164232fe78d6ec">append\_records\_order\_by</a>: Comma-separated list of the columns to be sorted by from source table (specified by <span>sourceTableName</span>), e.g., 'timestamp asc, x desc'. The <a href="/content/api/cpp/namespacegpudb#a07602ab890c84b3862164232fe78d6ec">order\_by</a> columns do not have to be present in <span>fieldMap</span>. The default value is ''. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a6846d34da4d90dbaf91c3fadbe480e68">append\_records\_error\_handling</a>: Specifies how record errors are handled while appending source table records into the target table. Currently this governs primary-key collision behavior: <a href="/content/api/cpp/namespacegpudb#a30355488a5940174966e9f91e6b6c2d6">skip</a> and <a href="/content/api/cpp/namespacegpudb#a13aaa87c4c4c2d34d895111ba44938f0">permissive</a> drop the colliding source records and continue, while <a href="/content/api/cpp/namespacegpudb#ab3a13dce9bd21fff14a7cb408362cfc6">abort</a> rejects the batch. Explicit <a href="/content/api/cpp/namespacegpudb#a20a1fe73ce67985b994e3f7e2b0fe62b">update\_on\_existing\_pk</a> or <a href="/content/api/cpp/namespacegpudb#a9316eeb63a5e01730174d5b39e4cdc07">ignore\_existing\_pk</a> take precedence over this option. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a13aaa87c4c4c2d34d895111ba44938f0">append\_records\_permissive</a>: Source records that cannot be appended (e.g. a primary-key collision) are skipped and reported; the rest of the batch is appended. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a30355488a5940174966e9f91e6b6c2d6">append\_records\_skip</a>: Source records that cannot be appended are skipped and reported; the rest of the batch is appended. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ab3a13dce9bd21fff14a7cb408362cfc6">append\_records\_abort</a>: A source record that cannot be appended (e.g. a primary-key collision) raises an error. This is the default. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ab3a13dce9bd21fff14a7cb408362cfc6">append\_records\_abort</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a20a1fe73ce67985b994e3f7e2b0fe62b">append\_records\_update\_on\_existing\_pk</a>: Specifies the record collision policy for inserting source table records (specified by <span>sourceTableName</span>) into a target table (specified by <span>tableName</span>) with a <a href="/content/concepts/tables/#primary-keys">primary key</a>. If set to <a href="/content/api/cpp/namespacegpudb#a4dc510a6c94513c747849fccae2921f1">true</a>, any existing table record with primary key values that match those of a source table record being inserted will be replaced by that new record (the new data will be "upserted"). If set to <a href="/content/api/cpp/namespacegpudb#a2a6ce357b6b7f28848b9cb643c21ddc9">false</a>, any existing table record with primary key values that match those of a source table record being inserted will remain unchanged, while the source record will be rejected and an error handled as determined by <a href="/content/api/cpp/namespacegpudb#a9316eeb63a5e01730174d5b39e4cdc07">ignore\_existing\_pk</a>. If the specified table does not have a primary key, then this option has no effect. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a4dc510a6c94513c747849fccae2921f1">append\_records\_true</a>: Upsert new records when primary keys match existing records. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a2a6ce357b6b7f28848b9cb643c21ddc9">append\_records\_false</a>: Reject new records when primary keys match existing records. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a2a6ce357b6b7f28848b9cb643c21ddc9">append\_records\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a05126a08aa3e2a694e354112d3cd4a5d">append\_records\_enable\_inplace\_updates</a>: Applies only when upserting (when <a href="/content/api/cpp/namespacegpudb#a20a1fe73ce67985b994e3f7e2b0fe62b">update\_on\_existing\_pk</a> is <a href="/content/api/cpp/namespacegpudb#a4dc510a6c94513c747849fccae2921f1">true</a>). If set to <a href="/content/api/cpp/namespacegpudb#a4dc510a6c94513c747849fccae2921f1">true</a>, an existing record matched by primary key is modified in place. If set to <a href="/content/api/cpp/namespacegpudb#a2a6ce357b6b7f28848b9cb643c21ddc9">false</a>, it is updated by deleting the existing record and inserting a replacement (delete and insert), which prevents the change from being reflected in dependent materialized views until they are refreshed. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a4dc510a6c94513c747849fccae2921f1">append\_records\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a2a6ce357b6b7f28848b9cb643c21ddc9">append\_records\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a4dc510a6c94513c747849fccae2921f1">append\_records\_true</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a9316eeb63a5e01730174d5b39e4cdc07">append\_records\_ignore\_existing\_pk</a>: Specifies the record collision error-suppression policy for inserting source table records (specified by <span>sourceTableName</span>) into a target table (specified by <span>tableName</span>) with a <a href="/content/concepts/tables/#primary-keys">primary key</a>, only used when not in upsert mode (upsert mode is disabled when <a href="/content/api/cpp/namespacegpudb#a20a1fe73ce67985b994e3f7e2b0fe62b">update\_on\_existing\_pk</a> is <a href="/content/api/cpp/namespacegpudb#a2a6ce357b6b7f28848b9cb643c21ddc9">false</a>). If set to <a href="/content/api/cpp/namespacegpudb#a4dc510a6c94513c747849fccae2921f1">true</a>, any source table record being inserted that is rejected for having primary key values that match those of an existing target table record will be ignored with no error generated. If <a href="/content/api/cpp/namespacegpudb#a2a6ce357b6b7f28848b9cb643c21ddc9">false</a>, the rejection of any source table record for having primary key values matching an existing target table record will result in an error being raised. If the specified table does not have a primary key or if upsert mode is in effect (<a href="/content/api/cpp/namespacegpudb#a20a1fe73ce67985b994e3f7e2b0fe62b">update\_on\_existing\_pk</a> is <a href="/content/api/cpp/namespacegpudb#a4dc510a6c94513c747849fccae2921f1">true</a>), then this option has no effect. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a4dc510a6c94513c747849fccae2921f1">append\_records\_true</a>: Ignore source table records whose primary key values collide with those of target table records. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a2a6ce357b6b7f28848b9cb643c21ddc9">append\_records\_false</a>: Raise an error for any source table record whose primary key values collide with those of a target table record. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a2a6ce357b6b7f28848b9cb643c21ddc9">append\_records\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a728940d01e8466552445f439d78d098a">append\_records\_pk\_conflict\_predicate\_higher</a>: The record with higher value for the column resolves the primary-key insert conflict. The default value is ''. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a2783d0cf15d9c702b25d4c7f2571f4aa">append\_records\_pk\_conflict\_predicate\_lower</a>: The record with lower value for the column resolves the primary-key insert conflict. The default value is ''. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a4403e70c31ca39faafe51ea1e9a78c95">append\_records\_truncate\_strings</a>: If set to <a href="/content/api/cpp/namespacegpudb#a4dc510a6c94513c747849fccae2921f1">true</a>, it allows inserting longer strings into smaller charN string columns by truncating the longer strings to fit. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a4dc510a6c94513c747849fccae2921f1">append\_records\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a2a6ce357b6b7f28848b9cb643c21ddc9">append\_records\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a2a6ce357b6b7f28848b9cb643c21ddc9">append\_records\_false</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1AppendRecordsResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1AppendRecordsResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a90b3a1ea70450b92e93bcc38ca4e5658">◆ </a></span>checkTable() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CheckTableResponse">CheckTableResponse</a> gpudb::GPUdb::checkTable </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1CheckTableRequest">CheckTableRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Scans the requested tables as specified in <a href="/content/api/cpp/structgpudb_1_1CheckTableRequest#a86963be684731f0b74fd1c68633cd15c">tableNames</a> for integrity. </p>
        <p>Any table chunks which fail the check will be marked as corrupt. By default the database will automatically repair corrupt tables (via truncating). Note that since this reads every table column from disk it may be a potentially long-running operation. The option <a href="/content/api/cpp/namespacegpudb#a8401ed637326bcdcc0d079e04c8d3415">local\_only</a> can be used to skip any table files already written to a remote storage. Returns table corruption results.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CheckTableRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CheckTableResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#adebe60a19cff32b856f6b0fdf65fa742">◆ </a></span>checkTable() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CheckTableResponse">CheckTableResponse</a> & gpudb::GPUdb::checkTable </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1CheckTableRequest">CheckTableRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1CheckTableResponse">CheckTableResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Scans the requested tables as specified in <a href="/content/api/cpp/structgpudb_1_1CheckTableRequest#a86963be684731f0b74fd1c68633cd15c">tableNames</a> for integrity. </p>
        <p>Any table chunks which fail the check will be marked as corrupt. By default the database will automatically repair corrupt tables (via truncating). Note that since this reads every table column from disk it may be a potentially long-running operation. The option <a href="/content/api/cpp/namespacegpudb#a8401ed637326bcdcc0d079e04c8d3415">local\_only</a> can be used to skip any table files already written to a remote storage. Returns table corruption results.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CheckTableRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CheckTableResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CheckTableResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#af3c5071524742d67504b556411ccca18">◆ </a></span>checkTable() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CheckTableResponse">CheckTableResponse</a> gpudb::GPUdb::checkTable </td>
            <td>(</td>
            <td>const std::vector\< std::string > &</td>
            <td><span><span>tableNames</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Scans the requested tables as specified in <span>tableNames</span> for integrity. </p>
        <p>Any table chunks which fail the check will be marked as corrupt. By default the database will automatically repair corrupt tables (via truncating). Note that since this reads every table column from disk it may be a potentially long-running operation. The option <a href="/content/api/cpp/namespacegpudb#a8401ed637326bcdcc0d079e04c8d3415">local\_only</a> can be used to skip any table files already written to a remote storage. Returns table corruption results.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableNames</td>
                <td>List of tables to query. An asterisk returns all tables. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a8401ed637326bcdcc0d079e04c8d3415">check\_table\_local\_only</a>: If <a href="/content/api/cpp/namespacegpudb#acedf36978a7c4bcd539742011f089d5d">true</a> only locally persisted files will be checked. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#acedf36978a7c4bcd539742011f089d5d">check\_table\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#af4c598105fb0d8ba28b7b7f6fbf3d47f">check\_table\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#af4c598105fb0d8ba28b7b7f6fbf3d47f">check\_table\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a03e8a889b6b455654cae1415bdb0ae11">check\_table\_show\_detail</a>: If <a href="/content/api/cpp/namespacegpudb#acedf36978a7c4bcd539742011f089d5d">true</a> reports individual chunk errors. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#acedf36978a7c4bcd539742011f089d5d">check\_table\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#af4c598105fb0d8ba28b7b7f6fbf3d47f">check\_table\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#acedf36978a7c4bcd539742011f089d5d">check\_table\_true</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CheckTableResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a3ffa91f42f974de2d1872af38fe318f3">◆ </a></span>checkTable() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CheckTableResponse">CheckTableResponse</a> & gpudb::GPUdb::checkTable </td>
            <td>(</td>
            <td>const std::vector\< std::string > &</td>
            <td><span><span>tableNames</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1CheckTableResponse">CheckTableResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Scans the requested tables as specified in <span>tableNames</span> for integrity. </p>
        <p>Any table chunks which fail the check will be marked as corrupt. By default the database will automatically repair corrupt tables (via truncating). Note that since this reads every table column from disk it may be a potentially long-running operation. The option <a href="/content/api/cpp/namespacegpudb#a8401ed637326bcdcc0d079e04c8d3415">local\_only</a> can be used to skip any table files already written to a remote storage. Returns table corruption results.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableNames</td>
                <td>List of tables to query. An asterisk returns all tables. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a8401ed637326bcdcc0d079e04c8d3415">check\_table\_local\_only</a>: If <a href="/content/api/cpp/namespacegpudb#acedf36978a7c4bcd539742011f089d5d">true</a> only locally persisted files will be checked. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#acedf36978a7c4bcd539742011f089d5d">check\_table\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#af4c598105fb0d8ba28b7b7f6fbf3d47f">check\_table\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#af4c598105fb0d8ba28b7b7f6fbf3d47f">check\_table\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a03e8a889b6b455654cae1415bdb0ae11">check\_table\_show\_detail</a>: If <a href="/content/api/cpp/namespacegpudb#acedf36978a7c4bcd539742011f089d5d">true</a> reports individual chunk errors. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#acedf36978a7c4bcd539742011f089d5d">check\_table\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#af4c598105fb0d8ba28b7b7f6fbf3d47f">check\_table\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#acedf36978a7c4bcd539742011f089d5d">check\_table\_true</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CheckTableResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CheckTableResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a4f92562790e4fa6169b14fe3a356d495">◆ </a></span>clearStatistics() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ClearStatisticsResponse">ClearStatisticsResponse</a> gpudb::GPUdb::clearStatistics </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1ClearStatisticsRequest">ClearStatisticsRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Clears statistics (cardinality, mean value, etc.) for a column in a specified table. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ClearStatisticsRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ClearStatisticsResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a1db7da64c443bd49d54d3b6643047916">◆ </a></span>clearStatistics() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ClearStatisticsResponse">ClearStatisticsResponse</a> & gpudb::GPUdb::clearStatistics </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1ClearStatisticsRequest">ClearStatisticsRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1ClearStatisticsResponse">ClearStatisticsResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Clears statistics (cardinality, mean value, etc.) for a column in a specified table. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ClearStatisticsRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ClearStatisticsResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ClearStatisticsResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ae73eefae2052b3fa6fb5788d819f9e8a">◆ </a></span>clearStatistics() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ClearStatisticsResponse">ClearStatisticsResponse</a> gpudb::GPUdb::clearStatistics </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>columnName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Clears statistics (cardinality, mean value, etc.) for a column in a specified table. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of a table, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. Must be an existing table. A value of '\*' clears statistics on every user table the caller may read (excluding system schemas, views, and temporary tables); when used, <span>columnName</span> must be empty. The default value is ''. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>columnName</td>
                <td>Name of the column in <span>tableName</span> for which to clear statistics. The column must be from an existing table. An empty string clears statistics for all columns in the table. Must be empty when <span>tableName</span> is '\*'. The default value is ''. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ClearStatisticsResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a8fc73e98a02f047df4bfc89cf0946511">◆ </a></span>clearStatistics() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ClearStatisticsResponse">ClearStatisticsResponse</a> & gpudb::GPUdb::clearStatistics </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>columnName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1ClearStatisticsResponse">ClearStatisticsResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Clears statistics (cardinality, mean value, etc.) for a column in a specified table. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of a table, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. Must be an existing table. A value of '\*' clears statistics on every user table the caller may read (excluding system schemas, views, and temporary tables); when used, <span>columnName</span> must be empty. The default value is ''. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>columnName</td>
                <td>Name of the column in <span>tableName</span> for which to clear statistics. The column must be from an existing table. An empty string clears statistics for all columns in the table. Must be empty when <span>tableName</span> is '\*'. The default value is ''. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ClearStatisticsResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ClearStatisticsResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a438f915ee5d2c8e5c624610842f47b34">◆ </a></span>clearTable() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ClearTableResponse">ClearTableResponse</a> gpudb::GPUdb::clearTable </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1ClearTableRequest">ClearTableRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Clears (drops) one or all tables in the database cluster. </p>
        <p>The operation is synchronous meaning that the table will be cleared before the function returns. The response payload returns the status of the operation along with the name of the table that was cleared.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ClearTableRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ClearTableResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a05977053bbeeee30aef9c3eccf98bdf3">◆ </a></span>clearTable() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ClearTableResponse">ClearTableResponse</a> & gpudb::GPUdb::clearTable </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1ClearTableRequest">ClearTableRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1ClearTableResponse">ClearTableResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Clears (drops) one or all tables in the database cluster. </p>
        <p>The operation is synchronous meaning that the table will be cleared before the function returns. The response payload returns the status of the operation along with the name of the table that was cleared.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ClearTableRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ClearTableResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ClearTableResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a52e2ee9452af707377a8cca0af68320d">◆ </a></span>clearTable() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ClearTableResponse">ClearTableResponse</a> gpudb::GPUdb::clearTable </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>authorization</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Clears (drops) one or all tables in the database cluster. </p>
        <p>The operation is synchronous meaning that the table will be cleared before the function returns. The response payload returns the status of the operation along with the name of the table that was cleared.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of the table to be cleared, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. Must be an existing table. Empty string clears all available tables, though this behavior is be prevented by default via gpudb.conf parameter 'disable\_clear\_all'. The default value is ''. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>authorization</td>
                <td>No longer used. User can pass an empty string. The default value is ''. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#adea8b5fd768ea481c4324cedafc8ccc0">clear\_table\_no\_error\_if\_not\_exists</a>: If <a href="/content/api/cpp/namespacegpudb#a19066cad9fd313d9af1c6e6b7abfaaf5">true</a> and if the table specified in <span>tableName</span> does not exist no error is returned. If <a href="/content/api/cpp/namespacegpudb#a8ce33841713205619a147b0e16df489b">false</a> and if the table specified in <span>tableName</span> does not exist then an error is returned. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a19066cad9fd313d9af1c6e6b7abfaaf5">clear\_table\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a8ce33841713205619a147b0e16df489b">clear\_table\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a8ce33841713205619a147b0e16df489b">clear\_table\_false</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ClearTableResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ae372d9957b28f88e656b4a683fc7de41">◆ </a></span>clearTable() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ClearTableResponse">ClearTableResponse</a> & gpudb::GPUdb::clearTable </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>authorization</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1ClearTableResponse">ClearTableResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Clears (drops) one or all tables in the database cluster. </p>
        <p>The operation is synchronous meaning that the table will be cleared before the function returns. The response payload returns the status of the operation along with the name of the table that was cleared.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of the table to be cleared, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. Must be an existing table. Empty string clears all available tables, though this behavior is be prevented by default via gpudb.conf parameter 'disable\_clear\_all'. The default value is ''. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>authorization</td>
                <td>No longer used. User can pass an empty string. The default value is ''. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#adea8b5fd768ea481c4324cedafc8ccc0">clear\_table\_no\_error\_if\_not\_exists</a>: If <a href="/content/api/cpp/namespacegpudb#a19066cad9fd313d9af1c6e6b7abfaaf5">true</a> and if the table specified in <span>tableName</span> does not exist no error is returned. If <a href="/content/api/cpp/namespacegpudb#a8ce33841713205619a147b0e16df489b">false</a> and if the table specified in <span>tableName</span> does not exist then an error is returned. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a19066cad9fd313d9af1c6e6b7abfaaf5">clear\_table\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a8ce33841713205619a147b0e16df489b">clear\_table\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a8ce33841713205619a147b0e16df489b">clear\_table\_false</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ClearTableResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ClearTableResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ad2bf08c0671686d9fd13ec177214fa1c">◆ </a></span>clearTableMonitor() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ClearTableMonitorResponse">ClearTableMonitorResponse</a> gpudb::GPUdb::clearTableMonitor </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1ClearTableMonitorRequest">ClearTableMonitorRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Deactivates a table monitor previously created with <a href="#ab379d6656d94cb2e54be2671ecd05d6c">createTableMonitor</a>. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ClearTableMonitorRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ClearTableMonitorResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#acbb596d576cf6071fec8a46cf8f536ca">◆ </a></span>clearTableMonitor() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ClearTableMonitorResponse">ClearTableMonitorResponse</a> & gpudb::GPUdb::clearTableMonitor </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1ClearTableMonitorRequest">ClearTableMonitorRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1ClearTableMonitorResponse">ClearTableMonitorResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Deactivates a table monitor previously created with <a href="#ab379d6656d94cb2e54be2671ecd05d6c">createTableMonitor</a>. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ClearTableMonitorRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ClearTableMonitorResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ClearTableMonitorResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ad85f24dc8ca9ac3d649aaa969febcf25">◆ </a></span>clearTableMonitor() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ClearTableMonitorResponse">ClearTableMonitorResponse</a> gpudb::GPUdb::clearTableMonitor </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>topicId</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Deactivates a table monitor previously created with <a href="#a562dc443f79f57ea572cb5ec0f2e8093">createTableMonitor</a>. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>topicId</td>
                <td>The topic ID returned by <a href="#a562dc443f79f57ea572cb5ec0f2e8093">createTableMonitor</a>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a8961301f127ebf4419ba031ddf28300b">clear\_table\_monitor\_keep\_autogenerated\_sink</a>: If <a href="/content/api/cpp/namespacegpudb#a68f6f1f96002d7596db2f39e56809474">true</a>, the auto-generated <a href="/content/concepts/data_sinks/">datasink</a> associated with this monitor, if there is one, will be retained for further use. If <a href="/content/api/cpp/namespacegpudb#a460ec95af1cc4a386ac3fc320b89f9ef">false</a>, then the auto-generated sink will be dropped if there are no other monitors referencing it. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a68f6f1f96002d7596db2f39e56809474">clear\_table\_monitor\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a460ec95af1cc4a386ac3fc320b89f9ef">clear\_table\_monitor\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a460ec95af1cc4a386ac3fc320b89f9ef">clear\_table\_monitor\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ad82dfc77a824d33ee9d35ae6b9697609">clear\_table\_monitor\_clear\_all\_references</a>: If <a href="/content/api/cpp/namespacegpudb#a68f6f1f96002d7596db2f39e56809474">true</a>, all references that share the same <span>topicId</span> will be cleared. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a68f6f1f96002d7596db2f39e56809474">clear\_table\_monitor\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a460ec95af1cc4a386ac3fc320b89f9ef">clear\_table\_monitor\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a460ec95af1cc4a386ac3fc320b89f9ef">clear\_table\_monitor\_false</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ClearTableMonitorResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a0d0c0fadbf1e7057cf5e3bfc451e6e49">◆ </a></span>clearTableMonitor() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ClearTableMonitorResponse">ClearTableMonitorResponse</a> & gpudb::GPUdb::clearTableMonitor </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>topicId</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1ClearTableMonitorResponse">ClearTableMonitorResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Deactivates a table monitor previously created with <a href="#a562dc443f79f57ea572cb5ec0f2e8093">createTableMonitor</a>. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>topicId</td>
                <td>The topic ID returned by <a href="#a562dc443f79f57ea572cb5ec0f2e8093">createTableMonitor</a>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a8961301f127ebf4419ba031ddf28300b">clear\_table\_monitor\_keep\_autogenerated\_sink</a>: If <a href="/content/api/cpp/namespacegpudb#a68f6f1f96002d7596db2f39e56809474">true</a>, the auto-generated <a href="/content/concepts/data_sinks/">datasink</a> associated with this monitor, if there is one, will be retained for further use. If <a href="/content/api/cpp/namespacegpudb#a460ec95af1cc4a386ac3fc320b89f9ef">false</a>, then the auto-generated sink will be dropped if there are no other monitors referencing it. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a68f6f1f96002d7596db2f39e56809474">clear\_table\_monitor\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a460ec95af1cc4a386ac3fc320b89f9ef">clear\_table\_monitor\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a460ec95af1cc4a386ac3fc320b89f9ef">clear\_table\_monitor\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ad82dfc77a824d33ee9d35ae6b9697609">clear\_table\_monitor\_clear\_all\_references</a>: If <a href="/content/api/cpp/namespacegpudb#a68f6f1f96002d7596db2f39e56809474">true</a>, all references that share the same <span>topicId</span> will be cleared. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a68f6f1f96002d7596db2f39e56809474">clear\_table\_monitor\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a460ec95af1cc4a386ac3fc320b89f9ef">clear\_table\_monitor\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a460ec95af1cc4a386ac3fc320b89f9ef">clear\_table\_monitor\_false</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ClearTableMonitorResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ClearTableMonitorResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a6ea34c34f63eb6781811eea53b2a7e33">◆ </a></span>clearTables() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ClearTablesResponse">ClearTablesResponse</a> gpudb::GPUdb::clearTables </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1ClearTablesRequest">ClearTablesRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Clears (drops) tables in the database cluster. </p>
        <p>The operation is synchronous meaning that the tables will be cleared before the function returns. The response payload returns the status of the operation for each table requested.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ClearTablesRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ClearTablesResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#aa039ed76125cf6049542860f71f8a2fe">◆ </a></span>clearTables() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ClearTablesResponse">ClearTablesResponse</a> & gpudb::GPUdb::clearTables </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1ClearTablesRequest">ClearTablesRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1ClearTablesResponse">ClearTablesResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Clears (drops) tables in the database cluster. </p>
        <p>The operation is synchronous meaning that the tables will be cleared before the function returns. The response payload returns the status of the operation for each table requested.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ClearTablesRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ClearTablesResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ClearTablesResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ad41cf27b402ded6a1b6876bfcd28770e">◆ </a></span>clearTables() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ClearTablesResponse">ClearTablesResponse</a> gpudb::GPUdb::clearTables </td>
            <td>(</td>
            <td>const std::vector\< std::string > &</td>
            <td><span><span>tableNames</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Clears (drops) tables in the database cluster. </p>
        <p>The operation is synchronous meaning that the tables will be cleared before the function returns. The response payload returns the status of the operation for each table requested.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableNames</td>
                <td>Names of the tables to be cleared, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. Must be existing tables. Empty list clears all available tables, though this behavior is be prevented by default via gpudb.conf parameter 'disable\_clear\_all'. The default value is an empty vector. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#aad8bebea802c4d60f13cb20c11cdee46">clear\_tables\_no\_error\_if\_not\_exists</a>: If <a href="/content/api/cpp/namespacegpudb#aeb4d938d6844d47c476c1e7f793b7603">true</a> and if a table specified in <span>tableNames</span> does not exist no error is returned. If <a href="/content/api/cpp/namespacegpudb#a0820747ad294b1af92e267be2a7beae0">false</a> and if a table specified in <span>tableNames</span> does not exist then an error is returned. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#aeb4d938d6844d47c476c1e7f793b7603">clear\_tables\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a0820747ad294b1af92e267be2a7beae0">clear\_tables\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a0820747ad294b1af92e267be2a7beae0">clear\_tables\_false</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ClearTablesResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a2be613cf6005c367f6d4f2f9835f2d27">◆ </a></span>clearTables() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ClearTablesResponse">ClearTablesResponse</a> & gpudb::GPUdb::clearTables </td>
            <td>(</td>
            <td>const std::vector\< std::string > &</td>
            <td><span><span>tableNames</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1ClearTablesResponse">ClearTablesResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Clears (drops) tables in the database cluster. </p>
        <p>The operation is synchronous meaning that the tables will be cleared before the function returns. The response payload returns the status of the operation for each table requested.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableNames</td>
                <td>Names of the tables to be cleared, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. Must be existing tables. Empty list clears all available tables, though this behavior is be prevented by default via gpudb.conf parameter 'disable\_clear\_all'. The default value is an empty vector. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#aad8bebea802c4d60f13cb20c11cdee46">clear\_tables\_no\_error\_if\_not\_exists</a>: If <a href="/content/api/cpp/namespacegpudb#aeb4d938d6844d47c476c1e7f793b7603">true</a> and if a table specified in <span>tableNames</span> does not exist no error is returned. If <a href="/content/api/cpp/namespacegpudb#a0820747ad294b1af92e267be2a7beae0">false</a> and if a table specified in <span>tableNames</span> does not exist then an error is returned. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#aeb4d938d6844d47c476c1e7f793b7603">clear\_tables\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a0820747ad294b1af92e267be2a7beae0">clear\_tables\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a0820747ad294b1af92e267be2a7beae0">clear\_tables\_false</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ClearTablesResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ClearTablesResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a158a4cbcafb96ac8832f7caeeb07e4b3">◆ </a></span>clearTrigger() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ClearTriggerResponse">ClearTriggerResponse</a> gpudb::GPUdb::clearTrigger </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1ClearTriggerRequest">ClearTriggerRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Clears or cancels the trigger identified by the specified handle. </p>
        <p>The output returns the handle of the trigger cleared as well as indicating success or failure of the trigger deactivation.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ClearTriggerRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ClearTriggerResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a30c0fca7857d41b31082a178e90b024e">◆ </a></span>clearTrigger() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ClearTriggerResponse">ClearTriggerResponse</a> & gpudb::GPUdb::clearTrigger </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1ClearTriggerRequest">ClearTriggerRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1ClearTriggerResponse">ClearTriggerResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Clears or cancels the trigger identified by the specified handle. </p>
        <p>The output returns the handle of the trigger cleared as well as indicating success or failure of the trigger deactivation.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ClearTriggerRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ClearTriggerResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ClearTriggerResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a582553240e7015f44ae86078ec533a85">◆ </a></span>clearTrigger() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ClearTriggerResponse">ClearTriggerResponse</a> gpudb::GPUdb::clearTrigger </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>triggerId</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Clears or cancels the trigger identified by the specified handle. </p>
        <p>The output returns the handle of the trigger cleared as well as indicating success or failure of the trigger deactivation.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>triggerId</td>
                <td>ID for the trigger to be deactivated. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ClearTriggerResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#adfafb6200f23ba0728ffddda95421437">◆ </a></span>clearTrigger() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ClearTriggerResponse">ClearTriggerResponse</a> & gpudb::GPUdb::clearTrigger </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>triggerId</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1ClearTriggerResponse">ClearTriggerResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Clears or cancels the trigger identified by the specified handle. </p>
        <p>The output returns the handle of the trigger cleared as well as indicating success or failure of the trigger deactivation.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>triggerId</td>
                <td>ID for the trigger to be deactivated. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ClearTriggerResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ClearTriggerResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a71a881b85611086a22694f352810dc45">◆ </a></span>collectStatistics() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CollectStatisticsResponse">CollectStatisticsResponse</a> gpudb::GPUdb::collectStatistics </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1CollectStatisticsRequest">CollectStatisticsRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Collect statistics for a column(s) in a specified table. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CollectStatisticsRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CollectStatisticsResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a8658d61bf4e34f6ae3b01b3fad968b35">◆ </a></span>collectStatistics() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CollectStatisticsResponse">CollectStatisticsResponse</a> & gpudb::GPUdb::collectStatistics </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1CollectStatisticsRequest">CollectStatisticsRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1CollectStatisticsResponse">CollectStatisticsResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Collect statistics for a column(s) in a specified table. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CollectStatisticsRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CollectStatisticsResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CollectStatisticsResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#af9b91d47a757a26bd1ba21d88fed6307">◆ </a></span>collectStatistics() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CollectStatisticsResponse">CollectStatisticsResponse</a> gpudb::GPUdb::collectStatistics </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< std::string > &</td>
            <td><span><span>columnNames</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Collect statistics for a column(s) in a specified table. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of a table, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. Must be an existing table. A value of '\*' collects statistics on every user table the caller may read (excluding system schemas, views, and temporary tables); when used, <span>columnNames</span> must be '\*'. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>columnNames</td>
                <td>List of one or more column names in <span>tableName</span> for which to collect statistics (cardinality, mean value, etc.). A single entry of '\*' expands to every collectable column on the table (geometry, vector, JSON, and array columns are skipped). </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CollectStatisticsResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a359611cda560b55497bb44388a699f80">◆ </a></span>collectStatistics() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CollectStatisticsResponse">CollectStatisticsResponse</a> & gpudb::GPUdb::collectStatistics </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< std::string > &</td>
            <td><span><span>columnNames</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1CollectStatisticsResponse">CollectStatisticsResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Collect statistics for a column(s) in a specified table. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of a table, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. Must be an existing table. A value of '\*' collects statistics on every user table the caller may read (excluding system schemas, views, and temporary tables); when used, <span>columnNames</span> must be '\*'. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>columnNames</td>
                <td>List of one or more column names in <span>tableName</span> for which to collect statistics (cardinality, mean value, etc.). A single entry of '\*' expands to every collectable column on the table (geometry, vector, JSON, and array columns are skipped). </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CollectStatisticsResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CollectStatisticsResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a8b23a215e39231b2719d9eaf103e91a5">◆ </a></span>createBackup() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CreateBackupResponse">CreateBackupResponse</a> gpudb::GPUdb::createBackup </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1CreateBackupRequest">CreateBackupRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Creates a database <a href="/content/admin/backup_restore/#database-backup">backup</a>, containing a snapshot of existing objects, at the remote file store accessible via the <a href="/content/concepts/data_sinks/">data sink</a> specified by <a href="/content/api/cpp/structgpudb_1_1CreateBackupRequest#a5e58568622ccf02370239603be22c85d">datasinkName</a>. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CreateBackupRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CreateBackupResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#adee6a721e30c2f3dcb7338b33e34b6f6">◆ </a></span>createBackup() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CreateBackupResponse">CreateBackupResponse</a> & gpudb::GPUdb::createBackup </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1CreateBackupRequest">CreateBackupRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1CreateBackupResponse">CreateBackupResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Creates a database <a href="/content/admin/backup_restore/#database-backup">backup</a>, containing a snapshot of existing objects, at the remote file store accessible via the <a href="/content/concepts/data_sinks/">data sink</a> specified by <a href="/content/api/cpp/structgpudb_1_1CreateBackupRequest#a5e58568622ccf02370239603be22c85d">datasinkName</a>. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CreateBackupRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CreateBackupResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CreateBackupResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a3042866fcc5ed4439c93db74ccc8e1fd">◆ </a></span>createBackup() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CreateBackupResponse">CreateBackupResponse</a> gpudb::GPUdb::createBackup </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>backupName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>backupType</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>backupObjectsMap</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>datasinkName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Creates a database <a href="/content/admin/backup_restore/#database-backup">backup</a>, containing a snapshot of existing objects, at the remote file store accessible via the <a href="/content/concepts/data_sinks/">data sink</a> specified by <span>datasinkName</span>. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>backupName</td>
                <td>Name for this backup. If the backup already exists, only an incremental or differential backup can be made, unless <a href="/content/api/cpp/namespacegpudb#ab9b18505d61116c56e2b1c34082e39c6">recreate</a> is set to <a href="/content/api/cpp/namespacegpudb#a775715678c38a5d615c4a1d1fbdd5637">true</a>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>backupType</td>

                <td>
                  <a href="/content/api/cpp/classgpudb_1_1Type">Type</a> of snapshot to create. Supported values:

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a2054defdcd4d203766463d1d858555d5">create\_backup\_differential</a>: Snapshot of changes in the database objects and data since the last full snapshot. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a1ccf48cfebf436df551cfe63700d84e5">create\_backup\_full</a>: Snapshot of the given database objects and data. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#af763a8d93c789baa3e0822dfbdfd145f">create\_backup\_incremental</a>: Snapshot of changes in the database objects and data since the last snapshot of any kind. </li>
                  </ul>
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>backupObjectsMap</td>

                <td>
                  Map of objects to be captured in the backup; must be specified when creating a full snapshot and left unspecified when creating an incremental or differential snapshot.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#ae37707afbe708686542c206e58beb8f6">create\_backup\_all</a>: All object types and data contained in the given <a href="/content/concepts/schemas/">schema(s)</a>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ad2250be35f3b277e4a477f9af2e2c9fa">create\_backup\_catalog</a>: Data Lake catalog that is external to the database. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a44e3a57cb038936ac1c0cba40587b3c2">create\_backup\_context</a>: <a href="/content/sql-gpt/concepts/#sql-gpt-context">Context(s)</a>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#afcdba3877540f96c05bf653086e923dd">create\_backup\_credential</a>: <a href="/content/concepts/credentials/">Credential(s)</a>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a2431b562b7c4f2f278c68ab2496dca45">create\_backup\_datasink</a>: <a href="/content/concepts/data_sinks/">Data sink(s)</a>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a5973a4aaad70c65d0ae9095e25bd9f15">create\_backup\_datasource</a>: <a href="/content/concepts/data_sources/">Data source(s)</a>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a49c3270753d16b9b16708094e7ec5b13">create\_backup\_directory</a>: KiFS <a href="/content/tools/kifs/">File directory(ies)</a>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a324d5ae0288c1a691b1d904dccdf67f2">create\_backup\_function\_environment</a>: <a href="/content/udf/python/writing/#udf-python-func-env">Python UDF function environment(s)</a>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a96786a12cf5613528b329e7bf0997bf6">create\_backup\_graph</a>: <a href="/content/graph_solver/network_graph_solver/">Graph</a> definition(s). Source table(s), if applicable, are required in order to restore graph objects. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ae9a4abecc01a8cc450c45ad6b97fae69">create\_backup\_monitor</a>: <a href="/content/concepts/table_monitors/">Table monitor(s)</a> / <a href="/content/sql/ddl/#create-stream">SQL stream(s)</a>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a720e18f531ad83c46c2fc90cb0b90a15">create\_backup\_resource\_group</a>: <a href="/content/rm/concepts/#resource-groups">Resource group(s)</a>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a9b67f5a0dbca7e23773060f393056665">create\_backup\_role</a>: <a href="/content/security/sec_concepts/#roles">Role(s)</a>, role members (roles or users, recursively), and associated permissions. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a78d0a0a13be222c8d9898b6ef0d5052f">create\_backup\_stored\_procedure</a>: <a href="/content/sql/procedure/">SQL procedure(s)</a>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a0cb9a37268f3727b008ecf111416b969">create\_backup\_table</a>: <a href="/content/concepts/tables/">Table(s)</a> and <a href="/content/sql/ddl/#create-view">SQL view(s)</a>. Active subscriptions on any tables to be backed up will be temporarily suspended while the backup is active. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aa86e001f0b5e523b1d76f71bf02a7768">create\_backup\_user</a>: <a href="/content/security/sec_concepts/#security-concepts-users">User(s)</a> (internal and external) and associated permissions. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a55c98b5f7252ff61f01762132d74fa1b">create\_backup\_user\_defined\_function</a>: <a href="/content/udf_overview">UDF(s)</a>. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>datasinkName</td>
                <td>Data sink through which the backup will be stored. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ac3a849d2a4c932616342e873db857844">create\_backup\_block\_table\_mutations</a>: Whether or not to block all mutations on target tables while they are being backed up. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a775715678c38a5d615c4a1d1fbdd5637">create\_backup\_true</a>: Block all mutations on target tables while they are being backed up. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a732ceaf11b185b4185a1150da98b73e1">create\_backup\_false</a>: Only block mutations on a target table at the point a disk eviction is necessary. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a732ceaf11b185b4185a1150da98b73e1">create\_backup\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#aa6940a725ad0e9e33cfb7cba41d968bc">create\_backup\_checksum</a>: Whether or not to calculate checksums for backup files. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a775715678c38a5d615c4a1d1fbdd5637">create\_backup\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a732ceaf11b185b4185a1150da98b73e1">create\_backup\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a732ceaf11b185b4185a1150da98b73e1">create\_backup\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#ab65c3a8b5b94662e274b3ae5e7635ee5">create\_backup\_comment</a>: Comments to store with this backup. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ab2b01d977c6b8b68c20abed16db58313">create\_backup\_ddl\_only</a>: Whether or not, for tables, to only backup DDL and not table data. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a775715678c38a5d615c4a1d1fbdd5637">create\_backup\_true</a>: For tables, only back up DDL, not data. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a732ceaf11b185b4185a1150da98b73e1">create\_backup\_false</a>: For tables, back up DDL and data. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a732ceaf11b185b4185a1150da98b73e1">create\_backup\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a99c4f971adf5d65bb6968875fb6bf2f1">create\_backup\_delete\_intermediate\_backups</a>: Whether or not to delete any intermediate snapshots when the <span>backupType</span> is set to <a href="/content/api/cpp/namespacegpudb#a2054defdcd4d203766463d1d858555d5">differential</a>. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a775715678c38a5d615c4a1d1fbdd5637">create\_backup\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a732ceaf11b185b4185a1150da98b73e1">create\_backup\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a732ceaf11b185b4185a1150da98b73e1">create\_backup\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a8dbaab3c0f03dc038a6034605a5c1249">create\_backup\_dry\_run</a>: Whether or not to perform a dry run of a backup operation. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a775715678c38a5d615c4a1d1fbdd5637">create\_backup\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a732ceaf11b185b4185a1150da98b73e1">create\_backup\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a732ceaf11b185b4185a1150da98b73e1">create\_backup\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a879cb3cd79c29df04911c00087f7e8ca">create\_backup\_max\_incremental\_backups\_to\_keep</a>: Maximum number of incremental snapshots to keep. The default value is '-1'. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ab9b18505d61116c56e2b1c34082e39c6">create\_backup\_recreate</a>: Whether or not to replace an existing backup object with a new backup with a full snapshot, if one already exists. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a775715678c38a5d615c4a1d1fbdd5637">create\_backup\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a732ceaf11b185b4185a1150da98b73e1">create\_backup\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a732ceaf11b185b4185a1150da98b73e1">create\_backup\_false</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CreateBackupResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a624eee76216dd95185333b2c4aff6803">◆ </a></span>createBackup() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CreateBackupResponse">CreateBackupResponse</a> & gpudb::GPUdb::createBackup </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>backupName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>backupType</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>backupObjectsMap</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>datasinkName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1CreateBackupResponse">CreateBackupResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Creates a database <a href="/content/admin/backup_restore/#database-backup">backup</a>, containing a snapshot of existing objects, at the remote file store accessible via the <a href="/content/concepts/data_sinks/">data sink</a> specified by <span>datasinkName</span>. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>backupName</td>
                <td>Name for this backup. If the backup already exists, only an incremental or differential backup can be made, unless <a href="/content/api/cpp/namespacegpudb#ab9b18505d61116c56e2b1c34082e39c6">recreate</a> is set to <a href="/content/api/cpp/namespacegpudb#a775715678c38a5d615c4a1d1fbdd5637">true</a>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>backupType</td>

                <td>
                  <a href="/content/api/cpp/classgpudb_1_1Type">Type</a> of snapshot to create. Supported values:

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a2054defdcd4d203766463d1d858555d5">create\_backup\_differential</a>: Snapshot of changes in the database objects and data since the last full snapshot. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a1ccf48cfebf436df551cfe63700d84e5">create\_backup\_full</a>: Snapshot of the given database objects and data. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#af763a8d93c789baa3e0822dfbdfd145f">create\_backup\_incremental</a>: Snapshot of changes in the database objects and data since the last snapshot of any kind. </li>
                  </ul>
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>backupObjectsMap</td>

                <td>
                  Map of objects to be captured in the backup; must be specified when creating a full snapshot and left unspecified when creating an incremental or differential snapshot.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#ae37707afbe708686542c206e58beb8f6">create\_backup\_all</a>: All object types and data contained in the given <a href="/content/concepts/schemas/">schema(s)</a>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ad2250be35f3b277e4a477f9af2e2c9fa">create\_backup\_catalog</a>: Data Lake catalog that is external to the database. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a44e3a57cb038936ac1c0cba40587b3c2">create\_backup\_context</a>: <a href="/content/sql-gpt/concepts/#sql-gpt-context">Context(s)</a>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#afcdba3877540f96c05bf653086e923dd">create\_backup\_credential</a>: <a href="/content/concepts/credentials/">Credential(s)</a>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a2431b562b7c4f2f278c68ab2496dca45">create\_backup\_datasink</a>: <a href="/content/concepts/data_sinks/">Data sink(s)</a>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a5973a4aaad70c65d0ae9095e25bd9f15">create\_backup\_datasource</a>: <a href="/content/concepts/data_sources/">Data source(s)</a>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a49c3270753d16b9b16708094e7ec5b13">create\_backup\_directory</a>: KiFS <a href="/content/tools/kifs/">File directory(ies)</a>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a324d5ae0288c1a691b1d904dccdf67f2">create\_backup\_function\_environment</a>: <a href="/content/udf/python/writing/#udf-python-func-env">Python UDF function environment(s)</a>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a96786a12cf5613528b329e7bf0997bf6">create\_backup\_graph</a>: <a href="/content/graph_solver/network_graph_solver/">Graph</a> definition(s). Source table(s), if applicable, are required in order to restore graph objects. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ae9a4abecc01a8cc450c45ad6b97fae69">create\_backup\_monitor</a>: <a href="/content/concepts/table_monitors/">Table monitor(s)</a> / <a href="/content/sql/ddl/#create-stream">SQL stream(s)</a>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a720e18f531ad83c46c2fc90cb0b90a15">create\_backup\_resource\_group</a>: <a href="/content/rm/concepts/#resource-groups">Resource group(s)</a>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a9b67f5a0dbca7e23773060f393056665">create\_backup\_role</a>: <a href="/content/security/sec_concepts/#roles">Role(s)</a>, role members (roles or users, recursively), and associated permissions. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a78d0a0a13be222c8d9898b6ef0d5052f">create\_backup\_stored\_procedure</a>: <a href="/content/sql/procedure/">SQL procedure(s)</a>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a0cb9a37268f3727b008ecf111416b969">create\_backup\_table</a>: <a href="/content/concepts/tables/">Table(s)</a> and <a href="/content/sql/ddl/#create-view">SQL view(s)</a>. Active subscriptions on any tables to be backed up will be temporarily suspended while the backup is active. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aa86e001f0b5e523b1d76f71bf02a7768">create\_backup\_user</a>: <a href="/content/security/sec_concepts/#security-concepts-users">User(s)</a> (internal and external) and associated permissions. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a55c98b5f7252ff61f01762132d74fa1b">create\_backup\_user\_defined\_function</a>: <a href="/content/udf_overview">UDF(s)</a>. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>datasinkName</td>
                <td>Data sink through which the backup will be stored. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ac3a849d2a4c932616342e873db857844">create\_backup\_block\_table\_mutations</a>: Whether or not to block all mutations on target tables while they are being backed up. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a775715678c38a5d615c4a1d1fbdd5637">create\_backup\_true</a>: Block all mutations on target tables while they are being backed up. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a732ceaf11b185b4185a1150da98b73e1">create\_backup\_false</a>: Only block mutations on a target table at the point a disk eviction is necessary. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a732ceaf11b185b4185a1150da98b73e1">create\_backup\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#aa6940a725ad0e9e33cfb7cba41d968bc">create\_backup\_checksum</a>: Whether or not to calculate checksums for backup files. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a775715678c38a5d615c4a1d1fbdd5637">create\_backup\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a732ceaf11b185b4185a1150da98b73e1">create\_backup\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a732ceaf11b185b4185a1150da98b73e1">create\_backup\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#ab65c3a8b5b94662e274b3ae5e7635ee5">create\_backup\_comment</a>: Comments to store with this backup. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ab2b01d977c6b8b68c20abed16db58313">create\_backup\_ddl\_only</a>: Whether or not, for tables, to only backup DDL and not table data. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a775715678c38a5d615c4a1d1fbdd5637">create\_backup\_true</a>: For tables, only back up DDL, not data. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a732ceaf11b185b4185a1150da98b73e1">create\_backup\_false</a>: For tables, back up DDL and data. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a732ceaf11b185b4185a1150da98b73e1">create\_backup\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a99c4f971adf5d65bb6968875fb6bf2f1">create\_backup\_delete\_intermediate\_backups</a>: Whether or not to delete any intermediate snapshots when the <span>backupType</span> is set to <a href="/content/api/cpp/namespacegpudb#a2054defdcd4d203766463d1d858555d5">differential</a>. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a775715678c38a5d615c4a1d1fbdd5637">create\_backup\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a732ceaf11b185b4185a1150da98b73e1">create\_backup\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a732ceaf11b185b4185a1150da98b73e1">create\_backup\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a8dbaab3c0f03dc038a6034605a5c1249">create\_backup\_dry\_run</a>: Whether or not to perform a dry run of a backup operation. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a775715678c38a5d615c4a1d1fbdd5637">create\_backup\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a732ceaf11b185b4185a1150da98b73e1">create\_backup\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a732ceaf11b185b4185a1150da98b73e1">create\_backup\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a879cb3cd79c29df04911c00087f7e8ca">create\_backup\_max\_incremental\_backups\_to\_keep</a>: Maximum number of incremental snapshots to keep. The default value is '-1'. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ab9b18505d61116c56e2b1c34082e39c6">create\_backup\_recreate</a>: Whether or not to replace an existing backup object with a new backup with a full snapshot, if one already exists. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a775715678c38a5d615c4a1d1fbdd5637">create\_backup\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a732ceaf11b185b4185a1150da98b73e1">create\_backup\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a732ceaf11b185b4185a1150da98b73e1">create\_backup\_false</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CreateBackupResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CreateBackupResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ac1a6c29a53988d10165a41ae5ce64658">◆ </a></span>createCatalog() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CreateCatalogResponse">CreateCatalogResponse</a> gpudb::GPUdb::createCatalog </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1CreateCatalogRequest">CreateCatalogRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Creates a catalog, which contains the location and connection information for a deltalake catalog that is external to the database. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CreateCatalogRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CreateCatalogResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a78817925c0fe763a6bcfa967c0c4a3d8">◆ </a></span>createCatalog() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CreateCatalogResponse">CreateCatalogResponse</a> & gpudb::GPUdb::createCatalog </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1CreateCatalogRequest">CreateCatalogRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1CreateCatalogResponse">CreateCatalogResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Creates a catalog, which contains the location and connection information for a deltalake catalog that is external to the database. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CreateCatalogRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CreateCatalogResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CreateCatalogResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a75400b465e05223445c85418a570431a">◆ </a></span>createCatalog() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CreateCatalogResponse">CreateCatalogResponse</a> gpudb::GPUdb::createCatalog </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>tableFormat</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>location</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>type</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>credential</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>datasource</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Creates a catalog, which contains the location and connection information for a deltalake catalog that is external to the database. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>name</td>
                <td>Name of the catalog to be created. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>tableFormat</td>
                <td>Table format (iceberg, hudi, deltalake). </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>location</td>
                <td>Location of the catalog in 'http\[s]://\[server\[:port]]]' format. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>type</td>
                <td><a href="/content/api/cpp/classgpudb_1_1Type">Type</a> of the catalog (REST (unity, polaris, tabular), nessie, hive, glue). </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>credential</td>
                <td>Name of the <a href="/content/concepts/credentials">credential</a> object to be used in catalog. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>datasource</td>
                <td>Password for the remote system user; may be an empty string. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#aaaa1925d5f6fa4a9301184d25a5dff2c">create\_catalog\_access\_delegation</a>: Use access delegation for object store. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#affc0a1c0e86ac6150585cf9a0a15cc87">create\_catalog\_datasource\_credentials</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a754adf5d916f717c0b3d8033d6864b65">create\_catalog\_vended\_credentials</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#affc0a1c0e86ac6150585cf9a0a15cc87">create\_catalog\_datasource\_credentials</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a0f2f4db7367dd6bb39e8b5deecd0efba">create\_catalog\_skip\_validation</a>: Bypass validation of connection to remote source. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a2a3375faf37eec7ee2b916662f4caf7f">create\_catalog\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a6ebac5b67471f8cab689f87cee97947f">create\_catalog\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a6ebac5b67471f8cab689f87cee97947f">create\_catalog\_false</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CreateCatalogResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a989ff90c51590e7793d43031ad48f7a9">◆ </a></span>createCatalog() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CreateCatalogResponse">CreateCatalogResponse</a> & gpudb::GPUdb::createCatalog </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>tableFormat</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>location</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>type</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>credential</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>datasource</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1CreateCatalogResponse">CreateCatalogResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Creates a catalog, which contains the location and connection information for a deltalake catalog that is external to the database. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>name</td>
                <td>Name of the catalog to be created. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>tableFormat</td>
                <td>Table format (iceberg, hudi, deltalake). </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>location</td>
                <td>Location of the catalog in 'http\[s]://\[server\[:port]]]' format. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>type</td>
                <td><a href="/content/api/cpp/classgpudb_1_1Type">Type</a> of the catalog (REST (unity, polaris, tabular), nessie, hive, glue). </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>credential</td>
                <td>Name of the <a href="/content/concepts/credentials">credential</a> object to be used in catalog. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>datasource</td>
                <td>Password for the remote system user; may be an empty string. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#aaaa1925d5f6fa4a9301184d25a5dff2c">create\_catalog\_access\_delegation</a>: Use access delegation for object store. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#affc0a1c0e86ac6150585cf9a0a15cc87">create\_catalog\_datasource\_credentials</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a754adf5d916f717c0b3d8033d6864b65">create\_catalog\_vended\_credentials</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#affc0a1c0e86ac6150585cf9a0a15cc87">create\_catalog\_datasource\_credentials</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a0f2f4db7367dd6bb39e8b5deecd0efba">create\_catalog\_skip\_validation</a>: Bypass validation of connection to remote source. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a2a3375faf37eec7ee2b916662f4caf7f">create\_catalog\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a6ebac5b67471f8cab689f87cee97947f">create\_catalog\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a6ebac5b67471f8cab689f87cee97947f">create\_catalog\_false</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CreateCatalogResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CreateCatalogResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a3e28b2e1d6ee457d0d127139c6369c7c">◆ </a></span>createCredential() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CreateCredentialResponse">CreateCredentialResponse</a> gpudb::GPUdb::createCredential </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1CreateCredentialRequest">CreateCredentialRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Create a new <a href="/content/concepts/credentials/">credential</a>. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CreateCredentialRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CreateCredentialResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a528e40827a0c5c22e9d19379102639a8">◆ </a></span>createCredential() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CreateCredentialResponse">CreateCredentialResponse</a> & gpudb::GPUdb::createCredential </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1CreateCredentialRequest">CreateCredentialRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1CreateCredentialResponse">CreateCredentialResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Create a new <a href="/content/concepts/credentials/">credential</a>. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CreateCredentialRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CreateCredentialResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CreateCredentialResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#af8b6fbc3da2a392838bb700762188a53">◆ </a></span>createCredential() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CreateCredentialResponse">CreateCredentialResponse</a> gpudb::GPUdb::createCredential </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>credentialName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>type</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>identity</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>secret</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Create a new <a href="/content/concepts/credentials/">credential</a>. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>credentialName</td>
                <td>Name of the credential to be created. Must contain only letters, digits, and underscores, and cannot begin with a digit. Must not match an existing credential name. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>type</td>

                <td>
                  <a href="/content/api/cpp/classgpudb_1_1Type">Type</a> of the credential to be created. Supported values:

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a8e7467d80fbec5d546960c2b65575414">create\_credential\_aws\_access\_key</a> </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ad1e554a090f28d4f4ad665b5fcbc4404">create\_credential\_aws\_iam\_role</a> </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a702aa3c8fb2d908278bacff3742b2c90">create\_credential\_azure\_ad</a> </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a718bf7c3ceeac71003b64b77907b9bc7">create\_credential\_azure\_oauth</a> </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a4d8d3adc8b19322f7cd72b2332bbba74">create\_credential\_azure\_sas</a> </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a1d687a3901fd183588b3907292edcd82">create\_credential\_azure\_storage\_key</a> </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a00019a2b9a7b6e5fdf8ec66e35979086">create\_credential\_confluent</a> </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ad9aee8ca52a31a3ba3bf38f21f1d3567">create\_credential\_docker</a> </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a415742c998ae94c05d67ffddc5668ddd">create\_credential\_gcs\_service\_account\_id</a> </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a3cfff09c6c8fe5c06abf2bd0d5504e69">create\_credential\_gcs\_service\_account\_keys</a> </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ac4e26cd45a7dfedd81f631e673960f1e">create\_credential\_hdfs</a> </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a07beb78d00453d13682cb398adb3e96c">create\_credential\_jdbc</a> </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a258690e6a1b9ab75e054059a9c28b960">create\_credential\_kafka</a> </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a0f69844381e5338d8200fb922324c7ab">create\_credential\_nvidia\_api\_key</a> </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#abc3879126d6e44f9b04abd2b2726420f">create\_credential\_openai\_api\_key</a> </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a3f1e9b285d037c2b2c48952e59e58576">create\_credential\_rest</a> </li>
                  </ul>
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>identity</td>
                <td>User of the credential to be created. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>secret</td>
                <td>Password of the credential to be created. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CreateCredentialResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a6f2cc71c1467245ca17951507a23e956">◆ </a></span>createCredential() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CreateCredentialResponse">CreateCredentialResponse</a> & gpudb::GPUdb::createCredential </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>credentialName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>type</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>identity</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>secret</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1CreateCredentialResponse">CreateCredentialResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Create a new <a href="/content/concepts/credentials/">credential</a>. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>credentialName</td>
                <td>Name of the credential to be created. Must contain only letters, digits, and underscores, and cannot begin with a digit. Must not match an existing credential name. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>type</td>

                <td>
                  <a href="/content/api/cpp/classgpudb_1_1Type">Type</a> of the credential to be created. Supported values:

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a8e7467d80fbec5d546960c2b65575414">create\_credential\_aws\_access\_key</a> </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ad1e554a090f28d4f4ad665b5fcbc4404">create\_credential\_aws\_iam\_role</a> </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a702aa3c8fb2d908278bacff3742b2c90">create\_credential\_azure\_ad</a> </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a718bf7c3ceeac71003b64b77907b9bc7">create\_credential\_azure\_oauth</a> </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a4d8d3adc8b19322f7cd72b2332bbba74">create\_credential\_azure\_sas</a> </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a1d687a3901fd183588b3907292edcd82">create\_credential\_azure\_storage\_key</a> </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a00019a2b9a7b6e5fdf8ec66e35979086">create\_credential\_confluent</a> </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ad9aee8ca52a31a3ba3bf38f21f1d3567">create\_credential\_docker</a> </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a415742c998ae94c05d67ffddc5668ddd">create\_credential\_gcs\_service\_account\_id</a> </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a3cfff09c6c8fe5c06abf2bd0d5504e69">create\_credential\_gcs\_service\_account\_keys</a> </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ac4e26cd45a7dfedd81f631e673960f1e">create\_credential\_hdfs</a> </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a07beb78d00453d13682cb398adb3e96c">create\_credential\_jdbc</a> </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a258690e6a1b9ab75e054059a9c28b960">create\_credential\_kafka</a> </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a0f69844381e5338d8200fb922324c7ab">create\_credential\_nvidia\_api\_key</a> </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#abc3879126d6e44f9b04abd2b2726420f">create\_credential\_openai\_api\_key</a> </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a3f1e9b285d037c2b2c48952e59e58576">create\_credential\_rest</a> </li>
                  </ul>
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>identity</td>
                <td>User of the credential to be created. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>secret</td>
                <td>Password of the credential to be created. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CreateCredentialResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CreateCredentialResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ad32bfcf63c4db33db0de668a02c2ff8e">◆ </a></span>createDatasink() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CreateDatasinkResponse">CreateDatasinkResponse</a> gpudb::GPUdb::createDatasink </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1CreateDatasinkRequest">CreateDatasinkRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Creates a <a href="/content/concepts/data_sinks/">data sink</a>, which contains the destination information for a data sink that is external to the database. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CreateDatasinkRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CreateDatasinkResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a1e3dded69d198f6e26d88cfd2c9a062e">◆ </a></span>createDatasink() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CreateDatasinkResponse">CreateDatasinkResponse</a> & gpudb::GPUdb::createDatasink </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1CreateDatasinkRequest">CreateDatasinkRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1CreateDatasinkResponse">CreateDatasinkResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Creates a <a href="/content/concepts/data_sinks/">data sink</a>, which contains the destination information for a data sink that is external to the database. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CreateDatasinkRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CreateDatasinkResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CreateDatasinkResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a84ef0210170f53a95829d990695287f0">◆ </a></span>createDatasink() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CreateDatasinkResponse">CreateDatasinkResponse</a> gpudb::GPUdb::createDatasink </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>destination</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Creates a <a href="/content/concepts/data_sinks/">data sink</a>, which contains the destination information for a data sink that is external to the database. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>name</td>
                <td>Name of the data sink to be created. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>destination</td>
                <td>Destination for the output data in format 'storage\_provider\_type://path\[:port]'. Supported storage provider types are 'azure', 'gcs', 'hdfs', 'http', 'https', 'jdbc', 'kafka', and 's3'. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a65e544d5ec6632c11aac1accf944815d">create\_datasink\_connection\_timeout</a>: Timeout in seconds for connecting to this data sink. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a5a4dfced423de1dbc3ecf151db403b48">create\_datasink\_wait\_timeout</a>: Timeout in seconds for waiting for a response from this data sink. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a3fff02aab3be6d4489e1bbe07a4f833e">create\_datasink\_credential</a>: Name of the <a href="/content/concepts/credentials/">credential</a> object to be used in this data sink. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a729d34f9fbdf2298dcf9d50f06d29f25">create\_datasink\_s3\_bucket\_name</a>: Name of the Amazon S3 bucket to use as the data sink. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a6ddafdbf5bf2aeab4a3ff13de234cefb">create\_datasink\_s3\_region</a>: Name of the Amazon S3 region where the given bucket is located. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ae93d6f3ee61417d67136a8e0f425defb">create\_datasink\_s3\_verify\_ssl</a>: Whether to verify SSL connections. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ac55d9a3eea355b2384e2aabe43b42350">create\_datasink\_true</a>: Connect with SSL verification. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a2043fa049ce6f056b3fe4b9195d76f3d">create\_datasink\_false</a>: Connect without verifying the SSL connection; for testing purposes, bypassing TLS errors, self-signed certificates, etc. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ac55d9a3eea355b2384e2aabe43b42350">create\_datasink\_true</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#af4cf96005f6a511337a02f6ac3340180">create\_datasink\_s3\_use\_virtual\_addressing</a>: Whether to use virtual addressing when referencing the Amazon S3 sink. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ac55d9a3eea355b2384e2aabe43b42350">create\_datasink\_true</a>: The requests URI should be specified in virtual-hosted-style format where the bucket name is part of the domain name in the URL. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a2043fa049ce6f056b3fe4b9195d76f3d">create\_datasink\_false</a>: Use path-style URI for requests. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ac55d9a3eea355b2384e2aabe43b42350">create\_datasink\_true</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a308c5cd31dced3225feff5410fd5f8c8">create\_datasink\_s3\_aws\_role\_arn</a>: Amazon IAM Role ARN which has required S3 permissions that can be assumed for the given S3 IAM user. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a63664fc32163654b0f36ee3a4172c61b">create\_datasink\_s3\_encryption\_customer\_algorithm</a>: Customer encryption algorithm used encrypting data. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a80d7d04803500661672fa8c4fbb85c43">create\_datasink\_s3\_encryption\_customer\_key</a>: Customer encryption key to encrypt or decrypt data. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a61277dbf3064ebe118caa0348cb89dcc">create\_datasink\_s3\_encryption\_type</a>: Server side encryption type. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ad62f6ea4d3d774253619422e3a6df716">create\_datasink\_s3\_kms\_key\_id</a>: KMS key. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a4a75da1b47e04af9f71cd1d4f1324254">create\_datasink\_hdfs\_kerberos\_keytab</a>: Kerberos keytab file location for the given HDFS user. This may be a KIFS file. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ae009e7f4b79314abbda29ec5ef4d96d9">create\_datasink\_hdfs\_delegation\_token</a>: Delegation token for the given HDFS user. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a88be57198309d6595588d6898c65386b">create\_datasink\_hdfs\_use\_kerberos</a>: Use kerberos authentication for the given HDFS cluster. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ac55d9a3eea355b2384e2aabe43b42350">create\_datasink\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a2043fa049ce6f056b3fe4b9195d76f3d">create\_datasink\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a2043fa049ce6f056b3fe4b9195d76f3d">create\_datasink\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a051e187149dc905659a73fbd338531be">create\_datasink\_azure\_storage\_account\_name</a>: Name of the Azure storage account to use as the data sink, this is valid only if tenant\_id is specified. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#afdf966bf1550a46fe953ad9bd8a221ef">create\_datasink\_azure\_container\_name</a>: Name of the Azure storage container to use as the data sink. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a0b9b0cf44aac56705dcb212221a8427c">create\_datasink\_azure\_tenant\_id</a>: Active Directory tenant ID (or directory ID). </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a2f2b7a9000f8aba499ff2ece186d0174">create\_datasink\_azure\_sas\_token</a>: Shared access signature token for Azure storage account to use as the data sink. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#afc1eb5b326290fc93cbcdc6159f1f620">create\_datasink\_azure\_oauth\_token</a>: Oauth token to access given storage container. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a37a5ef2954d265aceb52a71558b302a1">create\_datasink\_azure\_use\_virtual\_addressing</a>: Whether to use virtual addressing when referencing the Azure source. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ac55d9a3eea355b2384e2aabe43b42350">create\_datasink\_true</a>: The requests URI should be specified in virtual-hosted-style format where the bucket name is part of the domain name in the URL. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a2043fa049ce6f056b3fe4b9195d76f3d">create\_datasink\_false</a>: Use path-style URI for requests. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ac55d9a3eea355b2384e2aabe43b42350">create\_datasink\_true</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#ab60555d6c13547ebbe87f4733d224514">create\_datasink\_gcs\_bucket\_name</a>: Name of the Google Cloud Storage bucket to use as the data sink. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a4777824afa880a72ad356d2f3177b2b5">create\_datasink\_gcs\_project\_id</a>: Name of the Google Cloud project to use as the data sink. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a44a4fc4146fc807ff9fcff3a12485f00">create\_datasink\_gcs\_service\_account\_keys</a>: Google Cloud service account keys to use for authenticating the data sink. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#add0f62778c05277e96ed5b4d12ec361a">create\_datasink\_jdbc\_driver\_jar\_path</a>: JDBC driver jar file location. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a8b7be5447fb63ccd75b83314d2b857bd">create\_datasink\_jdbc\_driver\_class\_name</a>: Name of the JDBC driver class. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a4bb285a06b6307249b1c29c5b91a4ef0">create\_datasink\_kafka\_topic\_name</a>: Name of the Kafka topic to publish to if <span>destination</span> is a Kafka broker. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ab8997e8691729cea4fb9fa3268fe33df">create\_datasink\_max\_batch\_size</a>: Maximum number of records per notification message. The default value is '1'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ab65ff43bdab0befbf8c55e0e88a869d9">create\_datasink\_max\_message\_size</a>: Maximum size in bytes of each notification message. The default value is '1000000'. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a9253cd617adacde8307d5d8e358057c0">create\_datasink\_json\_format</a>: The desired format of JSON encoded notifications message. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#aeeeea79dfa6bbb68c1ea4b52fbe76967">create\_datasink\_flat</a>: A single record is returned per message. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aee536e31ab04ca90729910709d0853d4">create\_datasink\_nested</a>: Records are returned as an array per message. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#aeeeea79dfa6bbb68c1ea4b52fbe76967">create\_datasink\_flat</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a5f418f8d80621680eb70bc868862701e">create\_datasink\_use\_managed\_credentials</a>: When no credentials are supplied, we use anonymous access by default. If this is set, we will use cloud provider user settings. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ac55d9a3eea355b2384e2aabe43b42350">create\_datasink\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a2043fa049ce6f056b3fe4b9195d76f3d">create\_datasink\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a2043fa049ce6f056b3fe4b9195d76f3d">create\_datasink\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a2f0caa3608807b319ef4df461ee96450">create\_datasink\_use\_https</a>: Use HTTPS to connect to datasink if true, otherwise use HTTP. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ac55d9a3eea355b2384e2aabe43b42350">create\_datasink\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a2043fa049ce6f056b3fe4b9195d76f3d">create\_datasink\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ac55d9a3eea355b2384e2aabe43b42350">create\_datasink\_true</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a4f267076e11bccc4a82e8440294c87f0">create\_datasink\_skip\_validation</a>: Bypass validation of connection to this data sink. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ac55d9a3eea355b2384e2aabe43b42350">create\_datasink\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a2043fa049ce6f056b3fe4b9195d76f3d">create\_datasink\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a2043fa049ce6f056b3fe4b9195d76f3d">create\_datasink\_false</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CreateDatasinkResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ad472ec2d6d8b64d862531a17cc32e2b8">◆ </a></span>createDatasink() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CreateDatasinkResponse">CreateDatasinkResponse</a> & gpudb::GPUdb::createDatasink </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>destination</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1CreateDatasinkResponse">CreateDatasinkResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Creates a <a href="/content/concepts/data_sinks/">data sink</a>, which contains the destination information for a data sink that is external to the database. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>name</td>
                <td>Name of the data sink to be created. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>destination</td>
                <td>Destination for the output data in format 'storage\_provider\_type://path\[:port]'. Supported storage provider types are 'azure', 'gcs', 'hdfs', 'http', 'https', 'jdbc', 'kafka', and 's3'. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a65e544d5ec6632c11aac1accf944815d">create\_datasink\_connection\_timeout</a>: Timeout in seconds for connecting to this data sink. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a5a4dfced423de1dbc3ecf151db403b48">create\_datasink\_wait\_timeout</a>: Timeout in seconds for waiting for a response from this data sink. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a3fff02aab3be6d4489e1bbe07a4f833e">create\_datasink\_credential</a>: Name of the <a href="/content/concepts/credentials/">credential</a> object to be used in this data sink. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a729d34f9fbdf2298dcf9d50f06d29f25">create\_datasink\_s3\_bucket\_name</a>: Name of the Amazon S3 bucket to use as the data sink. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a6ddafdbf5bf2aeab4a3ff13de234cefb">create\_datasink\_s3\_region</a>: Name of the Amazon S3 region where the given bucket is located. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ae93d6f3ee61417d67136a8e0f425defb">create\_datasink\_s3\_verify\_ssl</a>: Whether to verify SSL connections. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ac55d9a3eea355b2384e2aabe43b42350">create\_datasink\_true</a>: Connect with SSL verification. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a2043fa049ce6f056b3fe4b9195d76f3d">create\_datasink\_false</a>: Connect without verifying the SSL connection; for testing purposes, bypassing TLS errors, self-signed certificates, etc. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ac55d9a3eea355b2384e2aabe43b42350">create\_datasink\_true</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#af4cf96005f6a511337a02f6ac3340180">create\_datasink\_s3\_use\_virtual\_addressing</a>: Whether to use virtual addressing when referencing the Amazon S3 sink. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ac55d9a3eea355b2384e2aabe43b42350">create\_datasink\_true</a>: The requests URI should be specified in virtual-hosted-style format where the bucket name is part of the domain name in the URL. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a2043fa049ce6f056b3fe4b9195d76f3d">create\_datasink\_false</a>: Use path-style URI for requests. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ac55d9a3eea355b2384e2aabe43b42350">create\_datasink\_true</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a308c5cd31dced3225feff5410fd5f8c8">create\_datasink\_s3\_aws\_role\_arn</a>: Amazon IAM Role ARN which has required S3 permissions that can be assumed for the given S3 IAM user. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a63664fc32163654b0f36ee3a4172c61b">create\_datasink\_s3\_encryption\_customer\_algorithm</a>: Customer encryption algorithm used encrypting data. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a80d7d04803500661672fa8c4fbb85c43">create\_datasink\_s3\_encryption\_customer\_key</a>: Customer encryption key to encrypt or decrypt data. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a61277dbf3064ebe118caa0348cb89dcc">create\_datasink\_s3\_encryption\_type</a>: Server side encryption type. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ad62f6ea4d3d774253619422e3a6df716">create\_datasink\_s3\_kms\_key\_id</a>: KMS key. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a4a75da1b47e04af9f71cd1d4f1324254">create\_datasink\_hdfs\_kerberos\_keytab</a>: Kerberos keytab file location for the given HDFS user. This may be a KIFS file. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ae009e7f4b79314abbda29ec5ef4d96d9">create\_datasink\_hdfs\_delegation\_token</a>: Delegation token for the given HDFS user. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a88be57198309d6595588d6898c65386b">create\_datasink\_hdfs\_use\_kerberos</a>: Use kerberos authentication for the given HDFS cluster. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ac55d9a3eea355b2384e2aabe43b42350">create\_datasink\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a2043fa049ce6f056b3fe4b9195d76f3d">create\_datasink\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a2043fa049ce6f056b3fe4b9195d76f3d">create\_datasink\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a051e187149dc905659a73fbd338531be">create\_datasink\_azure\_storage\_account\_name</a>: Name of the Azure storage account to use as the data sink, this is valid only if tenant\_id is specified. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#afdf966bf1550a46fe953ad9bd8a221ef">create\_datasink\_azure\_container\_name</a>: Name of the Azure storage container to use as the data sink. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a0b9b0cf44aac56705dcb212221a8427c">create\_datasink\_azure\_tenant\_id</a>: Active Directory tenant ID (or directory ID). </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a2f2b7a9000f8aba499ff2ece186d0174">create\_datasink\_azure\_sas\_token</a>: Shared access signature token for Azure storage account to use as the data sink. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#afc1eb5b326290fc93cbcdc6159f1f620">create\_datasink\_azure\_oauth\_token</a>: Oauth token to access given storage container. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a37a5ef2954d265aceb52a71558b302a1">create\_datasink\_azure\_use\_virtual\_addressing</a>: Whether to use virtual addressing when referencing the Azure source. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ac55d9a3eea355b2384e2aabe43b42350">create\_datasink\_true</a>: The requests URI should be specified in virtual-hosted-style format where the bucket name is part of the domain name in the URL. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a2043fa049ce6f056b3fe4b9195d76f3d">create\_datasink\_false</a>: Use path-style URI for requests. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ac55d9a3eea355b2384e2aabe43b42350">create\_datasink\_true</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#ab60555d6c13547ebbe87f4733d224514">create\_datasink\_gcs\_bucket\_name</a>: Name of the Google Cloud Storage bucket to use as the data sink. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a4777824afa880a72ad356d2f3177b2b5">create\_datasink\_gcs\_project\_id</a>: Name of the Google Cloud project to use as the data sink. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a44a4fc4146fc807ff9fcff3a12485f00">create\_datasink\_gcs\_service\_account\_keys</a>: Google Cloud service account keys to use for authenticating the data sink. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#add0f62778c05277e96ed5b4d12ec361a">create\_datasink\_jdbc\_driver\_jar\_path</a>: JDBC driver jar file location. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a8b7be5447fb63ccd75b83314d2b857bd">create\_datasink\_jdbc\_driver\_class\_name</a>: Name of the JDBC driver class. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a4bb285a06b6307249b1c29c5b91a4ef0">create\_datasink\_kafka\_topic\_name</a>: Name of the Kafka topic to publish to if <span>destination</span> is a Kafka broker. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ab8997e8691729cea4fb9fa3268fe33df">create\_datasink\_max\_batch\_size</a>: Maximum number of records per notification message. The default value is '1'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ab65ff43bdab0befbf8c55e0e88a869d9">create\_datasink\_max\_message\_size</a>: Maximum size in bytes of each notification message. The default value is '1000000'. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a9253cd617adacde8307d5d8e358057c0">create\_datasink\_json\_format</a>: The desired format of JSON encoded notifications message. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#aeeeea79dfa6bbb68c1ea4b52fbe76967">create\_datasink\_flat</a>: A single record is returned per message. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aee536e31ab04ca90729910709d0853d4">create\_datasink\_nested</a>: Records are returned as an array per message. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#aeeeea79dfa6bbb68c1ea4b52fbe76967">create\_datasink\_flat</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a5f418f8d80621680eb70bc868862701e">create\_datasink\_use\_managed\_credentials</a>: When no credentials are supplied, we use anonymous access by default. If this is set, we will use cloud provider user settings. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ac55d9a3eea355b2384e2aabe43b42350">create\_datasink\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a2043fa049ce6f056b3fe4b9195d76f3d">create\_datasink\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a2043fa049ce6f056b3fe4b9195d76f3d">create\_datasink\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a2f0caa3608807b319ef4df461ee96450">create\_datasink\_use\_https</a>: Use HTTPS to connect to datasink if true, otherwise use HTTP. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ac55d9a3eea355b2384e2aabe43b42350">create\_datasink\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a2043fa049ce6f056b3fe4b9195d76f3d">create\_datasink\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ac55d9a3eea355b2384e2aabe43b42350">create\_datasink\_true</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a4f267076e11bccc4a82e8440294c87f0">create\_datasink\_skip\_validation</a>: Bypass validation of connection to this data sink. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ac55d9a3eea355b2384e2aabe43b42350">create\_datasink\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a2043fa049ce6f056b3fe4b9195d76f3d">create\_datasink\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a2043fa049ce6f056b3fe4b9195d76f3d">create\_datasink\_false</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CreateDatasinkResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CreateDatasinkResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#aee7f93ffe53262e30f66a08cf99847e5">◆ </a></span>createDatasource() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CreateDatasourceResponse">CreateDatasourceResponse</a> gpudb::GPUdb::createDatasource </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1CreateDatasourceRequest">CreateDatasourceRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Creates a <a href="/content/concepts/data_sources/">data source</a>, which contains the location and connection information for a data store that is external to the database. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CreateDatasourceRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CreateDatasourceResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a7bf5abea868db0f44e0ab9d6298da7aa">◆ </a></span>createDatasource() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CreateDatasourceResponse">CreateDatasourceResponse</a> & gpudb::GPUdb::createDatasource </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1CreateDatasourceRequest">CreateDatasourceRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1CreateDatasourceResponse">CreateDatasourceResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Creates a <a href="/content/concepts/data_sources/">data source</a>, which contains the location and connection information for a data store that is external to the database. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CreateDatasourceRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CreateDatasourceResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CreateDatasourceResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#abd907f6e877fc1e5bab4c9a913e54261">◆ </a></span>createDatasource() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CreateDatasourceResponse">CreateDatasourceResponse</a> gpudb::GPUdb::createDatasource </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>location</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>userName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>password</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Creates a <a href="/content/concepts/data_sources/">data source</a>, which contains the location and connection information for a data store that is external to the database. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>name</td>
                <td>Name of the data source to be created. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>location</td>
                <td>Location of the remote storage in 'storage\_provider\_type://\[storage\_path\[:storage\_port]]' format. Supported storage provider types are 'azure', 'gcs', 'hdfs', 'jdbc', 'kafka', 'confluent', and 's3'. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>userName</td>
                <td>Name of the remote system user; may be an empty string. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>password</td>
                <td>Password for the remote system user; may be an empty string. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a5991b0fece39effa8b141ed3a821628f">create\_datasource\_skip\_validation</a>: Bypass validation of connection to remote source. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a8c356b0263bfd052812ac7ca811e7270">create\_datasource\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a32775115614181dac5d0312c649b22f8">create\_datasource\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a32775115614181dac5d0312c649b22f8">create\_datasource\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#aadfcd734567c64e73633088645f50621">create\_datasource\_connection\_timeout</a>: Timeout in seconds for connecting to this storage provider. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ab852fedea0ece7c198df90fcfea46b66">create\_datasource\_wait\_timeout</a>: Timeout in seconds for reading from this storage provider. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a9ea410c698a08a705156b4cd47cb76d9">create\_datasource\_credential</a>: Name of the <a href="/content/concepts/credentials">credential</a> object to be used in data source. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a1a5d015a7f877b82adf782b02f8d7fee">create\_datasource\_s3\_bucket\_name</a>: Name of the Amazon S3 bucket to use as the data source. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#af0cde712894694fbd6a12b3799a51c28">create\_datasource\_s3\_region</a>: Name of the Amazon S3 region where the given bucket is located. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a94df071390de176cfef884ba960a8482">create\_datasource\_s3\_verify\_ssl</a>: Whether to verify SSL connections. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a8c356b0263bfd052812ac7ca811e7270">create\_datasource\_true</a>: Connect with SSL verification. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a32775115614181dac5d0312c649b22f8">create\_datasource\_false</a>: Connect without verifying the SSL connection; for testing purposes, bypassing TLS errors, self-signed certificates, etc. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a8c356b0263bfd052812ac7ca811e7270">create\_datasource\_true</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ac1bbbea1d9c3147898c64a8ecde08b4f">create\_datasource\_s3\_use\_virtual\_addressing</a>: Whether to use virtual addressing when referencing the Amazon S3 source. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a8c356b0263bfd052812ac7ca811e7270">create\_datasource\_true</a>: The requests URI should be specified in virtual-hosted-style format where the bucket name is part of the domain name in the URL. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a32775115614181dac5d0312c649b22f8">create\_datasource\_false</a>: Use path-style URI for requests. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a8c356b0263bfd052812ac7ca811e7270">create\_datasource\_true</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#aa2379b58609720d71db6d6964606b28d">create\_datasource\_s3\_aws\_role\_arn</a>: Amazon IAM Role ARN which has required S3 permissions that can be assumed for the given S3 IAM user. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ac8030ceb95177a49c58b37ace69e7a82">create\_datasource\_s3\_encryption\_customer\_algorithm</a>: Customer encryption algorithm used encrypting data. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a74460b4336ab62b616f3a01631cfaee5">create\_datasource\_s3\_encryption\_customer\_key</a>: Customer encryption key to encrypt or decrypt data. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a26033cc9892c82509f3cf485080a3bcc">create\_datasource\_hdfs\_kerberos\_keytab</a>: Kerberos keytab file location for the given HDFS user. This may be a KIFS file. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a14fed5e858e21050390e0d129fa1bad2">create\_datasource\_hdfs\_delegation\_token</a>: Delegation token for the given HDFS user. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a62a4ae0bcebc960fcd016c89a0ca63aa">create\_datasource\_hdfs\_use\_kerberos</a>: Use kerberos authentication for the given HDFS cluster. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a8c356b0263bfd052812ac7ca811e7270">create\_datasource\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a32775115614181dac5d0312c649b22f8">create\_datasource\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a32775115614181dac5d0312c649b22f8">create\_datasource\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a85abdcfe7f765ec8cdd695a2d966a577">create\_datasource\_azure\_storage\_account\_name</a>: Name of the Azure storage account to use as the data source, this is valid only if tenant\_id is specified. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a70e6a2bc5b1cfbf422caf2591374c309">create\_datasource\_azure\_container\_name</a>: Name of the Azure storage container to use as the data source. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a975630a875456275bed3c3a0fd9d13bb">create\_datasource\_azure\_tenant\_id</a>: Active Directory tenant ID (or directory ID). </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a7de08e1cb32b4de4babedaeea2bff726">create\_datasource\_azure\_sas\_token</a>: Shared access signature token for Azure storage account to use as the data source. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aacedcb0ba462cabf37274fd7fd582c74">create\_datasource\_azure\_oauth\_token</a>: OAuth token to access given storage container. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a966d303b4e318704a70721083cba8ba1">create\_datasource\_azure\_use\_virtual\_addressing</a>: Whether to use virtual addressing when referencing the Azure source. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a8c356b0263bfd052812ac7ca811e7270">create\_datasource\_true</a>: The requests URI should be specified in virtual-hosted-style format where the bucket name is part of the domain name in the URL. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a32775115614181dac5d0312c649b22f8">create\_datasource\_false</a>: Use path-style URI for requests. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a8c356b0263bfd052812ac7ca811e7270">create\_datasource\_true</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#af6211e8680d4647d78a030d66a5dabca">create\_datasource\_gcs\_bucket\_name</a>: Name of the Google Cloud Storage bucket to use as the data source. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a0cd7527cec67822c43ccfbdb8a700580">create\_datasource\_gcs\_project\_id</a>: Name of the Google Cloud project to use as the data source. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aacf478c08c08174b8d0a172e79db8f3f">create\_datasource\_gcs\_service\_account\_keys</a>: Google Cloud service account keys to use for authenticating the data source. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#abd44e08ce5741bb3bd25b4e6f8175d0c">create\_datasource\_is\_stream</a>: To load from Azure/GCS/S3 as a stream continuously. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a8c356b0263bfd052812ac7ca811e7270">create\_datasource\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a32775115614181dac5d0312c649b22f8">create\_datasource\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a32775115614181dac5d0312c649b22f8">create\_datasource\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a0a4fc81f1da618be2e39fedb229b4309">create\_datasource\_kafka\_topic\_name</a>: Name of the Kafka topic to use as the data source. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aa426a60be465769d477fcab28e929a44">create\_datasource\_jdbc\_driver\_jar\_path</a>: JDBC driver jar file location. This may be a KIFS file. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aa03e82751b2c556e6a0f56443b8e1c2f">create\_datasource\_jdbc\_driver\_class\_name</a>: Name of the JDBC driver class. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a74a7c81c89b1f4dc971d0435853098ad">create\_datasource\_anonymous</a>: Use anonymous connection to storage provider–DEPRECATED: this is now the default. Specify use\_managed\_credentials for non-anonymous connection. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a8c356b0263bfd052812ac7ca811e7270">create\_datasource\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a32775115614181dac5d0312c649b22f8">create\_datasource\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a8c356b0263bfd052812ac7ca811e7270">create\_datasource\_true</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a10b29be54353b475cba809aef2f641fb">create\_datasource\_use\_managed\_credentials</a>: When no credentials are supplied, we use anonymous access by default. If this is set, we will use cloud provider user settings. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a8c356b0263bfd052812ac7ca811e7270">create\_datasource\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a32775115614181dac5d0312c649b22f8">create\_datasource\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a32775115614181dac5d0312c649b22f8">create\_datasource\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#adf55cc0301f39c595d80b1f218b60da3">create\_datasource\_use\_https</a>: Use HTTPS to connect to datasource if true, otherwise use HTTP. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a8c356b0263bfd052812ac7ca811e7270">create\_datasource\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a32775115614181dac5d0312c649b22f8">create\_datasource\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a8c356b0263bfd052812ac7ca811e7270">create\_datasource\_true</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a306376988b6d97b63ebf31e3ed169a50">create\_datasource\_schema\_registry\_location</a>: Location of Confluent Schema Registry in '\[storage\_path\[:storage\_port]]' format. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a79b74df8c283e93076bcebefc7b0479d">create\_datasource\_schema\_registry\_credential</a>: Confluent Schema Registry <a href="/content/concepts/credentials">credential</a> object name. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a1750c097dca129b111bc8b028d8aad33">create\_datasource\_schema\_registry\_port</a>: Confluent Schema Registry port (optional). </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a72b7b434fe10dec6e96c52c72c63c12f">create\_datasource\_schema\_registry\_connection\_retries</a>: Confluent Schema registry connection timeout (in secs). </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a05155247cfecd122cef6c4430f47a091">create\_datasource\_schema\_registry\_connection\_timeout</a>: Confluent Schema registry connection timeout (in secs). </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CreateDatasourceResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a2be406bc91fb042fccb89e77fd4f1c29">◆ </a></span>createDatasource() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CreateDatasourceResponse">CreateDatasourceResponse</a> & gpudb::GPUdb::createDatasource </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>location</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>userName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>password</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1CreateDatasourceResponse">CreateDatasourceResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Creates a <a href="/content/concepts/data_sources/">data source</a>, which contains the location and connection information for a data store that is external to the database. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>name</td>
                <td>Name of the data source to be created. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>location</td>
                <td>Location of the remote storage in 'storage\_provider\_type://\[storage\_path\[:storage\_port]]' format. Supported storage provider types are 'azure', 'gcs', 'hdfs', 'jdbc', 'kafka', 'confluent', and 's3'. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>userName</td>
                <td>Name of the remote system user; may be an empty string. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>password</td>
                <td>Password for the remote system user; may be an empty string. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a5991b0fece39effa8b141ed3a821628f">create\_datasource\_skip\_validation</a>: Bypass validation of connection to remote source. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a8c356b0263bfd052812ac7ca811e7270">create\_datasource\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a32775115614181dac5d0312c649b22f8">create\_datasource\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a32775115614181dac5d0312c649b22f8">create\_datasource\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#aadfcd734567c64e73633088645f50621">create\_datasource\_connection\_timeout</a>: Timeout in seconds for connecting to this storage provider. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ab852fedea0ece7c198df90fcfea46b66">create\_datasource\_wait\_timeout</a>: Timeout in seconds for reading from this storage provider. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a9ea410c698a08a705156b4cd47cb76d9">create\_datasource\_credential</a>: Name of the <a href="/content/concepts/credentials">credential</a> object to be used in data source. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a1a5d015a7f877b82adf782b02f8d7fee">create\_datasource\_s3\_bucket\_name</a>: Name of the Amazon S3 bucket to use as the data source. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#af0cde712894694fbd6a12b3799a51c28">create\_datasource\_s3\_region</a>: Name of the Amazon S3 region where the given bucket is located. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a94df071390de176cfef884ba960a8482">create\_datasource\_s3\_verify\_ssl</a>: Whether to verify SSL connections. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a8c356b0263bfd052812ac7ca811e7270">create\_datasource\_true</a>: Connect with SSL verification. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a32775115614181dac5d0312c649b22f8">create\_datasource\_false</a>: Connect without verifying the SSL connection; for testing purposes, bypassing TLS errors, self-signed certificates, etc. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a8c356b0263bfd052812ac7ca811e7270">create\_datasource\_true</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ac1bbbea1d9c3147898c64a8ecde08b4f">create\_datasource\_s3\_use\_virtual\_addressing</a>: Whether to use virtual addressing when referencing the Amazon S3 source. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a8c356b0263bfd052812ac7ca811e7270">create\_datasource\_true</a>: The requests URI should be specified in virtual-hosted-style format where the bucket name is part of the domain name in the URL. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a32775115614181dac5d0312c649b22f8">create\_datasource\_false</a>: Use path-style URI for requests. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a8c356b0263bfd052812ac7ca811e7270">create\_datasource\_true</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#aa2379b58609720d71db6d6964606b28d">create\_datasource\_s3\_aws\_role\_arn</a>: Amazon IAM Role ARN which has required S3 permissions that can be assumed for the given S3 IAM user. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ac8030ceb95177a49c58b37ace69e7a82">create\_datasource\_s3\_encryption\_customer\_algorithm</a>: Customer encryption algorithm used encrypting data. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a74460b4336ab62b616f3a01631cfaee5">create\_datasource\_s3\_encryption\_customer\_key</a>: Customer encryption key to encrypt or decrypt data. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a26033cc9892c82509f3cf485080a3bcc">create\_datasource\_hdfs\_kerberos\_keytab</a>: Kerberos keytab file location for the given HDFS user. This may be a KIFS file. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a14fed5e858e21050390e0d129fa1bad2">create\_datasource\_hdfs\_delegation\_token</a>: Delegation token for the given HDFS user. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a62a4ae0bcebc960fcd016c89a0ca63aa">create\_datasource\_hdfs\_use\_kerberos</a>: Use kerberos authentication for the given HDFS cluster. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a8c356b0263bfd052812ac7ca811e7270">create\_datasource\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a32775115614181dac5d0312c649b22f8">create\_datasource\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a32775115614181dac5d0312c649b22f8">create\_datasource\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a85abdcfe7f765ec8cdd695a2d966a577">create\_datasource\_azure\_storage\_account\_name</a>: Name of the Azure storage account to use as the data source, this is valid only if tenant\_id is specified. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a70e6a2bc5b1cfbf422caf2591374c309">create\_datasource\_azure\_container\_name</a>: Name of the Azure storage container to use as the data source. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a975630a875456275bed3c3a0fd9d13bb">create\_datasource\_azure\_tenant\_id</a>: Active Directory tenant ID (or directory ID). </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a7de08e1cb32b4de4babedaeea2bff726">create\_datasource\_azure\_sas\_token</a>: Shared access signature token for Azure storage account to use as the data source. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aacedcb0ba462cabf37274fd7fd582c74">create\_datasource\_azure\_oauth\_token</a>: OAuth token to access given storage container. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a966d303b4e318704a70721083cba8ba1">create\_datasource\_azure\_use\_virtual\_addressing</a>: Whether to use virtual addressing when referencing the Azure source. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a8c356b0263bfd052812ac7ca811e7270">create\_datasource\_true</a>: The requests URI should be specified in virtual-hosted-style format where the bucket name is part of the domain name in the URL. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a32775115614181dac5d0312c649b22f8">create\_datasource\_false</a>: Use path-style URI for requests. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a8c356b0263bfd052812ac7ca811e7270">create\_datasource\_true</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#af6211e8680d4647d78a030d66a5dabca">create\_datasource\_gcs\_bucket\_name</a>: Name of the Google Cloud Storage bucket to use as the data source. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a0cd7527cec67822c43ccfbdb8a700580">create\_datasource\_gcs\_project\_id</a>: Name of the Google Cloud project to use as the data source. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aacf478c08c08174b8d0a172e79db8f3f">create\_datasource\_gcs\_service\_account\_keys</a>: Google Cloud service account keys to use for authenticating the data source. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#abd44e08ce5741bb3bd25b4e6f8175d0c">create\_datasource\_is\_stream</a>: To load from Azure/GCS/S3 as a stream continuously. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a8c356b0263bfd052812ac7ca811e7270">create\_datasource\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a32775115614181dac5d0312c649b22f8">create\_datasource\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a32775115614181dac5d0312c649b22f8">create\_datasource\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a0a4fc81f1da618be2e39fedb229b4309">create\_datasource\_kafka\_topic\_name</a>: Name of the Kafka topic to use as the data source. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aa426a60be465769d477fcab28e929a44">create\_datasource\_jdbc\_driver\_jar\_path</a>: JDBC driver jar file location. This may be a KIFS file. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aa03e82751b2c556e6a0f56443b8e1c2f">create\_datasource\_jdbc\_driver\_class\_name</a>: Name of the JDBC driver class. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a74a7c81c89b1f4dc971d0435853098ad">create\_datasource\_anonymous</a>: Use anonymous connection to storage provider–DEPRECATED: this is now the default. Specify use\_managed\_credentials for non-anonymous connection. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a8c356b0263bfd052812ac7ca811e7270">create\_datasource\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a32775115614181dac5d0312c649b22f8">create\_datasource\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a8c356b0263bfd052812ac7ca811e7270">create\_datasource\_true</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a10b29be54353b475cba809aef2f641fb">create\_datasource\_use\_managed\_credentials</a>: When no credentials are supplied, we use anonymous access by default. If this is set, we will use cloud provider user settings. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a8c356b0263bfd052812ac7ca811e7270">create\_datasource\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a32775115614181dac5d0312c649b22f8">create\_datasource\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a32775115614181dac5d0312c649b22f8">create\_datasource\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#adf55cc0301f39c595d80b1f218b60da3">create\_datasource\_use\_https</a>: Use HTTPS to connect to datasource if true, otherwise use HTTP. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a8c356b0263bfd052812ac7ca811e7270">create\_datasource\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a32775115614181dac5d0312c649b22f8">create\_datasource\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a8c356b0263bfd052812ac7ca811e7270">create\_datasource\_true</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a306376988b6d97b63ebf31e3ed169a50">create\_datasource\_schema\_registry\_location</a>: Location of Confluent Schema Registry in '\[storage\_path\[:storage\_port]]' format. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a79b74df8c283e93076bcebefc7b0479d">create\_datasource\_schema\_registry\_credential</a>: Confluent Schema Registry <a href="/content/concepts/credentials">credential</a> object name. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a1750c097dca129b111bc8b028d8aad33">create\_datasource\_schema\_registry\_port</a>: Confluent Schema Registry port (optional). </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a72b7b434fe10dec6e96c52c72c63c12f">create\_datasource\_schema\_registry\_connection\_retries</a>: Confluent Schema registry connection timeout (in secs). </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a05155247cfecd122cef6c4430f47a091">create\_datasource\_schema\_registry\_connection\_timeout</a>: Confluent Schema registry connection timeout (in secs). </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CreateDatasourceResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CreateDatasourceResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ad932eb748735980773e9f45a50aaf818">◆ </a></span>createDirectory() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CreateDirectoryResponse">CreateDirectoryResponse</a> gpudb::GPUdb::createDirectory </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1CreateDirectoryRequest">CreateDirectoryRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Creates a new directory in <a href="/content/tools/kifs/">KiFS</a>. </p>
        <p>The new directory serves as a location in which the user can upload files using <a href="#abf858a844a619c04135d680ce9a2fe4c">uploadFiles</a>.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CreateDirectoryRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CreateDirectoryResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a9ca93f20fbe8707eeb45074103ea0041">◆ </a></span>createDirectory() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CreateDirectoryResponse">CreateDirectoryResponse</a> & gpudb::GPUdb::createDirectory </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1CreateDirectoryRequest">CreateDirectoryRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1CreateDirectoryResponse">CreateDirectoryResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Creates a new directory in <a href="/content/tools/kifs/">KiFS</a>. </p>
        <p>The new directory serves as a location in which the user can upload files using <a href="#abf858a844a619c04135d680ce9a2fe4c">uploadFiles</a>.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CreateDirectoryRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CreateDirectoryResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CreateDirectoryResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a3251f84a1c160b981f62beee27787825">◆ </a></span>createDirectory() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CreateDirectoryResponse">CreateDirectoryResponse</a> gpudb::GPUdb::createDirectory </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>directoryName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Creates a new directory in <a href="/content/tools/kifs/">KiFS</a>. </p>
        <p>The new directory serves as a location in which the user can upload files using <a href="#a536c56e50bedb45ae384af8de3b6483a">uploadFiles</a>.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>directoryName</td>
                <td>Name of the directory in KiFS to be created. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a6eea48ad93a90f8e00c194cfe87250d7">create\_directory\_create\_home\_directory</a>: When set, a home directory is created for the user name provided in the value. The <span>directoryName</span> must be an empty string in this case. The user must exist. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a4b6b939da3d5ca9fae8f0e262abe2497">create\_directory\_data\_limit</a>: The maximum capacity, in bytes, to apply to the created directory. Set to -1 to indicate no upper limit. If empty, the system default limit is applied. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a0c2b822bf59c127ed06112f8e4fe90eb">create\_directory\_no\_error\_if\_exists</a>: If <a href="/content/api/cpp/namespacegpudb#a65fde3c9705cf756aa5f7115e18ca283">true</a>, does not return an error if the directory already exists. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a65fde3c9705cf756aa5f7115e18ca283">create\_directory\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a8087053c4f1d8d6fc90cf27e01b1875f">create\_directory\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a8087053c4f1d8d6fc90cf27e01b1875f">create\_directory\_false</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CreateDirectoryResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a7b984154441271fb6003152b0033f732">◆ </a></span>createDirectory() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CreateDirectoryResponse">CreateDirectoryResponse</a> & gpudb::GPUdb::createDirectory </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>directoryName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1CreateDirectoryResponse">CreateDirectoryResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Creates a new directory in <a href="/content/tools/kifs/">KiFS</a>. </p>
        <p>The new directory serves as a location in which the user can upload files using <a href="#a536c56e50bedb45ae384af8de3b6483a">uploadFiles</a>.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>directoryName</td>
                <td>Name of the directory in KiFS to be created. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a6eea48ad93a90f8e00c194cfe87250d7">create\_directory\_create\_home\_directory</a>: When set, a home directory is created for the user name provided in the value. The <span>directoryName</span> must be an empty string in this case. The user must exist. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a4b6b939da3d5ca9fae8f0e262abe2497">create\_directory\_data\_limit</a>: The maximum capacity, in bytes, to apply to the created directory. Set to -1 to indicate no upper limit. If empty, the system default limit is applied. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a0c2b822bf59c127ed06112f8e4fe90eb">create\_directory\_no\_error\_if\_exists</a>: If <a href="/content/api/cpp/namespacegpudb#a65fde3c9705cf756aa5f7115e18ca283">true</a>, does not return an error if the directory already exists. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a65fde3c9705cf756aa5f7115e18ca283">create\_directory\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a8087053c4f1d8d6fc90cf27e01b1875f">create\_directory\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a8087053c4f1d8d6fc90cf27e01b1875f">create\_directory\_false</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CreateDirectoryResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CreateDirectoryResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ae45e294adbb6e195ee0c90b06f8bdf93">◆ </a></span>createEnvironment() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CreateEnvironmentResponse">CreateEnvironmentResponse</a> gpudb::GPUdb::createEnvironment </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1CreateEnvironmentRequest">CreateEnvironmentRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Creates a new environment which can be used by <a href="/content/concepts/udf/">user-defined functions</a> (UDF). </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CreateEnvironmentRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CreateEnvironmentResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a721b9eb3619dbd4be1544cb964870ca8">◆ </a></span>createEnvironment() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CreateEnvironmentResponse">CreateEnvironmentResponse</a> & gpudb::GPUdb::createEnvironment </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1CreateEnvironmentRequest">CreateEnvironmentRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1CreateEnvironmentResponse">CreateEnvironmentResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Creates a new environment which can be used by <a href="/content/concepts/udf/">user-defined functions</a> (UDF). </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CreateEnvironmentRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CreateEnvironmentResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CreateEnvironmentResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a406a2b93c56aa4349b0c9044fc45cc2c">◆ </a></span>createEnvironment() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CreateEnvironmentResponse">CreateEnvironmentResponse</a> gpudb::GPUdb::createEnvironment </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>environmentName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Creates a new environment which can be used by <a href="/content/concepts/udf/">user-defined functions</a> (UDF). </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>environmentName</td>
                <td>Name of the environment to be created. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CreateEnvironmentResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ae802312994c203cd1daf82737d1b59eb">◆ </a></span>createEnvironment() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CreateEnvironmentResponse">CreateEnvironmentResponse</a> & gpudb::GPUdb::createEnvironment </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>environmentName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1CreateEnvironmentResponse">CreateEnvironmentResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Creates a new environment which can be used by <a href="/content/concepts/udf/">user-defined functions</a> (UDF). </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>environmentName</td>
                <td>Name of the environment to be created. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CreateEnvironmentResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CreateEnvironmentResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a4055b3b0cd047d5c78f8ab61350e1c4e">◆ </a></span>createGraph() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CreateGraphResponse">CreateGraphResponse</a> gpudb::GPUdb::createGraph </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1CreateGraphRequest">CreateGraphRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Creates a new graph network using given nodes, edges, weights, and restrictions. </p>
        <p>IMPORTANT: It's highly recommended that you review the <a href="/content/graph_solver/network_graph_solver/">Graphs and Solvers</a> concepts documentation, the <a href="/content/guides/graph_rest_guide/">Graph REST Tutorial</a>, and/or some <a href="/content/guides/tags/graph">graph examples</a> before using this endpoint.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CreateGraphRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CreateGraphResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a01658fbf50eee78b0680adaa40c91da1">◆ </a></span>createGraph() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CreateGraphResponse">CreateGraphResponse</a> & gpudb::GPUdb::createGraph </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1CreateGraphRequest">CreateGraphRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1CreateGraphResponse">CreateGraphResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Creates a new graph network using given nodes, edges, weights, and restrictions. </p>
        <p>IMPORTANT: It's highly recommended that you review the <a href="/content/graph_solver/network_graph_solver/">Graphs and Solvers</a> concepts documentation, the <a href="/content/guides/graph_rest_guide/">Graph REST Tutorial</a>, and/or some <a href="/content/guides/tags/graph">graph examples</a> before using this endpoint.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CreateGraphRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CreateGraphResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CreateGraphResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a025f78582e1d24c590888a3d29e19f36">◆ </a></span>createGraph() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CreateGraphResponse">CreateGraphResponse</a> gpudb::GPUdb::createGraph </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>graphName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const bool</td>
            <td><span><span>directedGraph</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< std::string > &</td>
            <td><span><span>nodes</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< std::string > &</td>
            <td><span><span>edges</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< std::string > &</td>
            <td><span><span>weights</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< std::string > &</td>
            <td><span><span>restrictions</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Creates a new graph network using given nodes, edges, weights, and restrictions. </p>
        <p>IMPORTANT: It's highly recommended that you review the <a href="/content/graph_solver/network_graph_solver/">Graphs and Solvers</a> concepts documentation, the <a href="/content/guides/graph_rest_guide/">Graph REST Tutorial</a>, and/or some <a href="/content/guides/tags/graph">graph examples</a> before using this endpoint.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>graphName</td>
                <td>Name of the graph resource to generate. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>directedGraph</td>

                <td>
                  If set to <a href="/content/api/cpp/namespacegpudb#a3ca8c939d8cfab26776111afb43aad58">true</a>, the graph will be directed. If set to <a href="/content/api/cpp/namespacegpudb#a2c423b784936dedad83dfb7dd78ef7ff">false</a>, the graph will not be directed. Consult <a href="/content/graph_solver/network_graph_solver/#directed-graphs">Directed Graphs</a> for more details. Supported values:

                  <ul>
                    <li> true </li>
                    <li> false </li>
                  </ul>

                  The default value is true.
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>nodes</td>
                <td>Nodes represent fundamental topological units of a graph. Nodes must be specified using <a href="/content/graph_solver/network_graph_solver/#identifiers">identifiers</a>; identifiers are grouped as <a href="/content/graph_solver/network_graph_solver/#id-combos">combinations</a>. Identifiers can be used with existing column names, e.g., 'table.column AS NODE\_ID', expressions, e.g., 'ST\_MAKEPOINT(column1, column2) AS NODE\_WKTPOINT', or constant values, e.g., '9, 10, 11 AS NODE\_ID'. If using constant values in an identifier combination, the number of values specified must match across the combination. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>edges</td>
                <td>Edges represent the required fundamental topological unit of a graph that typically connect nodes. Edges must be specified using <a href="/content/graph_solver/network_graph_solver/#identifiers">identifiers</a>; identifiers are grouped as <a href="/content/graph_solver/network_graph_solver/#id-combos">combinations</a>. Identifiers can be used with existing column names, e.g., 'table.column AS EDGE\_ID', expressions, e.g., 'SUBSTR(column, 1, 6) AS EDGE\_NODE1\_NAME', or constant values, e.g., "'family', 'coworker' AS EDGE\_LABEL". If using constant values in an identifier combination, the number of values specified must match across the combination. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>weights</td>
                <td>Weights represent a method of informing the graph solver of the cost of including a given edge in a solution. Weights must be specified using <a href="/content/graph_solver/network_graph_solver/#identifiers">identifiers</a>; identifiers are grouped as <a href="/content/graph_solver/network_graph_solver/#id-combos">combinations</a>. Identifiers can be used with existing column names, e.g., 'table.column AS WEIGHTS\_EDGE\_ID', expressions, e.g., 'ST\_LENGTH(wkt) AS WEIGHTS\_VALUESPECIFIED', or constant values, e.g., '4, 15 AS WEIGHTS\_VALUESPECIFIED'. If using constant values in an identifier combination, the number of values specified must match across the combination. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>restrictions</td>
                <td>Restrictions represent a method of informing the graph solver which edges and/or nodes should be ignored for the solution. Restrictions must be specified using <a href="/content/graph_solver/network_graph_solver/#identifiers">identifiers</a>; identifiers are grouped as <a href="/content/graph_solver/network_graph_solver/#id-combos">combinations</a>. Identifiers can be used with existing column names, e.g., 'table.column AS RESTRICTIONS\_EDGE\_ID', expressions, e.g., 'column/2 AS RESTRICTIONS\_VALUECOMPARED', or constant values, e.g., '0, 0, 0, 1 AS RESTRICTIONS\_ONOFFCOMPARED'. If using constant values in an identifier combination, the number of values specified must match across the combination. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a417e28ff8866570429f8316aeaa3da2a">create\_graph\_merge\_tolerance</a>: If node geospatial positions are input (e.g., WKTPOINT, X, Y), determines the minimum separation allowed between unique nodes. If nodes are within the tolerance of each other, they will be merged as a single node. The default value is '1.0E-5'. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a3e5f1b4f55b323f19b1a3dcbe72ff374">create\_graph\_recreate</a>: If set to <a href="/content/api/cpp/namespacegpudb#a3ca8c939d8cfab26776111afb43aad58">true</a> and the graph (using <span>graphName</span>) already exists, the graph is deleted and recreated. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a3ca8c939d8cfab26776111afb43aad58">create\_graph\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a2c423b784936dedad83dfb7dd78ef7ff">create\_graph\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a2c423b784936dedad83dfb7dd78ef7ff">create\_graph\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a11e0b27a923e0799b98d3e4fb3556f84">create\_graph\_save\_persist</a>: If set to <a href="/content/api/cpp/namespacegpudb#a3ca8c939d8cfab26776111afb43aad58">true</a>, the graph will be saved in the persist directory (see the <a href="/content/config/#config-main-persistence">config reference</a> for more information). If set to <a href="/content/api/cpp/namespacegpudb#a2c423b784936dedad83dfb7dd78ef7ff">false</a>, the graph will be removed when the graph server is shutdown. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a3ca8c939d8cfab26776111afb43aad58">create\_graph\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a2c423b784936dedad83dfb7dd78ef7ff">create\_graph\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a2c423b784936dedad83dfb7dd78ef7ff">create\_graph\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a24454d1b5129edb59f73971954affb01">create\_graph\_add\_table\_monitor</a>: Adds a table monitor to every table used in the creation of the graph; this table monitor will trigger the graph to update dynamically upon inserts to the source table(s). Note that upon database restart, if <a href="/content/api/cpp/namespacegpudb#a11e0b27a923e0799b98d3e4fb3556f84">save\_persist</a> is also set to <a href="/content/api/cpp/namespacegpudb#a3ca8c939d8cfab26776111afb43aad58">true</a>, the graph will be fully reconstructed and the table monitors will be reattached. For more details on table monitors, see <a href="#a562dc443f79f57ea572cb5ec0f2e8093">createTableMonitor</a>. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a3ca8c939d8cfab26776111afb43aad58">create\_graph\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a2c423b784936dedad83dfb7dd78ef7ff">create\_graph\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a2c423b784936dedad83dfb7dd78ef7ff">create\_graph\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#ae24dc42aca0219b29bed07d5d9c2f826">create\_graph\_graph\_table</a>: If specified, the created graph is also created as a table with the given name, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a> and meeting <a href="/content/concepts/tables/#table-naming-criteria">table naming criteria</a>. The table will have the following identifier columns: 'EDGE\_ID', 'EDGE\_NODE1\_ID', 'EDGE\_NODE2\_ID'. If left blank, no table is created. The default value is ''. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a1586f986bd5f37dc3e7806070f5961e2">create\_graph\_add\_turns</a>: Adds dummy 'pillowed' edges around intersection nodes where there are more than three edges so that additional weight penalties can be imposed by the solve endpoints. (increases the total number of edges). Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a3ca8c939d8cfab26776111afb43aad58">create\_graph\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a2c423b784936dedad83dfb7dd78ef7ff">create\_graph\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a2c423b784936dedad83dfb7dd78ef7ff">create\_graph\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a072a45120a76033064fd2888df6f1972">create\_graph\_is\_partitioned</a>: Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a3ca8c939d8cfab26776111afb43aad58">create\_graph\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a2c423b784936dedad83dfb7dd78ef7ff">create\_graph\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a2c423b784936dedad83dfb7dd78ef7ff">create\_graph\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a0eb694cde3b39f636045687e318aed15">create\_graph\_server\_id</a>: Indicates which graph server(s) to send the request to. Default is to send to the server with the most available memory. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a564af03011ce5f92e8cf2cd7ed0f870a">create\_graph\_use\_rtree</a>: Use an range tree structure to accelerate and improve the accuracy of snapping, especially to edges. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a3ca8c939d8cfab26776111afb43aad58">create\_graph\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a2c423b784936dedad83dfb7dd78ef7ff">create\_graph\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a3ca8c939d8cfab26776111afb43aad58">create\_graph\_true</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a0b1ab95446fabf6535c40eb993f7efec">create\_graph\_label\_delimiter</a>: If provided the label string will be split according to this delimiter and each sub-string will be applied as a separate label onto the specified edge. The default value is ''. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ae39505f96d21f75fdc2ac96ffb6de000">create\_graph\_allow\_multiple\_edges</a>: Multigraph choice; allowing multiple edges with the same node pairs if set to true, otherwise, new edges with existing same node pairs will not be inserted. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a3ca8c939d8cfab26776111afb43aad58">create\_graph\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a2c423b784936dedad83dfb7dd78ef7ff">create\_graph\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a3ca8c939d8cfab26776111afb43aad58">create\_graph\_true</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#ad38dcf04662a13366ed41d4b3d9b2c7a">create\_graph\_embedding\_table</a>: If table exists (should be generated by the match/graph match\_embedding solver), the vector embeddings for the newly inserted nodes will be appended into this table. The default value is ''. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CreateGraphResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#aeab804eaaec1a946d6d4a294312d8f7b">◆ </a></span>createGraph() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CreateGraphResponse">CreateGraphResponse</a> & gpudb::GPUdb::createGraph </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>graphName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const bool</td>
            <td><span><span>directedGraph</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< std::string > &</td>
            <td><span><span>nodes</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< std::string > &</td>
            <td><span><span>edges</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< std::string > &</td>
            <td><span><span>weights</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< std::string > &</td>
            <td><span><span>restrictions</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1CreateGraphResponse">CreateGraphResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Creates a new graph network using given nodes, edges, weights, and restrictions. </p>
        <p>IMPORTANT: It's highly recommended that you review the <a href="/content/graph_solver/network_graph_solver/">Graphs and Solvers</a> concepts documentation, the <a href="/content/guides/graph_rest_guide/">Graph REST Tutorial</a>, and/or some <a href="/content/guides/tags/graph">graph examples</a> before using this endpoint.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>graphName</td>
                <td>Name of the graph resource to generate. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>directedGraph</td>

                <td>
                  If set to <a href="/content/api/cpp/namespacegpudb#a3ca8c939d8cfab26776111afb43aad58">true</a>, the graph will be directed. If set to <a href="/content/api/cpp/namespacegpudb#a2c423b784936dedad83dfb7dd78ef7ff">false</a>, the graph will not be directed. Consult <a href="/content/graph_solver/network_graph_solver/#directed-graphs">Directed Graphs</a> for more details. Supported values:

                  <ul>
                    <li> true </li>
                    <li> false </li>
                  </ul>

                  The default value is true.
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>nodes</td>
                <td>Nodes represent fundamental topological units of a graph. Nodes must be specified using <a href="/content/graph_solver/network_graph_solver/#identifiers">identifiers</a>; identifiers are grouped as <a href="/content/graph_solver/network_graph_solver/#id-combos">combinations</a>. Identifiers can be used with existing column names, e.g., 'table.column AS NODE\_ID', expressions, e.g., 'ST\_MAKEPOINT(column1, column2) AS NODE\_WKTPOINT', or constant values, e.g., '9, 10, 11 AS NODE\_ID'. If using constant values in an identifier combination, the number of values specified must match across the combination. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>edges</td>
                <td>Edges represent the required fundamental topological unit of a graph that typically connect nodes. Edges must be specified using <a href="/content/graph_solver/network_graph_solver/#identifiers">identifiers</a>; identifiers are grouped as <a href="/content/graph_solver/network_graph_solver/#id-combos">combinations</a>. Identifiers can be used with existing column names, e.g., 'table.column AS EDGE\_ID', expressions, e.g., 'SUBSTR(column, 1, 6) AS EDGE\_NODE1\_NAME', or constant values, e.g., "'family', 'coworker' AS EDGE\_LABEL". If using constant values in an identifier combination, the number of values specified must match across the combination. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>weights</td>
                <td>Weights represent a method of informing the graph solver of the cost of including a given edge in a solution. Weights must be specified using <a href="/content/graph_solver/network_graph_solver/#identifiers">identifiers</a>; identifiers are grouped as <a href="/content/graph_solver/network_graph_solver/#id-combos">combinations</a>. Identifiers can be used with existing column names, e.g., 'table.column AS WEIGHTS\_EDGE\_ID', expressions, e.g., 'ST\_LENGTH(wkt) AS WEIGHTS\_VALUESPECIFIED', or constant values, e.g., '4, 15 AS WEIGHTS\_VALUESPECIFIED'. If using constant values in an identifier combination, the number of values specified must match across the combination. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>restrictions</td>
                <td>Restrictions represent a method of informing the graph solver which edges and/or nodes should be ignored for the solution. Restrictions must be specified using <a href="/content/graph_solver/network_graph_solver/#identifiers">identifiers</a>; identifiers are grouped as <a href="/content/graph_solver/network_graph_solver/#id-combos">combinations</a>. Identifiers can be used with existing column names, e.g., 'table.column AS RESTRICTIONS\_EDGE\_ID', expressions, e.g., 'column/2 AS RESTRICTIONS\_VALUECOMPARED', or constant values, e.g., '0, 0, 0, 1 AS RESTRICTIONS\_ONOFFCOMPARED'. If using constant values in an identifier combination, the number of values specified must match across the combination. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a417e28ff8866570429f8316aeaa3da2a">create\_graph\_merge\_tolerance</a>: If node geospatial positions are input (e.g., WKTPOINT, X, Y), determines the minimum separation allowed between unique nodes. If nodes are within the tolerance of each other, they will be merged as a single node. The default value is '1.0E-5'. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a3e5f1b4f55b323f19b1a3dcbe72ff374">create\_graph\_recreate</a>: If set to <a href="/content/api/cpp/namespacegpudb#a3ca8c939d8cfab26776111afb43aad58">true</a> and the graph (using <span>graphName</span>) already exists, the graph is deleted and recreated. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a3ca8c939d8cfab26776111afb43aad58">create\_graph\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a2c423b784936dedad83dfb7dd78ef7ff">create\_graph\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a2c423b784936dedad83dfb7dd78ef7ff">create\_graph\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a11e0b27a923e0799b98d3e4fb3556f84">create\_graph\_save\_persist</a>: If set to <a href="/content/api/cpp/namespacegpudb#a3ca8c939d8cfab26776111afb43aad58">true</a>, the graph will be saved in the persist directory (see the <a href="/content/config/#config-main-persistence">config reference</a> for more information). If set to <a href="/content/api/cpp/namespacegpudb#a2c423b784936dedad83dfb7dd78ef7ff">false</a>, the graph will be removed when the graph server is shutdown. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a3ca8c939d8cfab26776111afb43aad58">create\_graph\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a2c423b784936dedad83dfb7dd78ef7ff">create\_graph\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a2c423b784936dedad83dfb7dd78ef7ff">create\_graph\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a24454d1b5129edb59f73971954affb01">create\_graph\_add\_table\_monitor</a>: Adds a table monitor to every table used in the creation of the graph; this table monitor will trigger the graph to update dynamically upon inserts to the source table(s). Note that upon database restart, if <a href="/content/api/cpp/namespacegpudb#a11e0b27a923e0799b98d3e4fb3556f84">save\_persist</a> is also set to <a href="/content/api/cpp/namespacegpudb#a3ca8c939d8cfab26776111afb43aad58">true</a>, the graph will be fully reconstructed and the table monitors will be reattached. For more details on table monitors, see <a href="#a562dc443f79f57ea572cb5ec0f2e8093">createTableMonitor</a>. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a3ca8c939d8cfab26776111afb43aad58">create\_graph\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a2c423b784936dedad83dfb7dd78ef7ff">create\_graph\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a2c423b784936dedad83dfb7dd78ef7ff">create\_graph\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#ae24dc42aca0219b29bed07d5d9c2f826">create\_graph\_graph\_table</a>: If specified, the created graph is also created as a table with the given name, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a> and meeting <a href="/content/concepts/tables/#table-naming-criteria">table naming criteria</a>. The table will have the following identifier columns: 'EDGE\_ID', 'EDGE\_NODE1\_ID', 'EDGE\_NODE2\_ID'. If left blank, no table is created. The default value is ''. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a1586f986bd5f37dc3e7806070f5961e2">create\_graph\_add\_turns</a>: Adds dummy 'pillowed' edges around intersection nodes where there are more than three edges so that additional weight penalties can be imposed by the solve endpoints. (increases the total number of edges). Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a3ca8c939d8cfab26776111afb43aad58">create\_graph\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a2c423b784936dedad83dfb7dd78ef7ff">create\_graph\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a2c423b784936dedad83dfb7dd78ef7ff">create\_graph\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a072a45120a76033064fd2888df6f1972">create\_graph\_is\_partitioned</a>: Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a3ca8c939d8cfab26776111afb43aad58">create\_graph\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a2c423b784936dedad83dfb7dd78ef7ff">create\_graph\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a2c423b784936dedad83dfb7dd78ef7ff">create\_graph\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a0eb694cde3b39f636045687e318aed15">create\_graph\_server\_id</a>: Indicates which graph server(s) to send the request to. Default is to send to the server with the most available memory. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a564af03011ce5f92e8cf2cd7ed0f870a">create\_graph\_use\_rtree</a>: Use an range tree structure to accelerate and improve the accuracy of snapping, especially to edges. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a3ca8c939d8cfab26776111afb43aad58">create\_graph\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a2c423b784936dedad83dfb7dd78ef7ff">create\_graph\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a3ca8c939d8cfab26776111afb43aad58">create\_graph\_true</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a0b1ab95446fabf6535c40eb993f7efec">create\_graph\_label\_delimiter</a>: If provided the label string will be split according to this delimiter and each sub-string will be applied as a separate label onto the specified edge. The default value is ''. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ae39505f96d21f75fdc2ac96ffb6de000">create\_graph\_allow\_multiple\_edges</a>: Multigraph choice; allowing multiple edges with the same node pairs if set to true, otherwise, new edges with existing same node pairs will not be inserted. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a3ca8c939d8cfab26776111afb43aad58">create\_graph\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a2c423b784936dedad83dfb7dd78ef7ff">create\_graph\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a3ca8c939d8cfab26776111afb43aad58">create\_graph\_true</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#ad38dcf04662a13366ed41d4b3d9b2c7a">create\_graph\_embedding\_table</a>: If table exists (should be generated by the match/graph match\_embedding solver), the vector embeddings for the newly inserted nodes will be appended into this table. The default value is ''. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CreateGraphResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CreateGraphResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a02ef4c58e395bbf2c83325cf592397af">◆ </a></span>createJob() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CreateJobResponse">CreateJobResponse</a> gpudb::GPUdb::createJob </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1CreateJobRequest">CreateJobRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Create a job which will run asynchronously. </p>
        <p>The response returns a job ID, which can be used to query the status and result of the job. The status and the result of the job upon completion can be requested by <a href="#a0ff78cb10848a739067c5dbd0a052e05">getJob</a>.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CreateJobRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CreateJobResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a09c09f08b2e5805ff3740daa3eaa06c1">◆ </a></span>createJob() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CreateJobResponse">CreateJobResponse</a> & gpudb::GPUdb::createJob </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1CreateJobRequest">CreateJobRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1CreateJobResponse">CreateJobResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Create a job which will run asynchronously. </p>
        <p>The response returns a job ID, which can be used to query the status and result of the job. The status and the result of the job upon completion can be requested by <a href="#a0ff78cb10848a739067c5dbd0a052e05">getJob</a>.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CreateJobRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CreateJobResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CreateJobResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a2807b0831529b2f2e6fb554339670763">◆ </a></span>createJob() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CreateJobResponse">CreateJobResponse</a> gpudb::GPUdb::createJob </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>endpoint</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>requestEncoding</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< uint8\_t > &</td>
            <td><span><span>data</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>dataStr</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Create a job which will run asynchronously. </p>
        <p>The response returns a job ID, which can be used to query the status and result of the job. The status and the result of the job upon completion can be requested by <a href="#a8f46b312a6700634204dec278fe18b98">getJob</a>.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>endpoint</td>
                <td>Indicates which endpoint to execute, e.g. '/alter/table'. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>requestEncoding</td>

                <td>
                  The encoding of the request payload for the job. Supported values:

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a0258ba3c6c49237f61120ae4d0e7ff08">create\_job\_binary</a> </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a135ca12331c5c022ddb43149122a47b0">create\_job\_json</a> </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a83c7f5ccd5607cbacfd3777955101238">create\_job\_snappy</a> </li>
                  </ul>

                  The default value is <a href="/content/api/cpp/namespacegpudb#a0258ba3c6c49237f61120ae4d0e7ff08">create\_job\_binary</a>.
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>data</td>
                <td>Binary-encoded payload for the job to be run asynchronously. The payload must contain the relevant input parameters for the endpoint indicated in <span>endpoint</span>. Please see the documentation for the appropriate endpoint to see what values must (or can) be specified. If this parameter is used, then <span>requestEncoding</span> must be <a href="/content/api/cpp/namespacegpudb#a0258ba3c6c49237f61120ae4d0e7ff08">binary</a> or <a href="/content/api/cpp/namespacegpudb#a83c7f5ccd5607cbacfd3777955101238">snappy</a>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>dataStr</td>
                <td>JSON-encoded payload for the job to be run asynchronously. The payload must contain the relevant input parameters for the endpoint indicated in <span>endpoint</span>. Please see the documentation for the appropriate endpoint to see what values must (or can) be specified. If this parameter is used, then <span>requestEncoding</span> must be <a href="/content/api/cpp/namespacegpudb#a135ca12331c5c022ddb43149122a47b0">json</a>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a5decd9d4fe50c463553fb90c9023d3a5">create\_job\_job\_tag</a>: Tag to use for submitted job. The same tag could be used on backup cluster to retrieve response for the job. Tags can use letter, numbers, '\_' and '-'. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CreateJobResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ab9d0718a56686729612f1b0917601983">◆ </a></span>createJob() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CreateJobResponse">CreateJobResponse</a> & gpudb::GPUdb::createJob </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>endpoint</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>requestEncoding</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< uint8\_t > &</td>
            <td><span><span>data</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>dataStr</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1CreateJobResponse">CreateJobResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Create a job which will run asynchronously. </p>
        <p>The response returns a job ID, which can be used to query the status and result of the job. The status and the result of the job upon completion can be requested by <a href="#a8f46b312a6700634204dec278fe18b98">getJob</a>.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>endpoint</td>
                <td>Indicates which endpoint to execute, e.g. '/alter/table'. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>requestEncoding</td>

                <td>
                  The encoding of the request payload for the job. Supported values:

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a0258ba3c6c49237f61120ae4d0e7ff08">create\_job\_binary</a> </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a135ca12331c5c022ddb43149122a47b0">create\_job\_json</a> </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a83c7f5ccd5607cbacfd3777955101238">create\_job\_snappy</a> </li>
                  </ul>

                  The default value is <a href="/content/api/cpp/namespacegpudb#a0258ba3c6c49237f61120ae4d0e7ff08">create\_job\_binary</a>.
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>data</td>
                <td>Binary-encoded payload for the job to be run asynchronously. The payload must contain the relevant input parameters for the endpoint indicated in <span>endpoint</span>. Please see the documentation for the appropriate endpoint to see what values must (or can) be specified. If this parameter is used, then <span>requestEncoding</span> must be <a href="/content/api/cpp/namespacegpudb#a0258ba3c6c49237f61120ae4d0e7ff08">binary</a> or <a href="/content/api/cpp/namespacegpudb#a83c7f5ccd5607cbacfd3777955101238">snappy</a>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>dataStr</td>
                <td>JSON-encoded payload for the job to be run asynchronously. The payload must contain the relevant input parameters for the endpoint indicated in <span>endpoint</span>. Please see the documentation for the appropriate endpoint to see what values must (or can) be specified. If this parameter is used, then <span>requestEncoding</span> must be <a href="/content/api/cpp/namespacegpudb#a135ca12331c5c022ddb43149122a47b0">json</a>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a5decd9d4fe50c463553fb90c9023d3a5">create\_job\_job\_tag</a>: Tag to use for submitted job. The same tag could be used on backup cluster to retrieve response for the job. Tags can use letter, numbers, '\_' and '-'. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CreateJobResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CreateJobResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a3446363f962c29930fd54ab38b8d2f24">◆ </a></span>createJoinTable() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CreateJoinTableResponse">CreateJoinTableResponse</a> gpudb::GPUdb::createJoinTable </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1CreateJoinTableRequest">CreateJoinTableRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Creates a table that is the result of a SQL JOIN. </p>
        <p>For join details and examples see: <a href="/content/concepts/joins/">Joins</a>. For limitations, see <a href="/content/concepts/joins/#limitations-cautions">Join Limitations and Cautions</a>.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CreateJoinTableRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CreateJoinTableResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#afeec38b18c4d2e97b552f92ab195df27">◆ </a></span>createJoinTable() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CreateJoinTableResponse">CreateJoinTableResponse</a> & gpudb::GPUdb::createJoinTable </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1CreateJoinTableRequest">CreateJoinTableRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1CreateJoinTableResponse">CreateJoinTableResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Creates a table that is the result of a SQL JOIN. </p>
        <p>For join details and examples see: <a href="/content/concepts/joins/">Joins</a>. For limitations, see <a href="/content/concepts/joins/#limitations-cautions">Join Limitations and Cautions</a>.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CreateJoinTableRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CreateJoinTableResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CreateJoinTableResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a8c4a3b0823d2f0bd9cdd744139ee0e17">◆ </a></span>createJoinTable() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CreateJoinTableResponse">CreateJoinTableResponse</a> gpudb::GPUdb::createJoinTable </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>joinTableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< std::string > &</td>
            <td><span><span>tableNames</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< std::string > &</td>
            <td><span><span>columnNames</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< std::string > &</td>
            <td><span><span>expressions</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Creates a table that is the result of a SQL JOIN. </p>
        <p>For join details and examples see: <a href="/content/concepts/joins/">Joins</a>. For limitations, see <a href="/content/concepts/joins/#limitations-cautions">Join Limitations and Cautions</a>.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>joinTableName</td>
                <td>Name of the join table to be created, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a> and meeting <a href="/content/concepts/tables/#table-naming-criteria">table naming criteria</a>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>tableNames</td>
                <td>The list of table names composing the join, each in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. Corresponds to a SQL statement FROM clause. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>columnNames</td>
                <td>List of member table columns or column expressions to be included in the join. Columns can be prefixed with 'table\_id.column\_name', where 'table\_id' is the table name or alias. Columns can be aliased via the syntax 'column\_name as alias'. Wild cards '<span>' can be used to include all columns across member tables or 'table\_id.</span>' for all of a single table's columns. Columns and column expressions composing the join must be uniquely named or aliased–therefore, the '\*' wild card cannot be used if column names aren't unique across all tables. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>expressions</td>
                <td>An optional list of expressions to combine and filter the joined tables. Corresponds to a SQL statement WHERE clause. For details see: <a href="/content/concepts/expressions/">expressions</a>. The default value is an empty vector. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a7593270978b9443ff37e1c02c99eb019">create\_join\_table\_create\_temp\_table</a>: If <a href="/content/api/cpp/namespacegpudb#ab7e6ed428d4b494c517b78753fd1f8e7">true</a>, a unique temporary table name will be generated in the sys\_temp schema and used in place of <span>joinTableName</span>. This is always allowed even if the caller does not have permission to create tables. The generated name is returned in <a href="/content/api/cpp/namespacegpudb#a79e60033da729f59de1afef5b8d8ac30">qualified\_join\_table\_name</a>. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ab7e6ed428d4b494c517b78753fd1f8e7">create\_join\_table\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ae135f2e5fc0d24d2e21c6bbc43f82748">create\_join\_table\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ae135f2e5fc0d24d2e21c6bbc43f82748">create\_join\_table\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#ad1d4cd0b01da8ce9b9e3b0b633480741">create\_join\_table\_collection\_name</a>: \[DEPRECATED–please specify the containing schema for the join as part of <span>joinTableName</span> and use <a href="#a33d9a0a8e738d14b688f9f869f9640ad">createSchema</a> to create the schema if non-existent] Name of a schema for the join. If the schema is non-existent, it will be automatically created. The default value is ''. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ae0bc574081e06d2c4458db00b7eeca06">create\_join\_table\_max\_query\_dimensions</a>: No longer used. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a907c41d66f9b54f0df1e0e0f4ef512df">create\_join\_table\_strategy\_definition</a>: The <a href="/content/rm/concepts/#tier-strategies">tier strategy</a> for the table and its columns. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a4ef5fbbf2e86ef89d2a36c445be51523">create\_join\_table\_ttl</a>: Sets the <a href="/content/concepts/ttl/">TTL</a> of the join table specified in <span>joinTableName</span>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a6ab3222e9f04dd96dcaef4433e929f3f">create\_join\_table\_view\_id</a>: View this projection is part of. The default value is ''. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#afe43c787a7446c27873464bb374161b1">create\_join\_table\_no\_count</a>: Return a count of 0 for the join table for logging and for <a href="#a0ba64d599891431a9d2aff56dca5a9ab">showTable</a>; optimization needed for large overlapped equi-join stencils. The default value is 'false'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a97a8410473ed65b55275b7438df6519b">create\_join\_table\_chunk\_size</a>: Maximum number of records per joined-chunk for this table. Defaults to the gpudb.conf file chunk size. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a83e7283d83f28c997748ec402ca983bd">create\_join\_table\_enable\_virtual\_chunking</a>: Collect chunks with accumulated size less than chunk\_size into a single chunk. The default value is 'false'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a7b70527fe34feed9e0b3ea25614f195d">create\_join\_table\_max\_virtual\_chunk\_size</a>: Maximum number of records per virtual-chunk. When set, enables virtual chunking. Defaults to chunk\_size if virtual chunking otherwise enabled. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a3196efbc454b15e9ae621b09f07129d8">create\_join\_table\_min\_virtual\_chunk\_size</a>: Minimum number of records per virtual-chunk. When set, enables virtual chunking. Defaults to chunk\_size if virtual chunking otherwise enabled. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ada0f55eb8d263c63df66980725228d36">create\_join\_table\_enable\_sparse\_virtual\_chunking</a>: Materialize virtual chunks with only non-deleted values. The default value is 'false'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a46bbecdb272cf034da7a534cf308a11b">create\_join\_table\_enable\_equi\_join\_lazy\_result\_store</a>: Allow using the lazy result store to cache computation of one side of a multichunk equi-join. Reduces computation but also reduces parallelism to the number of chunks on the other side of the equi-join. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a514d92702f85ce608f02811a0bf82a3f">create\_join\_table\_enable\_predicate\_equi\_join\_lazy\_result\_store</a>: Allow using the lazy result store to cache computation of one side of a multichunk predicate-equi-join. Reduces computation but also reduces parallelism to the number of chunks on the other side of the equi-join. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a7ce421562b5bfc67d5fb7339c08602cf">create\_join\_table\_enable\_pk\_equi\_join</a>: Use equi-join to do primary key joins rather than using primary key index. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CreateJoinTableResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a4a344735f4a950fbb09a2fb84f703569">◆ </a></span>createJoinTable() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CreateJoinTableResponse">CreateJoinTableResponse</a> & gpudb::GPUdb::createJoinTable </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>joinTableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< std::string > &</td>
            <td><span><span>tableNames</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< std::string > &</td>
            <td><span><span>columnNames</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< std::string > &</td>
            <td><span><span>expressions</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1CreateJoinTableResponse">CreateJoinTableResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Creates a table that is the result of a SQL JOIN. </p>
        <p>For join details and examples see: <a href="/content/concepts/joins/">Joins</a>. For limitations, see <a href="/content/concepts/joins/#limitations-cautions">Join Limitations and Cautions</a>.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>joinTableName</td>
                <td>Name of the join table to be created, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a> and meeting <a href="/content/concepts/tables/#table-naming-criteria">table naming criteria</a>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>tableNames</td>
                <td>The list of table names composing the join, each in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. Corresponds to a SQL statement FROM clause. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>columnNames</td>
                <td>List of member table columns or column expressions to be included in the join. Columns can be prefixed with 'table\_id.column\_name', where 'table\_id' is the table name or alias. Columns can be aliased via the syntax 'column\_name as alias'. Wild cards '<span>' can be used to include all columns across member tables or 'table\_id.</span>' for all of a single table's columns. Columns and column expressions composing the join must be uniquely named or aliased–therefore, the '\*' wild card cannot be used if column names aren't unique across all tables. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>expressions</td>
                <td>An optional list of expressions to combine and filter the joined tables. Corresponds to a SQL statement WHERE clause. For details see: <a href="/content/concepts/expressions/">expressions</a>. The default value is an empty vector. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a7593270978b9443ff37e1c02c99eb019">create\_join\_table\_create\_temp\_table</a>: If <a href="/content/api/cpp/namespacegpudb#ab7e6ed428d4b494c517b78753fd1f8e7">true</a>, a unique temporary table name will be generated in the sys\_temp schema and used in place of <span>joinTableName</span>. This is always allowed even if the caller does not have permission to create tables. The generated name is returned in <a href="/content/api/cpp/namespacegpudb#a79e60033da729f59de1afef5b8d8ac30">qualified\_join\_table\_name</a>. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ab7e6ed428d4b494c517b78753fd1f8e7">create\_join\_table\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ae135f2e5fc0d24d2e21c6bbc43f82748">create\_join\_table\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ae135f2e5fc0d24d2e21c6bbc43f82748">create\_join\_table\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#ad1d4cd0b01da8ce9b9e3b0b633480741">create\_join\_table\_collection\_name</a>: \[DEPRECATED–please specify the containing schema for the join as part of <span>joinTableName</span> and use <a href="#a33d9a0a8e738d14b688f9f869f9640ad">createSchema</a> to create the schema if non-existent] Name of a schema for the join. If the schema is non-existent, it will be automatically created. The default value is ''. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ae0bc574081e06d2c4458db00b7eeca06">create\_join\_table\_max\_query\_dimensions</a>: No longer used. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a907c41d66f9b54f0df1e0e0f4ef512df">create\_join\_table\_strategy\_definition</a>: The <a href="/content/rm/concepts/#tier-strategies">tier strategy</a> for the table and its columns. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a4ef5fbbf2e86ef89d2a36c445be51523">create\_join\_table\_ttl</a>: Sets the <a href="/content/concepts/ttl/">TTL</a> of the join table specified in <span>joinTableName</span>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a6ab3222e9f04dd96dcaef4433e929f3f">create\_join\_table\_view\_id</a>: View this projection is part of. The default value is ''. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#afe43c787a7446c27873464bb374161b1">create\_join\_table\_no\_count</a>: Return a count of 0 for the join table for logging and for <a href="#a0ba64d599891431a9d2aff56dca5a9ab">showTable</a>; optimization needed for large overlapped equi-join stencils. The default value is 'false'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a97a8410473ed65b55275b7438df6519b">create\_join\_table\_chunk\_size</a>: Maximum number of records per joined-chunk for this table. Defaults to the gpudb.conf file chunk size. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a83e7283d83f28c997748ec402ca983bd">create\_join\_table\_enable\_virtual\_chunking</a>: Collect chunks with accumulated size less than chunk\_size into a single chunk. The default value is 'false'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a7b70527fe34feed9e0b3ea25614f195d">create\_join\_table\_max\_virtual\_chunk\_size</a>: Maximum number of records per virtual-chunk. When set, enables virtual chunking. Defaults to chunk\_size if virtual chunking otherwise enabled. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a3196efbc454b15e9ae621b09f07129d8">create\_join\_table\_min\_virtual\_chunk\_size</a>: Minimum number of records per virtual-chunk. When set, enables virtual chunking. Defaults to chunk\_size if virtual chunking otherwise enabled. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ada0f55eb8d263c63df66980725228d36">create\_join\_table\_enable\_sparse\_virtual\_chunking</a>: Materialize virtual chunks with only non-deleted values. The default value is 'false'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a46bbecdb272cf034da7a534cf308a11b">create\_join\_table\_enable\_equi\_join\_lazy\_result\_store</a>: Allow using the lazy result store to cache computation of one side of a multichunk equi-join. Reduces computation but also reduces parallelism to the number of chunks on the other side of the equi-join. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a514d92702f85ce608f02811a0bf82a3f">create\_join\_table\_enable\_predicate\_equi\_join\_lazy\_result\_store</a>: Allow using the lazy result store to cache computation of one side of a multichunk predicate-equi-join. Reduces computation but also reduces parallelism to the number of chunks on the other side of the equi-join. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a7ce421562b5bfc67d5fb7339c08602cf">create\_join\_table\_enable\_pk\_equi\_join</a>: Use equi-join to do primary key joins rather than using primary key index. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CreateJoinTableResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CreateJoinTableResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a494c22211d9100d2c5ca53d4f6cef62a">◆ </a></span>createMaterializedView() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CreateMaterializedViewResponse">CreateMaterializedViewResponse</a> gpudb::GPUdb::createMaterializedView </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1CreateMaterializedViewRequest">CreateMaterializedViewRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Initiates the process of creating a materialized view, reserving the view's name to prevent other views or tables from being created with that name. </p>
        <p>For materialized view details and examples, see <a href="/content/concepts/materialized_views/">Materialized Views</a>.</p>
        <p>The response contains <a href="/content/api/cpp/structgpudb_1_1CreateMaterializedViewResponse#ab6b4448f11d3b8bd4ce19a5be6e039f6">viewId</a>, which is used to tag each subsequent operation (projection, union, aggregation, filter, or join) that will compose the view.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CreateMaterializedViewRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CreateMaterializedViewResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ad86909729ba25bf8a3c781bb50c954dd">◆ </a></span>createMaterializedView() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CreateMaterializedViewResponse">CreateMaterializedViewResponse</a> & gpudb::GPUdb::createMaterializedView </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1CreateMaterializedViewRequest">CreateMaterializedViewRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1CreateMaterializedViewResponse">CreateMaterializedViewResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Initiates the process of creating a materialized view, reserving the view's name to prevent other views or tables from being created with that name. </p>
        <p>For materialized view details and examples, see <a href="/content/concepts/materialized_views/">Materialized Views</a>.</p>
        <p>The response contains <a href="/content/api/cpp/structgpudb_1_1CreateMaterializedViewResponse#ab6b4448f11d3b8bd4ce19a5be6e039f6">viewId</a>, which is used to tag each subsequent operation (projection, union, aggregation, filter, or join) that will compose the view.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CreateMaterializedViewRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CreateMaterializedViewResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CreateMaterializedViewResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a4c585a19766a2de5755448429f034b61">◆ </a></span>createMaterializedView() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CreateMaterializedViewResponse">CreateMaterializedViewResponse</a> gpudb::GPUdb::createMaterializedView </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Initiates the process of creating a materialized view, reserving the view's name to prevent other views or tables from being created with that name. </p>
        <p>For materialized view details and examples, see <a href="/content/concepts/materialized_views/">Materialized Views</a>.</p>
        <p>The response contains <a href="/content/api/cpp/structgpudb_1_1CreateMaterializedViewResponse#ab6b4448f11d3b8bd4ce19a5be6e039f6">viewId</a>, which is used to tag each subsequent operation (projection, union, aggregation, filter, or join) that will compose the view.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of the table to be created that is the top-level table of the materialized view, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a> and meeting <a href="/content/concepts/tables/#table-naming-criteria">table naming criteria</a>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a58d239e3cec45a6b09e1a17b687047e3">create\_materialized\_view\_collection\_name</a>: \[DEPRECATED–please specify the containing schema for the materialized view as part of <span>tableName</span> and use <a href="#a33d9a0a8e738d14b688f9f869f9640ad">createSchema</a> to create the schema if non-existent] Name of a schema which is to contain the newly created view. If the schema provided is non-existent, it will be automatically created. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a3e66c3f9f3cb5b654e3f1010ef496a68">create\_materialized\_view\_execute\_as</a>: User name to use to run the refresh job. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#afe95ed2b6b0d67c5cd7a2f85bfb8d390">create\_materialized\_view\_build\_materialized\_view\_policy</a>: Sets startup materialized view rebuild scheme. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a370c878097b9ffb10fdfa2727d146676">create\_materialized\_view\_always</a>: Rebuild as many materialized views as possible before accepting requests. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#acd189e938d53182834dd5fac8cfa0bf8">create\_materialized\_view\_lazy</a>: Rebuild the necessary materialized views at start, and load the remainder lazily. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ae3085b8b219e28d4ca9d4220ed711d6b">create\_materialized\_view\_on\_demand</a>: Rebuild materialized views as requests use them. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a102bb0ef1a6453fee16053d4e30d233d">create\_materialized\_view\_system</a>: Rebuild materialized views using the system-configured default. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a102bb0ef1a6453fee16053d4e30d233d">create\_materialized\_view\_system</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a7abb96a50ce2c088601ad60347cb72a6">create\_materialized\_view\_persist</a>: If <a href="/content/api/cpp/namespacegpudb#a46c87771ef9ea8ef6fa1c2a45ccf839e">true</a>, then the materialized view specified in <span>tableName</span> will be persisted and will not expire unless a <a href="/content/api/cpp/namespacegpudb#aef5a0fd18b690d24af4b0a8a5d40f868">ttl</a> is specified. If <a href="/content/api/cpp/namespacegpudb#a584036d361cdc5c21b5b8f7742f062e7">false</a>, then the materialized view will be an in-memory table and will expire unless a <a href="/content/api/cpp/namespacegpudb#aef5a0fd18b690d24af4b0a8a5d40f868">ttl</a> is specified otherwise. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a46c87771ef9ea8ef6fa1c2a45ccf839e">create\_materialized\_view\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a584036d361cdc5c21b5b8f7742f062e7">create\_materialized\_view\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a584036d361cdc5c21b5b8f7742f062e7">create\_materialized\_view\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#aa269f2545bf21ea65a55215e18716984">create\_materialized\_view\_enable\_mv\_input\_wrappers</a>: If <a href="/content/api/cpp/namespacegpudb#a46c87771ef9ea8ef6fa1c2a45ccf839e">true</a>, each base table the view reads is accessed through a wrapper view so an in-progress out-of-place update cannot make a record momentarily disappear from the view, and a long refresh does not block updates to the base tables. Overrides the gaia.enable\_mv\_input\_wrappers configuration default when set. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a46c87771ef9ea8ef6fa1c2a45ccf839e">create\_materialized\_view\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a584036d361cdc5c21b5b8f7742f062e7">create\_materialized\_view\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a584036d361cdc5c21b5b8f7742f062e7">create\_materialized\_view\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a727dca7222b3166e32f85667b8794ffd">create\_materialized\_view\_refresh\_span</a>: Sets the future time-offset(in seconds) at which periodic refresh stops. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aeaf0c559fc2469a20a375406b865d683">create\_materialized\_view\_refresh\_stop\_time</a>: When <a href="/content/api/cpp/namespacegpudb#a707887aa726f864d1d45ad8e0dc86913">refresh\_method</a> is <a href="/content/api/cpp/namespacegpudb#a3820f7e67cea78a9d63a6456dd692187">periodic</a>, specifies the time at which a periodic refresh is stopped. Value is a datetime string with format 'YYYY-MM-DD HH:MM:SS'. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a707887aa726f864d1d45ad8e0dc86913">create\_materialized\_view\_refresh\_method</a>: Method by which the join can be refreshed when the data in underlying member tables have changed. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ac0c7b9d1607509c6795e19c216459568">create\_materialized\_view\_manual</a>: Refresh only occurs when manually requested by calling <a href="#a25df43fa85e02f0cdb3dab9e498995ce">alterTable</a> with an 'action' of 'refresh'. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a2f3ba76be193eebaa1bccf02ac304e78">create\_materialized\_view\_on\_query</a>: Refresh any time the view is queried. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ac7c6439ef944407fd5e67962a7431a4c">create\_materialized\_view\_on\_change</a>: If possible, incrementally refresh (refresh just those records added) whenever an insert, update, delete or refresh of input table is done. A full refresh is done if an incremental refresh is not possible. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a3820f7e67cea78a9d63a6456dd692187">create\_materialized\_view\_periodic</a>: Refresh table periodically at rate specified by <a href="/content/api/cpp/namespacegpudb#a85d515b31d3c177b2b1ee1f707861489">refresh\_period</a>. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ac0c7b9d1607509c6795e19c216459568">create\_materialized\_view\_manual</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a85d515b31d3c177b2b1ee1f707861489">create\_materialized\_view\_refresh\_period</a>: When <a href="/content/api/cpp/namespacegpudb#a707887aa726f864d1d45ad8e0dc86913">refresh\_method</a> is <a href="/content/api/cpp/namespacegpudb#a3820f7e67cea78a9d63a6456dd692187">periodic</a>, specifies the period in seconds at which refresh occurs. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a2fd6b33db295cb3864d02105f556cae7">create\_materialized\_view\_refresh\_start\_time</a>: When <a href="/content/api/cpp/namespacegpudb#a707887aa726f864d1d45ad8e0dc86913">refresh\_method</a> is <a href="/content/api/cpp/namespacegpudb#a3820f7e67cea78a9d63a6456dd692187">periodic</a>, specifies the first time at which a refresh is to be done. Value is a datetime string with format 'YYYY-MM-DD HH:MM:SS'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aef5a0fd18b690d24af4b0a8a5d40f868">create\_materialized\_view\_ttl</a>: Sets the <a href="/content/concepts/ttl/">TTL</a> of the table specified in <span>tableName</span>. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CreateMaterializedViewResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#abfa74ba57b3f32437a9855e2ffbc93f2">◆ </a></span>createMaterializedView() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CreateMaterializedViewResponse">CreateMaterializedViewResponse</a> & gpudb::GPUdb::createMaterializedView </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1CreateMaterializedViewResponse">CreateMaterializedViewResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Initiates the process of creating a materialized view, reserving the view's name to prevent other views or tables from being created with that name. </p>
        <p>For materialized view details and examples, see <a href="/content/concepts/materialized_views/">Materialized Views</a>.</p>
        <p>The response contains <a href="/content/api/cpp/structgpudb_1_1CreateMaterializedViewResponse#ab6b4448f11d3b8bd4ce19a5be6e039f6">viewId</a>, which is used to tag each subsequent operation (projection, union, aggregation, filter, or join) that will compose the view.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of the table to be created that is the top-level table of the materialized view, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a> and meeting <a href="/content/concepts/tables/#table-naming-criteria">table naming criteria</a>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a58d239e3cec45a6b09e1a17b687047e3">create\_materialized\_view\_collection\_name</a>: \[DEPRECATED–please specify the containing schema for the materialized view as part of <span>tableName</span> and use <a href="#a33d9a0a8e738d14b688f9f869f9640ad">createSchema</a> to create the schema if non-existent] Name of a schema which is to contain the newly created view. If the schema provided is non-existent, it will be automatically created. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a3e66c3f9f3cb5b654e3f1010ef496a68">create\_materialized\_view\_execute\_as</a>: User name to use to run the refresh job. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#afe95ed2b6b0d67c5cd7a2f85bfb8d390">create\_materialized\_view\_build\_materialized\_view\_policy</a>: Sets startup materialized view rebuild scheme. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a370c878097b9ffb10fdfa2727d146676">create\_materialized\_view\_always</a>: Rebuild as many materialized views as possible before accepting requests. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#acd189e938d53182834dd5fac8cfa0bf8">create\_materialized\_view\_lazy</a>: Rebuild the necessary materialized views at start, and load the remainder lazily. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ae3085b8b219e28d4ca9d4220ed711d6b">create\_materialized\_view\_on\_demand</a>: Rebuild materialized views as requests use them. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a102bb0ef1a6453fee16053d4e30d233d">create\_materialized\_view\_system</a>: Rebuild materialized views using the system-configured default. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a102bb0ef1a6453fee16053d4e30d233d">create\_materialized\_view\_system</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a7abb96a50ce2c088601ad60347cb72a6">create\_materialized\_view\_persist</a>: If <a href="/content/api/cpp/namespacegpudb#a46c87771ef9ea8ef6fa1c2a45ccf839e">true</a>, then the materialized view specified in <span>tableName</span> will be persisted and will not expire unless a <a href="/content/api/cpp/namespacegpudb#aef5a0fd18b690d24af4b0a8a5d40f868">ttl</a> is specified. If <a href="/content/api/cpp/namespacegpudb#a584036d361cdc5c21b5b8f7742f062e7">false</a>, then the materialized view will be an in-memory table and will expire unless a <a href="/content/api/cpp/namespacegpudb#aef5a0fd18b690d24af4b0a8a5d40f868">ttl</a> is specified otherwise. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a46c87771ef9ea8ef6fa1c2a45ccf839e">create\_materialized\_view\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a584036d361cdc5c21b5b8f7742f062e7">create\_materialized\_view\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a584036d361cdc5c21b5b8f7742f062e7">create\_materialized\_view\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#aa269f2545bf21ea65a55215e18716984">create\_materialized\_view\_enable\_mv\_input\_wrappers</a>: If <a href="/content/api/cpp/namespacegpudb#a46c87771ef9ea8ef6fa1c2a45ccf839e">true</a>, each base table the view reads is accessed through a wrapper view so an in-progress out-of-place update cannot make a record momentarily disappear from the view, and a long refresh does not block updates to the base tables. Overrides the gaia.enable\_mv\_input\_wrappers configuration default when set. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a46c87771ef9ea8ef6fa1c2a45ccf839e">create\_materialized\_view\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a584036d361cdc5c21b5b8f7742f062e7">create\_materialized\_view\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a584036d361cdc5c21b5b8f7742f062e7">create\_materialized\_view\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a727dca7222b3166e32f85667b8794ffd">create\_materialized\_view\_refresh\_span</a>: Sets the future time-offset(in seconds) at which periodic refresh stops. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aeaf0c559fc2469a20a375406b865d683">create\_materialized\_view\_refresh\_stop\_time</a>: When <a href="/content/api/cpp/namespacegpudb#a707887aa726f864d1d45ad8e0dc86913">refresh\_method</a> is <a href="/content/api/cpp/namespacegpudb#a3820f7e67cea78a9d63a6456dd692187">periodic</a>, specifies the time at which a periodic refresh is stopped. Value is a datetime string with format 'YYYY-MM-DD HH:MM:SS'. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a707887aa726f864d1d45ad8e0dc86913">create\_materialized\_view\_refresh\_method</a>: Method by which the join can be refreshed when the data in underlying member tables have changed. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ac0c7b9d1607509c6795e19c216459568">create\_materialized\_view\_manual</a>: Refresh only occurs when manually requested by calling <a href="#a25df43fa85e02f0cdb3dab9e498995ce">alterTable</a> with an 'action' of 'refresh'. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a2f3ba76be193eebaa1bccf02ac304e78">create\_materialized\_view\_on\_query</a>: Refresh any time the view is queried. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ac7c6439ef944407fd5e67962a7431a4c">create\_materialized\_view\_on\_change</a>: If possible, incrementally refresh (refresh just those records added) whenever an insert, update, delete or refresh of input table is done. A full refresh is done if an incremental refresh is not possible. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a3820f7e67cea78a9d63a6456dd692187">create\_materialized\_view\_periodic</a>: Refresh table periodically at rate specified by <a href="/content/api/cpp/namespacegpudb#a85d515b31d3c177b2b1ee1f707861489">refresh\_period</a>. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ac0c7b9d1607509c6795e19c216459568">create\_materialized\_view\_manual</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a85d515b31d3c177b2b1ee1f707861489">create\_materialized\_view\_refresh\_period</a>: When <a href="/content/api/cpp/namespacegpudb#a707887aa726f864d1d45ad8e0dc86913">refresh\_method</a> is <a href="/content/api/cpp/namespacegpudb#a3820f7e67cea78a9d63a6456dd692187">periodic</a>, specifies the period in seconds at which refresh occurs. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a2fd6b33db295cb3864d02105f556cae7">create\_materialized\_view\_refresh\_start\_time</a>: When <a href="/content/api/cpp/namespacegpudb#a707887aa726f864d1d45ad8e0dc86913">refresh\_method</a> is <a href="/content/api/cpp/namespacegpudb#a3820f7e67cea78a9d63a6456dd692187">periodic</a>, specifies the first time at which a refresh is to be done. Value is a datetime string with format 'YYYY-MM-DD HH:MM:SS'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aef5a0fd18b690d24af4b0a8a5d40f868">create\_materialized\_view\_ttl</a>: Sets the <a href="/content/concepts/ttl/">TTL</a> of the table specified in <span>tableName</span>. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CreateMaterializedViewResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CreateMaterializedViewResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#aece60959dc14eef09c0a3b390ddee6ea">◆ </a></span>createProc() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CreateProcResponse">CreateProcResponse</a> gpudb::GPUdb::createProc </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1CreateProcRequest">CreateProcRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Creates an instance (proc) of the <a href="/content/concepts/udf/">user-defined functions</a> (UDF) specified by the given command, options, and files, and makes it available for execution. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CreateProcRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CreateProcResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a7d1cc69f145c8d5bfe9d49defc76f52c">◆ </a></span>createProc() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CreateProcResponse">CreateProcResponse</a> & gpudb::GPUdb::createProc </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1CreateProcRequest">CreateProcRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1CreateProcResponse">CreateProcResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Creates an instance (proc) of the <a href="/content/concepts/udf/">user-defined functions</a> (UDF) specified by the given command, options, and files, and makes it available for execution. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CreateProcRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CreateProcResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CreateProcResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ace48ccb741aa8b5aaec6fca25b235fe0">◆ </a></span>createProc() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CreateProcResponse">CreateProcResponse</a> gpudb::GPUdb::createProc </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>procName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>executionMode</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::vector\< uint8\_t > > &</td>
            <td><span><span>files</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>command</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< std::string > &</td>
            <td><span><span>args</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Creates an instance (proc) of the <a href="/content/concepts/udf/">user-defined functions</a> (UDF) specified by the given command, options, and files, and makes it available for execution. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>procName</td>
                <td>Name of the proc to be created. Must not be the name of a currently existing proc. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>executionMode</td>

                <td>
                  The execution mode of the proc. Supported values:

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a5dd108a5fd72513cb0dd2a6f7f18f5f7">create\_proc\_distributed</a>: Input table data will be divided into data segments that are distributed across all nodes in the cluster, and the proc command will be invoked once per data segment in parallel. Output table data from each invocation will be saved to the same node as the corresponding input data. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a188933cd80dde132f4ee0bb4778f6104">create\_proc\_nondistributed</a>: The proc command will be invoked only once per execution, and will not have direct access to any tables named as input or output table parameters in the call to <a href="#a19f569cb61a53022021bbfd9e031468d">executeProc</a>. It will, however, be able to access the database using native API calls. </li>
                  </ul>

                  The default value is <a href="/content/api/cpp/namespacegpudb#a5dd108a5fd72513cb0dd2a6f7f18f5f7">create\_proc\_distributed</a>.
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>files</td>
                <td>A map of the files that make up the proc. The keys of the map are file names, and the values are the binary contents of the files. The file names may include subdirectory names (e.g. 'subdir/file') but must not resolve to a directory above the root for the proc. Files may be loaded from existing files in KiFS. Those file names should be prefixed with the uri kifs\:// and the values in the map should be empty. The default value is an empty map. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>command</td>
                <td>The command (excluding arguments) that will be invoked when the proc is executed. It will be invoked from the directory containing the proc <span>files</span> and may be any command that can be resolved from that directory. It need not refer to a file actually in that directory; for example, it could be 'java' if the proc is a Java application; however, any necessary external programs must be preinstalled on every database node. If the command refers to a file in that directory, it must be preceded with './' as per Linux convention. If not specified, and exactly one file is provided in <span>files</span>, that file will be invoked. The default value is ''. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>args</td>
                <td>An array of command-line arguments that will be passed to <span>command</span> when the proc is executed. The default value is an empty vector. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#ace370a61742e4767311a89a0373320a3">create\_proc\_max\_concurrency\_per\_node</a>: The maximum number of concurrent instances of the proc that will be executed per node. 0 allows unlimited concurrency. The default value is '0'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a9d2030eee6e2495ea4984266f6778992">create\_proc\_set\_environment</a>: A python environment to use when executing the proc. Must be an existing environment, else an error will be returned. The default value is ''. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CreateProcResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ac9fc234ac65973e64a8a832afeab6017">◆ </a></span>createProc() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CreateProcResponse">CreateProcResponse</a> & gpudb::GPUdb::createProc </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>procName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>executionMode</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::vector\< uint8\_t > > &</td>
            <td><span><span>files</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>command</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< std::string > &</td>
            <td><span><span>args</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1CreateProcResponse">CreateProcResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Creates an instance (proc) of the <a href="/content/concepts/udf/">user-defined functions</a> (UDF) specified by the given command, options, and files, and makes it available for execution. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>procName</td>
                <td>Name of the proc to be created. Must not be the name of a currently existing proc. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>executionMode</td>

                <td>
                  The execution mode of the proc. Supported values:

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a5dd108a5fd72513cb0dd2a6f7f18f5f7">create\_proc\_distributed</a>: Input table data will be divided into data segments that are distributed across all nodes in the cluster, and the proc command will be invoked once per data segment in parallel. Output table data from each invocation will be saved to the same node as the corresponding input data. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a188933cd80dde132f4ee0bb4778f6104">create\_proc\_nondistributed</a>: The proc command will be invoked only once per execution, and will not have direct access to any tables named as input or output table parameters in the call to <a href="#a19f569cb61a53022021bbfd9e031468d">executeProc</a>. It will, however, be able to access the database using native API calls. </li>
                  </ul>

                  The default value is <a href="/content/api/cpp/namespacegpudb#a5dd108a5fd72513cb0dd2a6f7f18f5f7">create\_proc\_distributed</a>.
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>files</td>
                <td>A map of the files that make up the proc. The keys of the map are file names, and the values are the binary contents of the files. The file names may include subdirectory names (e.g. 'subdir/file') but must not resolve to a directory above the root for the proc. Files may be loaded from existing files in KiFS. Those file names should be prefixed with the uri kifs\:// and the values in the map should be empty. The default value is an empty map. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>command</td>
                <td>The command (excluding arguments) that will be invoked when the proc is executed. It will be invoked from the directory containing the proc <span>files</span> and may be any command that can be resolved from that directory. It need not refer to a file actually in that directory; for example, it could be 'java' if the proc is a Java application; however, any necessary external programs must be preinstalled on every database node. If the command refers to a file in that directory, it must be preceded with './' as per Linux convention. If not specified, and exactly one file is provided in <span>files</span>, that file will be invoked. The default value is ''. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>args</td>
                <td>An array of command-line arguments that will be passed to <span>command</span> when the proc is executed. The default value is an empty vector. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#ace370a61742e4767311a89a0373320a3">create\_proc\_max\_concurrency\_per\_node</a>: The maximum number of concurrent instances of the proc that will be executed per node. 0 allows unlimited concurrency. The default value is '0'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a9d2030eee6e2495ea4984266f6778992">create\_proc\_set\_environment</a>: A python environment to use when executing the proc. Must be an existing environment, else an error will be returned. The default value is ''. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CreateProcResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CreateProcResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#aab22a8ee1b42ec6fa1acfc3b2f70cf4c">◆ </a></span>createProjection() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CreateProjectionResponse">CreateProjectionResponse</a> gpudb::GPUdb::createProjection </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1CreateProjectionRequest">CreateProjectionRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Creates a new <a href="/content/concepts/projections/">projection</a> of an existing table. </p>
        <p>A projection represents a subset of the columns (potentially including derived columns) of a table.</p>
        <p>For projection details and examples, see <a href="/content/concepts/projections/">Projections</a>. For limitations, see <a href="/content/concepts/projections/#limitations-and-cautions">Projection Limitations and Cautions</a>.</p>
        <p><a href="/content/concepts/window/">Window functions</a>, which can perform operations like moving averages, are available through this endpoint as well as <a href="#aaf391f0f2e29974de30e9aa91dbed1ef">getRecordsByColumn</a>.</p>
        <p>A projection can be created with a different <a href="/content/concepts/tables/#shard-keys">shard key</a> than the source table. By specifying <a href="/content/api/cpp/namespacegpudb#abea2a2041dabe1a1ae3c209ee1889121">shard\_key</a>, the projection will be sharded according to the specified columns, regardless of how the source table is sharded. The source table can even be unsharded or replicated.</p>
        <p>If <a href="/content/api/cpp/structgpudb_1_1CreateProjectionRequest#a13ca13a16564a1d19aa4572618771f7b">tableName</a> is empty, selection is performed against a single-row virtual table. This can be useful in executing temporal (<a href="/content/concepts/expressions/#date-time-functions">NOW()</a>), identity (<a href="/content/concepts/expressions/#user-security-functions">USER()</a>), or constant-based functions (<a href="/content/concepts/expressions/#scalar-functions">GEODIST(-77.11, 38.88, -71.06, 42.36)</a>).</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CreateProjectionRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CreateProjectionResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#adcce6ef10741d33d2215bc8201dd0256">◆ </a></span>createProjection() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CreateProjectionResponse">CreateProjectionResponse</a> & gpudb::GPUdb::createProjection </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1CreateProjectionRequest">CreateProjectionRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1CreateProjectionResponse">CreateProjectionResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Creates a new <a href="/content/concepts/projections/">projection</a> of an existing table. </p>
        <p>A projection represents a subset of the columns (potentially including derived columns) of a table.</p>
        <p>For projection details and examples, see <a href="/content/concepts/projections/">Projections</a>. For limitations, see <a href="/content/concepts/projections/#limitations-and-cautions">Projection Limitations and Cautions</a>.</p>
        <p><a href="/content/concepts/window/">Window functions</a>, which can perform operations like moving averages, are available through this endpoint as well as <a href="#aaf391f0f2e29974de30e9aa91dbed1ef">getRecordsByColumn</a>.</p>
        <p>A projection can be created with a different <a href="/content/concepts/tables/#shard-keys">shard key</a> than the source table. By specifying <a href="/content/api/cpp/namespacegpudb#abea2a2041dabe1a1ae3c209ee1889121">shard\_key</a>, the projection will be sharded according to the specified columns, regardless of how the source table is sharded. The source table can even be unsharded or replicated.</p>
        <p>If <a href="/content/api/cpp/structgpudb_1_1CreateProjectionRequest#a13ca13a16564a1d19aa4572618771f7b">tableName</a> is empty, selection is performed against a single-row virtual table. This can be useful in executing temporal (<a href="/content/concepts/expressions/#date-time-functions">NOW()</a>), identity (<a href="/content/concepts/expressions/#user-security-functions">USER()</a>), or constant-based functions (<a href="/content/concepts/expressions/#scalar-functions">GEODIST(-77.11, 38.88, -71.06, 42.36)</a>).</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CreateProjectionRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CreateProjectionResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CreateProjectionResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a8dd0f76ba727eed190f006f6d15d2e5b">◆ </a></span>createProjection() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CreateProjectionResponse">CreateProjectionResponse</a> gpudb::GPUdb::createProjection </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>projectionName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< std::string > &</td>
            <td><span><span>columnNames</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Creates a new <a href="/content/concepts/projections/">projection</a> of an existing table. </p>
        <p>A projection represents a subset of the columns (potentially including derived columns) of a table.</p>
        <p>For projection details and examples, see <a href="/content/concepts/projections/">Projections</a>. For limitations, see <a href="/content/concepts/projections/#limitations-and-cautions">Projection Limitations and Cautions</a>.</p>
        <p><a href="/content/concepts/window/">Window functions</a>, which can perform operations like moving averages, are available through this endpoint as well as <a href="#a5557e7cbe07004a0f754cf3bb5e5c62b">getRecordsByColumn</a>.</p>
        <p>A projection can be created with a different <a href="/content/concepts/tables/#shard-keys">shard key</a> than the source table. By specifying <a href="/content/api/cpp/namespacegpudb#abea2a2041dabe1a1ae3c209ee1889121">shard\_key</a>, the projection will be sharded according to the specified columns, regardless of how the source table is sharded. The source table can even be unsharded or replicated.</p>
        <p>If <span>tableName</span> is empty, selection is performed against a single-row virtual table. This can be useful in executing temporal (<a href="/content/concepts/expressions/#date-time-functions">NOW()</a>), identity (<a href="/content/concepts/expressions/#user-security-functions">USER()</a>), or constant-based functions (<a href="/content/concepts/expressions/#scalar-functions">GEODIST(-77.11, 38.88, -71.06, 42.36)</a>).</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of the existing table on which the projection is to be applied, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. An empty table name creates a projection from a single-row virtual table, where columns specified should be constants or constant expressions. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>projectionName</td>
                <td>Name of the projection to be created, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a> and meeting <a href="/content/concepts/tables/#table-naming-criteria">table naming criteria</a>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>columnNames</td>
                <td>List of columns from <span>tableName</span> to be included in the projection. Can include derived columns. Can be specified as aliased via the syntax 'column\_name as alias'. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ad323cb8fb4fc766b8764893c2232bd3f">create\_projection\_create\_temp\_table</a>: If <a href="/content/api/cpp/namespacegpudb#a5b599c793afdd772ef44a4215aa85cf5">true</a>, a unique temporary table name will be generated in the sys\_temp schema and used in place of <span>projectionName</span>. If <a href="/content/api/cpp/namespacegpudb#aced0a3481e950bd3c122f71d428e8e03">persist</a> is <a href="/content/api/cpp/namespacegpudb#a132bd8471ab7316ece48f4a31f1ea5c2">false</a> (or unspecified), then this is always allowed even if the caller does not have permission to create tables. The generated name is returned in <a href="/content/api/cpp/namespacegpudb#a70400f2052f2827b35d61e9ced03fa79">qualified\_projection\_name</a>. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a5b599c793afdd772ef44a4215aa85cf5">create\_projection\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a132bd8471ab7316ece48f4a31f1ea5c2">create\_projection\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a132bd8471ab7316ece48f4a31f1ea5c2">create\_projection\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a4b085fdf38a2720aad2dcef61baa782c">create\_projection\_collection\_name</a>: \[DEPRECATED–please specify the containing schema for the projection as part of <span>projectionName</span> and use <a href="#a33d9a0a8e738d14b688f9f869f9640ad">createSchema</a> to create the schema if non-existent] Name of a schema for the projection. If the schema is non-existent, it will be automatically created. The default value is ''. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aa1e7e946d6844a9b7b0b0842ed6f15c2">create\_projection\_expression</a>: An optional filter <a href="/content/concepts/expressions/">expression</a> to be applied to the source table prior to the projection. The default value is ''. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ab815eac2419fe91846599262a0622361">create\_projection\_is\_replicated</a>: If <a href="/content/api/cpp/namespacegpudb#a5b599c793afdd772ef44a4215aa85cf5">true</a> then the projection will be replicated even if the source table is not. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a5b599c793afdd772ef44a4215aa85cf5">create\_projection\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a132bd8471ab7316ece48f4a31f1ea5c2">create\_projection\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a132bd8471ab7316ece48f4a31f1ea5c2">create\_projection\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a8bd2323fce158a53e45ad30b25df61f1">create\_projection\_offset</a>: The number of initial results to skip (this can be useful for paging through the results). The default value is '0'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ab72d73c57be1daea52e642aaac568669">create\_projection\_limit</a>: The number of records to keep. The default value is '-9999'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a6972934c3b3fb28ad51fb2261d40a8a5">create\_projection\_order\_by</a>: Comma-separated list of the columns to be sorted by; e.g. 'timestamp asc, x desc'. The columns specified must be present in <span>columnNames</span>. If any alias is given for any column name, the alias must be used, rather than the original column name. The default value is ''. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aaa43727abcc54776d6386e197de301c0">create\_projection\_chunk\_size</a>: Indicates the number of records per chunk to be used for this projection. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aa313b9efcb5eff6cd9bc04446023f01e">create\_projection\_chunk\_column\_max\_memory</a>: Indicates the target maximum data size for each column in a chunk to be used for this projection. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a1b34b24735000c0dac9a374c1e6cbf4b">create\_projection\_chunk\_max\_memory</a>: Indicates the target maximum data size for all columns in a chunk to be used for this projection. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aeb30765f15c28f2fa32343f25a0b3ca6">create\_projection\_create\_indexes</a>: Comma-separated list of columns on which to create indexes on the projection. The columns specified must be present in <span>columnNames</span>. If any alias is given for any column name, the alias must be used, rather than the original column name. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a4cd2591e02b4dfcdfc1547423bf8bf3c">create\_projection\_ttl</a>: Sets the <a href="/content/concepts/ttl/">TTL</a> of the projection specified in <span>projectionName</span>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#abea2a2041dabe1a1ae3c209ee1889121">create\_projection\_shard\_key</a>: Comma-separated list of the columns to be sharded on; e.g. 'column1, column2'. The columns specified must be present in <span>columnNames</span>. If any alias is given for any column name, the alias must be used, rather than the original column name. The default value is ''. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#aced0a3481e950bd3c122f71d428e8e03">create\_projection\_persist</a>: If <a href="/content/api/cpp/namespacegpudb#a5b599c793afdd772ef44a4215aa85cf5">true</a>, then the projection specified in <span>projectionName</span> will be persisted and will not expire unless a <a href="/content/api/cpp/namespacegpudb#a4cd2591e02b4dfcdfc1547423bf8bf3c">ttl</a> is specified. If <a href="/content/api/cpp/namespacegpudb#a132bd8471ab7316ece48f4a31f1ea5c2">false</a>, then the projection will be an in-memory table and will expire unless a <a href="/content/api/cpp/namespacegpudb#a4cd2591e02b4dfcdfc1547423bf8bf3c">ttl</a> is specified otherwise. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a5b599c793afdd772ef44a4215aa85cf5">create\_projection\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a132bd8471ab7316ece48f4a31f1ea5c2">create\_projection\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a132bd8471ab7316ece48f4a31f1ea5c2">create\_projection\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a9bfd58584a38ba5bd2502f6ebe323553">create\_projection\_preserve\_dict\_encoding</a>: If <a href="/content/api/cpp/namespacegpudb#a5b599c793afdd772ef44a4215aa85cf5">true</a>, then columns that were dict encoded in the source table will be dict encoded in the projection. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a5b599c793afdd772ef44a4215aa85cf5">create\_projection\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a132bd8471ab7316ece48f4a31f1ea5c2">create\_projection\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a5b599c793afdd772ef44a4215aa85cf5">create\_projection\_true</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a0f7a1a2a2f8f7ad907b77a97fbe614d4">create\_projection\_retain\_partitions</a>: Determines whether the created projection will retain the partitioning scheme from the source table. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a5b599c793afdd772ef44a4215aa85cf5">create\_projection\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a132bd8471ab7316ece48f4a31f1ea5c2">create\_projection\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a132bd8471ab7316ece48f4a31f1ea5c2">create\_projection\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a6eb04a54ac1088f6155aa32b08de9b5b">create\_projection\_partition\_type</a>: <a href="/content/concepts/tables/#partitioning">Partitioning</a> scheme to use. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a3216960c70be6e192df2f470a8aa5bae">create\_projection\_RANGE</a>: Use <a href="/content/concepts/tables/#partitioning-by-range">range partitioning</a>. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a427d3a288496a1f9d66165dd29516e66">create\_projection\_INTERVAL</a>: Use <a href="/content/concepts/tables/#partitioning-by-interval">interval partitioning</a>. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#af43ed9f3470e4016cea676495c61a359">create\_projection\_LIST</a>: Use <a href="/content/concepts/tables/#partitioning-by-list">list partitioning</a>. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#afa6baa4925929e977219bfd0e5f7f91d">create\_projection\_HASH</a>: Use <a href="/content/concepts/tables/#partitioning-by-hash">hash partitioning</a>. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#adf61b29dfbdf52eb4ab3ff28cb2a7d71">create\_projection\_SERIES</a>: Use <a href="/content/concepts/tables/#partitioning-by-series">series partitioning</a>. </li>
                      </ul>
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#ad9aa7ee48f73a2ddd77bcf4857d38bd4">create\_projection\_partition\_keys</a>: Comma-separated list of partition keys, which are the columns or column expressions by which records will be assigned to partitions defined by <a href="/content/api/cpp/namespacegpudb#a6806df087c3e7bbc50dda81c5a994de5">partition\_definitions</a>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a6806df087c3e7bbc50dda81c5a994de5">create\_projection\_partition\_definitions</a>: Comma-separated list of partition definitions, whose format depends on the choice of <a href="/content/api/cpp/namespacegpudb#a6eb04a54ac1088f6155aa32b08de9b5b">partition\_type</a>. See <a href="/content/concepts/tables/#partitioning-by-range">range partitioning</a>, <a href="/content/concepts/tables/#partitioning-by-interval">interval partitioning</a>, <a href="/content/concepts/tables/#partitioning-by-list">list partitioning</a>, <a href="/content/concepts/tables/#partitioning-by-hash">hash partitioning</a>, or <a href="/content/concepts/tables/#partitioning-by-series">series partitioning</a> for example formats. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ad8503d1127cb5f1ede637a58b112be0b">create\_projection\_is\_automatic\_partition</a>: If <a href="/content/api/cpp/namespacegpudb#a5b599c793afdd772ef44a4215aa85cf5">true</a>, a new partition will be created for values which don't fall into an existing partition. Currently only supported for <a href="/content/concepts/tables/#partitioning-by-list">list partitions</a>. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a5b599c793afdd772ef44a4215aa85cf5">create\_projection\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a132bd8471ab7316ece48f4a31f1ea5c2">create\_projection\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a132bd8471ab7316ece48f4a31f1ea5c2">create\_projection\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a1da4e54de8e2da9144f74c303828fd09">create\_projection\_view\_id</a>: ID of view of which this projection is a member. The default value is ''. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a814c8b268a956eea43b922924515d917">create\_projection\_strategy\_definition</a>: The <a href="/content/rm/concepts/#tier-strategies">tier strategy</a> for the table and its columns. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a2e2df57c85dbedffcc3fc56eb7b909e3">create\_projection\_compression\_codec</a>: The default <a href="/content/concepts/column_compression/">compression codec</a> for the projection's columns. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a51bcd0b84806cb805114dd4d97edf121">create\_projection\_join\_window\_functions</a>: If set, window functions which require a reshard will be computed separately and joined back together, if the width of the projection is greater than the join\_window\_functions\_threshold. The default value is 'true'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a2ce4c6dee31d7f25a2d23bf6be6e5d2a">create\_projection\_join\_window\_functions\_threshold</a>: If the projection is greater than this width (in bytes), then window functions which require a reshard will be computed separately and joined back together. The default value is ''. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a9ad4e698261092bb1f6cc8d10ce3c5f0">create\_projection\_qualify\_filter</a>: An optional filter <a href="/content/concepts/expressions/">expression</a> applied to the projection after window function evaluation, equivalent to a SQL QUALIFY clause. May reference window function aliases as well as any other column in the projection. Rows for which the expression evaluates to false (or NULL) are removed from the projection. The default value is ''. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CreateProjectionResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ab9f111bfe282c4b5f8b1b884f7b89076">◆ </a></span>createProjection() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CreateProjectionResponse">CreateProjectionResponse</a> & gpudb::GPUdb::createProjection </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>projectionName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< std::string > &</td>
            <td><span><span>columnNames</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1CreateProjectionResponse">CreateProjectionResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Creates a new <a href="/content/concepts/projections/">projection</a> of an existing table. </p>
        <p>A projection represents a subset of the columns (potentially including derived columns) of a table.</p>
        <p>For projection details and examples, see <a href="/content/concepts/projections/">Projections</a>. For limitations, see <a href="/content/concepts/projections/#limitations-and-cautions">Projection Limitations and Cautions</a>.</p>
        <p><a href="/content/concepts/window/">Window functions</a>, which can perform operations like moving averages, are available through this endpoint as well as <a href="#a5557e7cbe07004a0f754cf3bb5e5c62b">getRecordsByColumn</a>.</p>
        <p>A projection can be created with a different <a href="/content/concepts/tables/#shard-keys">shard key</a> than the source table. By specifying <a href="/content/api/cpp/namespacegpudb#abea2a2041dabe1a1ae3c209ee1889121">shard\_key</a>, the projection will be sharded according to the specified columns, regardless of how the source table is sharded. The source table can even be unsharded or replicated.</p>
        <p>If <span>tableName</span> is empty, selection is performed against a single-row virtual table. This can be useful in executing temporal (<a href="/content/concepts/expressions/#date-time-functions">NOW()</a>), identity (<a href="/content/concepts/expressions/#user-security-functions">USER()</a>), or constant-based functions (<a href="/content/concepts/expressions/#scalar-functions">GEODIST(-77.11, 38.88, -71.06, 42.36)</a>).</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of the existing table on which the projection is to be applied, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. An empty table name creates a projection from a single-row virtual table, where columns specified should be constants or constant expressions. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>projectionName</td>
                <td>Name of the projection to be created, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a> and meeting <a href="/content/concepts/tables/#table-naming-criteria">table naming criteria</a>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>columnNames</td>
                <td>List of columns from <span>tableName</span> to be included in the projection. Can include derived columns. Can be specified as aliased via the syntax 'column\_name as alias'. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ad323cb8fb4fc766b8764893c2232bd3f">create\_projection\_create\_temp\_table</a>: If <a href="/content/api/cpp/namespacegpudb#a5b599c793afdd772ef44a4215aa85cf5">true</a>, a unique temporary table name will be generated in the sys\_temp schema and used in place of <span>projectionName</span>. If <a href="/content/api/cpp/namespacegpudb#aced0a3481e950bd3c122f71d428e8e03">persist</a> is <a href="/content/api/cpp/namespacegpudb#a132bd8471ab7316ece48f4a31f1ea5c2">false</a> (or unspecified), then this is always allowed even if the caller does not have permission to create tables. The generated name is returned in <a href="/content/api/cpp/namespacegpudb#a70400f2052f2827b35d61e9ced03fa79">qualified\_projection\_name</a>. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a5b599c793afdd772ef44a4215aa85cf5">create\_projection\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a132bd8471ab7316ece48f4a31f1ea5c2">create\_projection\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a132bd8471ab7316ece48f4a31f1ea5c2">create\_projection\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a4b085fdf38a2720aad2dcef61baa782c">create\_projection\_collection\_name</a>: \[DEPRECATED–please specify the containing schema for the projection as part of <span>projectionName</span> and use <a href="#a33d9a0a8e738d14b688f9f869f9640ad">createSchema</a> to create the schema if non-existent] Name of a schema for the projection. If the schema is non-existent, it will be automatically created. The default value is ''. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aa1e7e946d6844a9b7b0b0842ed6f15c2">create\_projection\_expression</a>: An optional filter <a href="/content/concepts/expressions/">expression</a> to be applied to the source table prior to the projection. The default value is ''. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ab815eac2419fe91846599262a0622361">create\_projection\_is\_replicated</a>: If <a href="/content/api/cpp/namespacegpudb#a5b599c793afdd772ef44a4215aa85cf5">true</a> then the projection will be replicated even if the source table is not. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a5b599c793afdd772ef44a4215aa85cf5">create\_projection\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a132bd8471ab7316ece48f4a31f1ea5c2">create\_projection\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a132bd8471ab7316ece48f4a31f1ea5c2">create\_projection\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a8bd2323fce158a53e45ad30b25df61f1">create\_projection\_offset</a>: The number of initial results to skip (this can be useful for paging through the results). The default value is '0'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ab72d73c57be1daea52e642aaac568669">create\_projection\_limit</a>: The number of records to keep. The default value is '-9999'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a6972934c3b3fb28ad51fb2261d40a8a5">create\_projection\_order\_by</a>: Comma-separated list of the columns to be sorted by; e.g. 'timestamp asc, x desc'. The columns specified must be present in <span>columnNames</span>. If any alias is given for any column name, the alias must be used, rather than the original column name. The default value is ''. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aaa43727abcc54776d6386e197de301c0">create\_projection\_chunk\_size</a>: Indicates the number of records per chunk to be used for this projection. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aa313b9efcb5eff6cd9bc04446023f01e">create\_projection\_chunk\_column\_max\_memory</a>: Indicates the target maximum data size for each column in a chunk to be used for this projection. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a1b34b24735000c0dac9a374c1e6cbf4b">create\_projection\_chunk\_max\_memory</a>: Indicates the target maximum data size for all columns in a chunk to be used for this projection. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aeb30765f15c28f2fa32343f25a0b3ca6">create\_projection\_create\_indexes</a>: Comma-separated list of columns on which to create indexes on the projection. The columns specified must be present in <span>columnNames</span>. If any alias is given for any column name, the alias must be used, rather than the original column name. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a4cd2591e02b4dfcdfc1547423bf8bf3c">create\_projection\_ttl</a>: Sets the <a href="/content/concepts/ttl/">TTL</a> of the projection specified in <span>projectionName</span>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#abea2a2041dabe1a1ae3c209ee1889121">create\_projection\_shard\_key</a>: Comma-separated list of the columns to be sharded on; e.g. 'column1, column2'. The columns specified must be present in <span>columnNames</span>. If any alias is given for any column name, the alias must be used, rather than the original column name. The default value is ''. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#aced0a3481e950bd3c122f71d428e8e03">create\_projection\_persist</a>: If <a href="/content/api/cpp/namespacegpudb#a5b599c793afdd772ef44a4215aa85cf5">true</a>, then the projection specified in <span>projectionName</span> will be persisted and will not expire unless a <a href="/content/api/cpp/namespacegpudb#a4cd2591e02b4dfcdfc1547423bf8bf3c">ttl</a> is specified. If <a href="/content/api/cpp/namespacegpudb#a132bd8471ab7316ece48f4a31f1ea5c2">false</a>, then the projection will be an in-memory table and will expire unless a <a href="/content/api/cpp/namespacegpudb#a4cd2591e02b4dfcdfc1547423bf8bf3c">ttl</a> is specified otherwise. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a5b599c793afdd772ef44a4215aa85cf5">create\_projection\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a132bd8471ab7316ece48f4a31f1ea5c2">create\_projection\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a132bd8471ab7316ece48f4a31f1ea5c2">create\_projection\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a9bfd58584a38ba5bd2502f6ebe323553">create\_projection\_preserve\_dict\_encoding</a>: If <a href="/content/api/cpp/namespacegpudb#a5b599c793afdd772ef44a4215aa85cf5">true</a>, then columns that were dict encoded in the source table will be dict encoded in the projection. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a5b599c793afdd772ef44a4215aa85cf5">create\_projection\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a132bd8471ab7316ece48f4a31f1ea5c2">create\_projection\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a5b599c793afdd772ef44a4215aa85cf5">create\_projection\_true</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a0f7a1a2a2f8f7ad907b77a97fbe614d4">create\_projection\_retain\_partitions</a>: Determines whether the created projection will retain the partitioning scheme from the source table. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a5b599c793afdd772ef44a4215aa85cf5">create\_projection\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a132bd8471ab7316ece48f4a31f1ea5c2">create\_projection\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a132bd8471ab7316ece48f4a31f1ea5c2">create\_projection\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a6eb04a54ac1088f6155aa32b08de9b5b">create\_projection\_partition\_type</a>: <a href="/content/concepts/tables/#partitioning">Partitioning</a> scheme to use. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a3216960c70be6e192df2f470a8aa5bae">create\_projection\_RANGE</a>: Use <a href="/content/concepts/tables/#partitioning-by-range">range partitioning</a>. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a427d3a288496a1f9d66165dd29516e66">create\_projection\_INTERVAL</a>: Use <a href="/content/concepts/tables/#partitioning-by-interval">interval partitioning</a>. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#af43ed9f3470e4016cea676495c61a359">create\_projection\_LIST</a>: Use <a href="/content/concepts/tables/#partitioning-by-list">list partitioning</a>. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#afa6baa4925929e977219bfd0e5f7f91d">create\_projection\_HASH</a>: Use <a href="/content/concepts/tables/#partitioning-by-hash">hash partitioning</a>. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#adf61b29dfbdf52eb4ab3ff28cb2a7d71">create\_projection\_SERIES</a>: Use <a href="/content/concepts/tables/#partitioning-by-series">series partitioning</a>. </li>
                      </ul>
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#ad9aa7ee48f73a2ddd77bcf4857d38bd4">create\_projection\_partition\_keys</a>: Comma-separated list of partition keys, which are the columns or column expressions by which records will be assigned to partitions defined by <a href="/content/api/cpp/namespacegpudb#a6806df087c3e7bbc50dda81c5a994de5">partition\_definitions</a>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a6806df087c3e7bbc50dda81c5a994de5">create\_projection\_partition\_definitions</a>: Comma-separated list of partition definitions, whose format depends on the choice of <a href="/content/api/cpp/namespacegpudb#a6eb04a54ac1088f6155aa32b08de9b5b">partition\_type</a>. See <a href="/content/concepts/tables/#partitioning-by-range">range partitioning</a>, <a href="/content/concepts/tables/#partitioning-by-interval">interval partitioning</a>, <a href="/content/concepts/tables/#partitioning-by-list">list partitioning</a>, <a href="/content/concepts/tables/#partitioning-by-hash">hash partitioning</a>, or <a href="/content/concepts/tables/#partitioning-by-series">series partitioning</a> for example formats. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ad8503d1127cb5f1ede637a58b112be0b">create\_projection\_is\_automatic\_partition</a>: If <a href="/content/api/cpp/namespacegpudb#a5b599c793afdd772ef44a4215aa85cf5">true</a>, a new partition will be created for values which don't fall into an existing partition. Currently only supported for <a href="/content/concepts/tables/#partitioning-by-list">list partitions</a>. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a5b599c793afdd772ef44a4215aa85cf5">create\_projection\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a132bd8471ab7316ece48f4a31f1ea5c2">create\_projection\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a132bd8471ab7316ece48f4a31f1ea5c2">create\_projection\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a1da4e54de8e2da9144f74c303828fd09">create\_projection\_view\_id</a>: ID of view of which this projection is a member. The default value is ''. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a814c8b268a956eea43b922924515d917">create\_projection\_strategy\_definition</a>: The <a href="/content/rm/concepts/#tier-strategies">tier strategy</a> for the table and its columns. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a2e2df57c85dbedffcc3fc56eb7b909e3">create\_projection\_compression\_codec</a>: The default <a href="/content/concepts/column_compression/">compression codec</a> for the projection's columns. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a51bcd0b84806cb805114dd4d97edf121">create\_projection\_join\_window\_functions</a>: If set, window functions which require a reshard will be computed separately and joined back together, if the width of the projection is greater than the join\_window\_functions\_threshold. The default value is 'true'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a2ce4c6dee31d7f25a2d23bf6be6e5d2a">create\_projection\_join\_window\_functions\_threshold</a>: If the projection is greater than this width (in bytes), then window functions which require a reshard will be computed separately and joined back together. The default value is ''. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a9ad4e698261092bb1f6cc8d10ce3c5f0">create\_projection\_qualify\_filter</a>: An optional filter <a href="/content/concepts/expressions/">expression</a> applied to the projection after window function evaluation, equivalent to a SQL QUALIFY clause. May reference window function aliases as well as any other column in the projection. Rows for which the expression evaluates to false (or NULL) are removed from the projection. The default value is ''. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CreateProjectionResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CreateProjectionResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a5b9733fe84adc0498c9bf18e758c5eb0">◆ </a></span>createResourceGroup() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CreateResourceGroupResponse">CreateResourceGroupResponse</a> gpudb::GPUdb::createResourceGroup </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1CreateResourceGroupRequest">CreateResourceGroupRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Creates a new resource group to facilitate resource management. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CreateResourceGroupRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CreateResourceGroupResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a3b9a0433110a7726b7574a6728108d97">◆ </a></span>createResourceGroup() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CreateResourceGroupResponse">CreateResourceGroupResponse</a> & gpudb::GPUdb::createResourceGroup </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1CreateResourceGroupRequest">CreateResourceGroupRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1CreateResourceGroupResponse">CreateResourceGroupResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Creates a new resource group to facilitate resource management. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CreateResourceGroupRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CreateResourceGroupResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CreateResourceGroupResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a3243021c43f5f653775767fa3a414806">◆ </a></span>createResourceGroup() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CreateResourceGroupResponse">CreateResourceGroupResponse</a> gpudb::GPUdb::createResourceGroup </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::map\< std::string, std::string > > &</td>
            <td><span><span>tierAttributes</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>ranking</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>adjoiningResourceGroup</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Creates a new resource group to facilitate resource management. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>name</td>
                <td>Name of the group to be created. Must contain only letters, digits, and underscores, and cannot begin with a digit. Must not match existing resource group name. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>tierAttributes</td>

                <td>
                  Optional map containing tier names and their respective attribute group limits. The only valid attribute limit that can be set is max\_memory (in bytes) for the VRAM and RAM tiers. For instance, to set max VRAM capacity to 1GB per rank per GPU and max RAM capacity to 10GB per rank, use: 'VRAM':'max\_memory':'1000000000', 'RAM':'max\_memory':'10000000000'.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a46256c5b2b7d17f82d34d56aa2eb63a6">create\_resource\_group\_max\_memory</a>: Maximum amount of memory usable at one time, per rank, per GPU, for the VRAM tier; or maximum amount of memory usable at one time, per rank, for the RAM tier. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>ranking</td>

                <td>
                  Indicates the relative ranking among existing resource groups where this new resource group will be placed. Supported values:

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#ac5bb1528b1a84c729473792fb5af64a5">create\_resource\_group\_first</a>: Make this resource group the new first one in the ordering. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#abf91eedff3c72004de21ee001e9c49bc">create\_resource\_group\_last</a>: Make this resource group the new last one in the ordering. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a2e6ea8bae76e6ecdaf1bc66875aed809">create\_resource\_group\_before</a>: Place this resource group before the one specified by <span>adjoiningResourceGroup</span> in the ordering. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a10613cdce7c914801d14867748404ce4">create\_resource\_group\_after</a>: Place this resource group after the one specified by <span>adjoiningResourceGroup</span> in the ordering. </li>
                  </ul>
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>adjoiningResourceGroup</td>
                <td>If <span>ranking</span> is <a href="/content/api/cpp/namespacegpudb#a2e6ea8bae76e6ecdaf1bc66875aed809">before</a> or <a href="/content/api/cpp/namespacegpudb#a10613cdce7c914801d14867748404ce4">after</a>, this field indicates the resource group before or after which the current group will be placed; otherwise, leave blank. The default value is ''. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a6e5ec8607af26c730ee8a7744f387e0c">create\_resource\_group\_max\_cpu\_concurrency</a>: Maximum number of simultaneous threads that will be used to execute a request, per rank, for this group. The minimum allowed value is '4'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ada60c2354d13090e5faa68c13b1eff6f">create\_resource\_group\_max\_data</a>: Maximum amount of data, per rank, in bytes, that can be used by all database objects within this group. Set to -1 to indicate no upper limit. The minimum allowed value is '-1'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a23adc70a319623ac82546966068d1701">create\_resource\_group\_max\_scheduling\_priority</a>: Maximum priority of a scheduled task for this group. The minimum allowed value is '1'. The maximum allowed value is '100'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a9693f7ca4fc7bc1e426f5a13288fec6c">create\_resource\_group\_max\_tier\_priority</a>: Maximum priority of a tiered object for this group. The minimum allowed value is '1'. The maximum allowed value is '10'. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CreateResourceGroupResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a03a662f7205c9d7c01770e81b8049fa2">◆ </a></span>createResourceGroup() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CreateResourceGroupResponse">CreateResourceGroupResponse</a> & gpudb::GPUdb::createResourceGroup </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::map\< std::string, std::string > > &</td>
            <td><span><span>tierAttributes</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>ranking</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>adjoiningResourceGroup</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1CreateResourceGroupResponse">CreateResourceGroupResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Creates a new resource group to facilitate resource management. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>name</td>
                <td>Name of the group to be created. Must contain only letters, digits, and underscores, and cannot begin with a digit. Must not match existing resource group name. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>tierAttributes</td>

                <td>
                  Optional map containing tier names and their respective attribute group limits. The only valid attribute limit that can be set is max\_memory (in bytes) for the VRAM and RAM tiers. For instance, to set max VRAM capacity to 1GB per rank per GPU and max RAM capacity to 10GB per rank, use: 'VRAM':'max\_memory':'1000000000', 'RAM':'max\_memory':'10000000000'.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a46256c5b2b7d17f82d34d56aa2eb63a6">create\_resource\_group\_max\_memory</a>: Maximum amount of memory usable at one time, per rank, per GPU, for the VRAM tier; or maximum amount of memory usable at one time, per rank, for the RAM tier. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>ranking</td>

                <td>
                  Indicates the relative ranking among existing resource groups where this new resource group will be placed. Supported values:

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#ac5bb1528b1a84c729473792fb5af64a5">create\_resource\_group\_first</a>: Make this resource group the new first one in the ordering. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#abf91eedff3c72004de21ee001e9c49bc">create\_resource\_group\_last</a>: Make this resource group the new last one in the ordering. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a2e6ea8bae76e6ecdaf1bc66875aed809">create\_resource\_group\_before</a>: Place this resource group before the one specified by <span>adjoiningResourceGroup</span> in the ordering. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a10613cdce7c914801d14867748404ce4">create\_resource\_group\_after</a>: Place this resource group after the one specified by <span>adjoiningResourceGroup</span> in the ordering. </li>
                  </ul>
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>adjoiningResourceGroup</td>
                <td>If <span>ranking</span> is <a href="/content/api/cpp/namespacegpudb#a2e6ea8bae76e6ecdaf1bc66875aed809">before</a> or <a href="/content/api/cpp/namespacegpudb#a10613cdce7c914801d14867748404ce4">after</a>, this field indicates the resource group before or after which the current group will be placed; otherwise, leave blank. The default value is ''. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a6e5ec8607af26c730ee8a7744f387e0c">create\_resource\_group\_max\_cpu\_concurrency</a>: Maximum number of simultaneous threads that will be used to execute a request, per rank, for this group. The minimum allowed value is '4'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ada60c2354d13090e5faa68c13b1eff6f">create\_resource\_group\_max\_data</a>: Maximum amount of data, per rank, in bytes, that can be used by all database objects within this group. Set to -1 to indicate no upper limit. The minimum allowed value is '-1'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a23adc70a319623ac82546966068d1701">create\_resource\_group\_max\_scheduling\_priority</a>: Maximum priority of a scheduled task for this group. The minimum allowed value is '1'. The maximum allowed value is '100'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a9693f7ca4fc7bc1e426f5a13288fec6c">create\_resource\_group\_max\_tier\_priority</a>: Maximum priority of a tiered object for this group. The minimum allowed value is '1'. The maximum allowed value is '10'. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CreateResourceGroupResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CreateResourceGroupResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a11c8fcda3ebbb876681b3b9f20e23a3c">◆ </a></span>createRole() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CreateRoleResponse">CreateRoleResponse</a> gpudb::GPUdb::createRole </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1CreateRoleRequest">CreateRoleRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Creates a new role. </p>

        <div>
          <div>Attention</div>
          <div>This method should be used for on-premise deployments only.</div>
        </div>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CreateRoleRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CreateRoleResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a9ef4609997fc3c545e985ba94bcefd26">◆ </a></span>createRole() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CreateRoleResponse">CreateRoleResponse</a> & gpudb::GPUdb::createRole </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1CreateRoleRequest">CreateRoleRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1CreateRoleResponse">CreateRoleResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Creates a new role. </p>

        <div>
          <div>Attention</div>
          <div>This method should be used for on-premise deployments only.</div>
        </div>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CreateRoleRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CreateRoleResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CreateRoleResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a5c25be98b6d00d03bc94841dcc1ee348">◆ </a></span>createRole() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CreateRoleResponse">CreateRoleResponse</a> gpudb::GPUdb::createRole </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Creates a new role. </p>

        <div>
          <div>Attention</div>
          <div>This method should be used for on-premise deployments only.</div>
        </div>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>name</td>
                <td>Name of the role to be created. Must contain only lowercase letters, digits, and underscores, and cannot begin with a digit. Must not be the same name as an existing user or role. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#abad782c584538b4c7792f3f92a9e834a">create\_role\_resource\_group</a>: Name of an existing resource group to associate with this user. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CreateRoleResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a9d6dd4b8f0c54db178d24393ba674a8e">◆ </a></span>createRole() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CreateRoleResponse">CreateRoleResponse</a> & gpudb::GPUdb::createRole </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1CreateRoleResponse">CreateRoleResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Creates a new role. </p>

        <div>
          <div>Attention</div>
          <div>This method should be used for on-premise deployments only.</div>
        </div>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>name</td>
                <td>Name of the role to be created. Must contain only lowercase letters, digits, and underscores, and cannot begin with a digit. Must not be the same name as an existing user or role. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#abad782c584538b4c7792f3f92a9e834a">create\_role\_resource\_group</a>: Name of an existing resource group to associate with this user. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CreateRoleResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CreateRoleResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a4aa5990ebebfab30b5961654f546cfd0">◆ </a></span>createSchema() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CreateSchemaResponse">CreateSchemaResponse</a> gpudb::GPUdb::createSchema </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1CreateSchemaRequest">CreateSchemaRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Creates a SQL-style <a href="/content/concepts/schemas/">schema</a>. </p>
        <p>Schemas are containers for tables and views. Multiple tables and views can be defined with the same name in different schemas.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CreateSchemaRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CreateSchemaResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a38d46d66b880642f20a0c166aa4c2b15">◆ </a></span>createSchema() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CreateSchemaResponse">CreateSchemaResponse</a> & gpudb::GPUdb::createSchema </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1CreateSchemaRequest">CreateSchemaRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1CreateSchemaResponse">CreateSchemaResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Creates a SQL-style <a href="/content/concepts/schemas/">schema</a>. </p>
        <p>Schemas are containers for tables and views. Multiple tables and views can be defined with the same name in different schemas.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CreateSchemaRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CreateSchemaResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CreateSchemaResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a33d9a0a8e738d14b688f9f869f9640ad">◆ </a></span>createSchema() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CreateSchemaResponse">CreateSchemaResponse</a> gpudb::GPUdb::createSchema </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>schemaName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Creates a SQL-style <a href="/content/concepts/schemas/">schema</a>. </p>
        <p>Schemas are containers for tables and views. Multiple tables and views can be defined with the same name in different schemas.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>schemaName</td>
                <td>Name of the schema to be created. Has the same naming restrictions as <a href="/content/concepts/tables/">tables</a>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a97e7aa79ac96ea0e2461f3a66ac187eb">create\_schema\_no\_error\_if\_exists</a>: If <a href="/content/api/cpp/namespacegpudb#a6ce6815b864986239b8d5505d12e5e8d">true</a>, prevents an error from occurring if the schema already exists. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a6ce6815b864986239b8d5505d12e5e8d">create\_schema\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a685381bd913b0b3d0d43411d115843d0">create\_schema\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a685381bd913b0b3d0d43411d115843d0">create\_schema\_false</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CreateSchemaResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ae91be6d23881ea7ef324a60ca65cd529">◆ </a></span>createSchema() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CreateSchemaResponse">CreateSchemaResponse</a> & gpudb::GPUdb::createSchema </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>schemaName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1CreateSchemaResponse">CreateSchemaResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Creates a SQL-style <a href="/content/concepts/schemas/">schema</a>. </p>
        <p>Schemas are containers for tables and views. Multiple tables and views can be defined with the same name in different schemas.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>schemaName</td>
                <td>Name of the schema to be created. Has the same naming restrictions as <a href="/content/concepts/tables/">tables</a>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a97e7aa79ac96ea0e2461f3a66ac187eb">create\_schema\_no\_error\_if\_exists</a>: If <a href="/content/api/cpp/namespacegpudb#a6ce6815b864986239b8d5505d12e5e8d">true</a>, prevents an error from occurring if the schema already exists. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a6ce6815b864986239b8d5505d12e5e8d">create\_schema\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a685381bd913b0b3d0d43411d115843d0">create\_schema\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a685381bd913b0b3d0d43411d115843d0">create\_schema\_false</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CreateSchemaResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CreateSchemaResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a827d2d54888b00d0dcc69599325de9cf">◆ </a></span>createTable() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CreateTableResponse">CreateTableResponse</a> gpudb::GPUdb::createTable </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1CreateTableRequest">CreateTableRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Creates a new table with the given type (definition of columns). </p>
        <p>The type is specified in <a href="/content/api/cpp/structgpudb_1_1CreateTableRequest#a0352e9c8a05a6b02fd1676ecfb5f10f3">typeId</a> as either a numerical type ID (as returned by <a href="#abaf7eca0d3c131b8fede4850d51f1a1a">createType</a>) or as a list of columns, each specified as a list of the column name, data type, and any column attributes.</p>
        <p>Example of a type definition with some parameters: </p>

        <div>
          <div>\[</div>
          <div> \[<span>"id"</span>, <span>"int8"</span>, <span>"primary\_key"</span>],</div>
          <div> \[<span>"dept\_id"</span>, <span>"int8"</span>, <span>"primary\_key"</span>, <span>"shard\_key"</span>],</div>
          <div> \[<span>"manager\_id"</span>, <span>"int8"</span>, <span>"nullable"</span>],</div>
          <div> \[<span>"first\_name"</span>, <span>"char32"</span>],</div>
          <div> \[<span>"last\_name"</span>, <span>"char64"</span>],</div>
          <div> \[<span>"salary"</span>, <span>"decimal"</span>],</div>
          <div> \[<span>"hire\_date"</span>, <span>"date"</span>]</div>
          <div>]</div>
        </div>

        <p> Each column definition consists of the column name (which should meet the standard <a href="/content/concepts/tables/#table-naming-criteria">column naming criteria</a>), the column's <a href="/content/concepts/types/#types-chart">specific type</a> (int, long, float, double, string, bytes, or any of the properties map values from <a href="#abaf7eca0d3c131b8fede4850d51f1a1a">createType</a>), and any <a href="/content/concepts/types/#types-data-handling">data handling</a>, <a href="/content/concepts/types/#types-data-keys">data key</a>, or <a href="/content/concepts/types/#types-data-replace">data replacement</a> properties.</p>
        <p>A table may optionally be designated to use a <a href="/content/concepts/tables/#replication">replicated</a> distribution scheme, or be assigned: <a href="/content/concepts/tables/#foreign-keys">foreign keys</a> to other tables, a <a href="/content/concepts/tables/#partitioning">partitioning</a> scheme, and/or a <a href="/content/rm/concepts/#tier-strategies">tier strategy</a>.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CreateTableRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CreateTableResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#aeb94f06a20fe34915cefb268e375bb64">◆ </a></span>createTable() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CreateTableResponse">CreateTableResponse</a> & gpudb::GPUdb::createTable </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1CreateTableRequest">CreateTableRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1CreateTableResponse">CreateTableResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Creates a new table with the given type (definition of columns). </p>
        <p>The type is specified in <a href="/content/api/cpp/structgpudb_1_1CreateTableRequest#a0352e9c8a05a6b02fd1676ecfb5f10f3">typeId</a> as either a numerical type ID (as returned by <a href="#abaf7eca0d3c131b8fede4850d51f1a1a">createType</a>) or as a list of columns, each specified as a list of the column name, data type, and any column attributes.</p>
        <p>Example of a type definition with some parameters: </p>

        <div>
          <div>\[</div>
          <div> \[<span>"id"</span>, <span>"int8"</span>, <span>"primary\_key"</span>],</div>
          <div> \[<span>"dept\_id"</span>, <span>"int8"</span>, <span>"primary\_key"</span>, <span>"shard\_key"</span>],</div>
          <div> \[<span>"manager\_id"</span>, <span>"int8"</span>, <span>"nullable"</span>],</div>
          <div> \[<span>"first\_name"</span>, <span>"char32"</span>],</div>
          <div> \[<span>"last\_name"</span>, <span>"char64"</span>],</div>
          <div> \[<span>"salary"</span>, <span>"decimal"</span>],</div>
          <div> \[<span>"hire\_date"</span>, <span>"date"</span>]</div>
          <div>]</div>
        </div>

        <p> Each column definition consists of the column name (which should meet the standard <a href="/content/concepts/tables/#table-naming-criteria">column naming criteria</a>), the column's <a href="/content/concepts/types/#types-chart">specific type</a> (int, long, float, double, string, bytes, or any of the properties map values from <a href="#abaf7eca0d3c131b8fede4850d51f1a1a">createType</a>), and any <a href="/content/concepts/types/#types-data-handling">data handling</a>, <a href="/content/concepts/types/#types-data-keys">data key</a>, or <a href="/content/concepts/types/#types-data-replace">data replacement</a> properties.</p>
        <p>A table may optionally be designated to use a <a href="/content/concepts/tables/#replication">replicated</a> distribution scheme, or be assigned: <a href="/content/concepts/tables/#foreign-keys">foreign keys</a> to other tables, a <a href="/content/concepts/tables/#partitioning">partitioning</a> scheme, and/or a <a href="/content/rm/concepts/#tier-strategies">tier strategy</a>.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CreateTableRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CreateTableResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CreateTableResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#afa4ded9fdb07b49b4b1cb0835b5ac52a">◆ </a></span>createTable() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CreateTableResponse">CreateTableResponse</a> gpudb::GPUdb::createTable </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>typeId</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Creates a new table with the given type (definition of columns). </p>
        <p>The type is specified in <span>typeId</span> as either a numerical type ID (as returned by <a href="#a1698840c08d7212878c9c1dac3f94cfc">createType</a>) or as a list of columns, each specified as a list of the column name, data type, and any column attributes.</p>
        <p>Example of a type definition with some parameters: </p>

        <div>
          <div>\[</div>
          <div> \[<span>"id"</span>, <span>"int8"</span>, <span>"primary\_key"</span>],</div>
          <div> \[<span>"dept\_id"</span>, <span>"int8"</span>, <span>"primary\_key"</span>, <span>"shard\_key"</span>],</div>
          <div> \[<span>"manager\_id"</span>, <span>"int8"</span>, <span>"nullable"</span>],</div>
          <div> \[<span>"first\_name"</span>, <span>"char32"</span>],</div>
          <div> \[<span>"last\_name"</span>, <span>"char64"</span>],</div>
          <div> \[<span>"salary"</span>, <span>"decimal"</span>],</div>
          <div> \[<span>"hire\_date"</span>, <span>"date"</span>]</div>
          <div>]</div>
        </div>

        <p> Each column definition consists of the column name (which should meet the standard <a href="/content/concepts/tables/#table-naming-criteria">column naming criteria</a>), the column's <a href="/content/concepts/types/#types-chart">specific type</a> (int, long, float, double, string, bytes, or any of the properties map values from <a href="#a1698840c08d7212878c9c1dac3f94cfc">createType</a>), and any <a href="/content/concepts/types/#types-data-handling">data handling</a>, <a href="/content/concepts/types/#types-data-keys">data key</a>, or <a href="/content/concepts/types/#types-data-replace">data replacement</a> properties.</p>
        <p>A table may optionally be designated to use a <a href="/content/concepts/tables/#replication">replicated</a> distribution scheme, or be assigned: <a href="/content/concepts/tables/#foreign-keys">foreign keys</a> to other tables, a <a href="/content/concepts/tables/#partitioning">partitioning</a> scheme, and/or a <a href="/content/rm/concepts/#tier-strategies">tier strategy</a>.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of the table to be created, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a> and meeting <a href="/content/concepts/tables/#table-naming-criteria">table naming criteria</a>. Error for requests with existing table of the same name and type ID may be suppressed by using the <a href="/content/api/cpp/namespacegpudb#a445fe2911b822623e6b26c0f61582cb0">no\_error\_if\_exists</a> option. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>typeId</td>
                <td>The type for the table, specified as either an existing table's numerical type ID (as returned by <a href="#a1698840c08d7212878c9c1dac3f94cfc">createType</a>) or a type definition (as described above). </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a445fe2911b822623e6b26c0f61582cb0">create\_table\_no\_error\_if\_exists</a>: If <a href="/content/api/cpp/namespacegpudb#a68723d817c882f8faad2f766b8c7e257">true</a>, prevents an error from occurring if the table already exists and is of the given type. If a table with the same ID but a different type exists, it is still an error. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a68723d817c882f8faad2f766b8c7e257">create\_table\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ab17cfbe49f1596f55781f32a5872bfc1">create\_table\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ab17cfbe49f1596f55781f32a5872bfc1">create\_table\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a75e7a9939c2083b76dba6b1528fbf632">create\_table\_create\_temp\_table</a>: If <a href="/content/api/cpp/namespacegpudb#a68723d817c882f8faad2f766b8c7e257">true</a>, a unique temporary table name will be generated in the sys\_temp schema and used in place of <span>tableName</span>. If <a href="/content/api/cpp/namespacegpudb#a2a26ae1a59d1e4bf8198e9b14ced4206">is\_result\_table</a> is <a href="/content/api/cpp/namespacegpudb#a68723d817c882f8faad2f766b8c7e257">true</a>, then this is always allowed even if the caller does not have permission to create tables. The generated name is returned in <a href="/content/api/cpp/namespacegpudb#a796ca8a225bfd583d58ff4becbd2783b">qualified\_table\_name</a>. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a68723d817c882f8faad2f766b8c7e257">create\_table\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ab17cfbe49f1596f55781f32a5872bfc1">create\_table\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ab17cfbe49f1596f55781f32a5872bfc1">create\_table\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a320af8dc09625175c60c4323dce04a21">create\_table\_collection\_name</a>: \[DEPRECATED–please specify the containing schema as part of <span>tableName</span> and use <a href="#a33d9a0a8e738d14b688f9f869f9640ad">createSchema</a> to create the schema if non-existent] Name of a schema which is to contain the newly created table. If the schema is non-existent, it will be automatically created. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ad9b9d5b641d939c630d101617a4a797a">create\_table\_is\_collection</a>: \[DEPRECATED–please use <a href="#a33d9a0a8e738d14b688f9f869f9640ad">createSchema</a> to create a schema instead] Indicates whether to create a schema instead of a table. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a68723d817c882f8faad2f766b8c7e257">create\_table\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ab17cfbe49f1596f55781f32a5872bfc1">create\_table\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ab17cfbe49f1596f55781f32a5872bfc1">create\_table\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a7104ca5c6ded54736e509ced7321de4c">create\_table\_is\_replicated</a>: Affects the <a href="/content/concepts/tables/#distribution">distribution scheme</a> for the table's data. If <a href="/content/api/cpp/namespacegpudb#a68723d817c882f8faad2f766b8c7e257">true</a> and the given type has no explicit <a href="/content/concepts/tables/#shard-key">shard key</a> defined, the table will be <a href="/content/concepts/tables/#replication">replicated</a>. If <a href="/content/api/cpp/namespacegpudb#ab17cfbe49f1596f55781f32a5872bfc1">false</a>, the table will be <a href="/content/concepts/tables/#sharding">sharded</a> according to the shard key specified in the given <span>typeId</span>, or <a href="/content/concepts/tables/#random-sharding">randomly sharded</a>, if no shard key is specified. Note that a type containing a shard key cannot be used to create a replicated table. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a68723d817c882f8faad2f766b8c7e257">create\_table\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ab17cfbe49f1596f55781f32a5872bfc1">create\_table\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ab17cfbe49f1596f55781f32a5872bfc1">create\_table\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a3f4810f9b5ac72ce020838ad7ae1fa7b">create\_table\_foreign\_keys</a>: Semicolon-separated list of <a href="/content/concepts/tables/#foreign-keys">foreign keys</a>, of the format '(source\_column\_name \[, ...]) references target\_table\_name(primary\_key\_column\_name \[, ...]) \[as foreign\_key\_name]'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ad4682bfc3b6e98ce320f1744ed4ebfc2">create\_table\_foreign\_shard\_key</a>: Foreign shard key of the format 'source\_column references shard\_by\_column from target\_table(primary\_key\_column)'. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a5f288dbab3fe8010bc8b26745edbfaf5">create\_table\_partition\_type</a>: <a href="/content/concepts/tables/#partitioning">Partitioning</a> scheme to use. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#aac595de77c6941518b867c5eb4bc8e09">create\_table\_RANGE</a>: Use <a href="/content/concepts/tables/#partitioning-by-range">range partitioning</a>. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a24db8d104d04c4d5da62b8daccfd3d66">create\_table\_INTERVAL</a>: Use <a href="/content/concepts/tables/#partitioning-by-interval">interval partitioning</a>. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aa220da05672544f5968b40143c155b41">create\_table\_LIST</a>: Use <a href="/content/concepts/tables/#partitioning-by-list">list partitioning</a>. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a31d7cab03373e8c7f89cdcee2d333775">create\_table\_HASH</a>: Use <a href="/content/concepts/tables/#partitioning-by-hash">hash partitioning</a>. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aed61431bd9e0877bf37d4939d86128fb">create\_table\_SERIES</a>: Use <a href="/content/concepts/tables/#partitioning-by-series">series partitioning</a>. </li>
                      </ul>
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#acf1547f910bed470a4ea76dde79ffd97">create\_table\_partition\_keys</a>: Comma-separated list of partition keys, which are the columns or column expressions by which records will be assigned to partitions defined by <a href="/content/api/cpp/namespacegpudb#a62f22ffeb7adf9117dacf811916cb850">partition\_definitions</a>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a62f22ffeb7adf9117dacf811916cb850">create\_table\_partition\_definitions</a>: Comma-separated list of partition definitions, whose format depends on the choice of <a href="/content/api/cpp/namespacegpudb#a5f288dbab3fe8010bc8b26745edbfaf5">partition\_type</a>. See <a href="/content/concepts/tables/#partitioning-by-range">range partitioning</a>, <a href="/content/concepts/tables/#partitioning-by-interval">interval partitioning</a>, <a href="/content/concepts/tables/#partitioning-by-list">list partitioning</a>, <a href="/content/concepts/tables/#partitioning-by-hash">hash partitioning</a>, or <a href="/content/concepts/tables/#partitioning-by-series">series partitioning</a> for example formats. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a43cb4aab1169616535d36a3a7180c40c">create\_table\_is\_automatic\_partition</a>: If <a href="/content/api/cpp/namespacegpudb#a68723d817c882f8faad2f766b8c7e257">true</a>, a new partition will be created for values which don't fall into an existing partition. Currently only supported for <a href="/content/concepts/tables/#partitioning-by-list">list partitions</a>. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a68723d817c882f8faad2f766b8c7e257">create\_table\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ab17cfbe49f1596f55781f32a5872bfc1">create\_table\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ab17cfbe49f1596f55781f32a5872bfc1">create\_table\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#af49995b11df0dfc22a4b090943ec5079">create\_table\_ttl</a>: Sets the <a href="/content/concepts/ttl/">TTL</a> of the table specified in <span>tableName</span>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ab456675e6c896b874d3337e8cd986fac">create\_table\_chunk\_size</a>: Indicates the number of records per chunk to be used for this table. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#acdfeaeb456bc0e07d2d70e78f0cedb87">create\_table\_chunk\_column\_max\_memory</a>: Indicates the target maximum data size for each column in a chunk to be used for this table. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a4f013c37bc4c582d105041a915e3a749">create\_table\_chunk\_max\_memory</a>: Indicates the target maximum data size for all columns in a chunk to be used for this table. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a2a26ae1a59d1e4bf8198e9b14ced4206">create\_table\_is\_result\_table</a>: Indicates whether the table is a <a href="/content/concepts/tables_memory_only/">memory-only table</a>. A result table cannot contain columns with text\_search <a href="/content/concepts/types/#data-handling">data-handling</a>, and it will not be retained if the server is restarted. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a68723d817c882f8faad2f766b8c7e257">create\_table\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ab17cfbe49f1596f55781f32a5872bfc1">create\_table\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ab17cfbe49f1596f55781f32a5872bfc1">create\_table\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#af71f5faa5ea865bbc6779651c3cf10b7">create\_table\_strategy\_definition</a>: The <a href="/content/rm/concepts/#tier-strategies">tier strategy</a> for the table and its columns. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ac5fbcd23a4aea42bc696d4c2a1f7cd2f">create\_table\_compression\_codec</a>: The default <a href="/content/concepts/column_compression/">compression codec</a> for this table's columns. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a4cda2a25a7f3eeb83b863d37cd1f25ad">create\_table\_load\_vectors\_policy</a>: Set startup data loading scheme for the table. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad317bb7b1a5ed5b3c3a0b1e8107ff267">create\_table\_always</a>: Load as much vector data as possible into memory before accepting requests. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a4401fcef8c5e17e1a2b6b89f211873f5">create\_table\_lazy</a>: Load the necessary vector data at start, and load the remainder lazily. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a216b642aff207bee5303342b3b702e00">create\_table\_on\_demand</a>: Load vector data as requests use it. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a96651b624b201e35d2463e0ecde8a776">create\_table\_system</a>: Load vector data using the system-configured default. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a96651b624b201e35d2463e0ecde8a776">create\_table\_system</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ad7001f1b36ac610de60739dcf78cf729">create\_table\_build\_pk\_index\_policy</a>: Set startup primary-key index generation scheme for the table. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad317bb7b1a5ed5b3c3a0b1e8107ff267">create\_table\_always</a>: Generate as much primary key index data as possible before accepting requests. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a4401fcef8c5e17e1a2b6b89f211873f5">create\_table\_lazy</a>: Generate the necessary primary key index data at start, and load the remainder lazily. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a216b642aff207bee5303342b3b702e00">create\_table\_on\_demand</a>: Generate primary key index data as requests use it. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a96651b624b201e35d2463e0ecde8a776">create\_table\_system</a>: Generate primary key index data using the system-configured default. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a96651b624b201e35d2463e0ecde8a776">create\_table\_system</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CreateTableResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a98dd73575fa84c4fa69a05a89ea9a612">◆ </a></span>createTable() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CreateTableResponse">CreateTableResponse</a> & gpudb::GPUdb::createTable </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>typeId</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1CreateTableResponse">CreateTableResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Creates a new table with the given type (definition of columns). </p>
        <p>The type is specified in <span>typeId</span> as either a numerical type ID (as returned by <a href="#a1698840c08d7212878c9c1dac3f94cfc">createType</a>) or as a list of columns, each specified as a list of the column name, data type, and any column attributes.</p>
        <p>Example of a type definition with some parameters: </p>

        <div>
          <div>\[</div>
          <div> \[<span>"id"</span>, <span>"int8"</span>, <span>"primary\_key"</span>],</div>
          <div> \[<span>"dept\_id"</span>, <span>"int8"</span>, <span>"primary\_key"</span>, <span>"shard\_key"</span>],</div>
          <div> \[<span>"manager\_id"</span>, <span>"int8"</span>, <span>"nullable"</span>],</div>
          <div> \[<span>"first\_name"</span>, <span>"char32"</span>],</div>
          <div> \[<span>"last\_name"</span>, <span>"char64"</span>],</div>
          <div> \[<span>"salary"</span>, <span>"decimal"</span>],</div>
          <div> \[<span>"hire\_date"</span>, <span>"date"</span>]</div>
          <div>]</div>
        </div>

        <p> Each column definition consists of the column name (which should meet the standard <a href="/content/concepts/tables/#table-naming-criteria">column naming criteria</a>), the column's <a href="/content/concepts/types/#types-chart">specific type</a> (int, long, float, double, string, bytes, or any of the properties map values from <a href="#a1698840c08d7212878c9c1dac3f94cfc">createType</a>), and any <a href="/content/concepts/types/#types-data-handling">data handling</a>, <a href="/content/concepts/types/#types-data-keys">data key</a>, or <a href="/content/concepts/types/#types-data-replace">data replacement</a> properties.</p>
        <p>A table may optionally be designated to use a <a href="/content/concepts/tables/#replication">replicated</a> distribution scheme, or be assigned: <a href="/content/concepts/tables/#foreign-keys">foreign keys</a> to other tables, a <a href="/content/concepts/tables/#partitioning">partitioning</a> scheme, and/or a <a href="/content/rm/concepts/#tier-strategies">tier strategy</a>.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of the table to be created, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a> and meeting <a href="/content/concepts/tables/#table-naming-criteria">table naming criteria</a>. Error for requests with existing table of the same name and type ID may be suppressed by using the <a href="/content/api/cpp/namespacegpudb#a445fe2911b822623e6b26c0f61582cb0">no\_error\_if\_exists</a> option. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>typeId</td>
                <td>The type for the table, specified as either an existing table's numerical type ID (as returned by <a href="#a1698840c08d7212878c9c1dac3f94cfc">createType</a>) or a type definition (as described above). </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a445fe2911b822623e6b26c0f61582cb0">create\_table\_no\_error\_if\_exists</a>: If <a href="/content/api/cpp/namespacegpudb#a68723d817c882f8faad2f766b8c7e257">true</a>, prevents an error from occurring if the table already exists and is of the given type. If a table with the same ID but a different type exists, it is still an error. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a68723d817c882f8faad2f766b8c7e257">create\_table\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ab17cfbe49f1596f55781f32a5872bfc1">create\_table\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ab17cfbe49f1596f55781f32a5872bfc1">create\_table\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a75e7a9939c2083b76dba6b1528fbf632">create\_table\_create\_temp\_table</a>: If <a href="/content/api/cpp/namespacegpudb#a68723d817c882f8faad2f766b8c7e257">true</a>, a unique temporary table name will be generated in the sys\_temp schema and used in place of <span>tableName</span>. If <a href="/content/api/cpp/namespacegpudb#a2a26ae1a59d1e4bf8198e9b14ced4206">is\_result\_table</a> is <a href="/content/api/cpp/namespacegpudb#a68723d817c882f8faad2f766b8c7e257">true</a>, then this is always allowed even if the caller does not have permission to create tables. The generated name is returned in <a href="/content/api/cpp/namespacegpudb#a796ca8a225bfd583d58ff4becbd2783b">qualified\_table\_name</a>. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a68723d817c882f8faad2f766b8c7e257">create\_table\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ab17cfbe49f1596f55781f32a5872bfc1">create\_table\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ab17cfbe49f1596f55781f32a5872bfc1">create\_table\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a320af8dc09625175c60c4323dce04a21">create\_table\_collection\_name</a>: \[DEPRECATED–please specify the containing schema as part of <span>tableName</span> and use <a href="#a33d9a0a8e738d14b688f9f869f9640ad">createSchema</a> to create the schema if non-existent] Name of a schema which is to contain the newly created table. If the schema is non-existent, it will be automatically created. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ad9b9d5b641d939c630d101617a4a797a">create\_table\_is\_collection</a>: \[DEPRECATED–please use <a href="#a33d9a0a8e738d14b688f9f869f9640ad">createSchema</a> to create a schema instead] Indicates whether to create a schema instead of a table. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a68723d817c882f8faad2f766b8c7e257">create\_table\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ab17cfbe49f1596f55781f32a5872bfc1">create\_table\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ab17cfbe49f1596f55781f32a5872bfc1">create\_table\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a7104ca5c6ded54736e509ced7321de4c">create\_table\_is\_replicated</a>: Affects the <a href="/content/concepts/tables/#distribution">distribution scheme</a> for the table's data. If <a href="/content/api/cpp/namespacegpudb#a68723d817c882f8faad2f766b8c7e257">true</a> and the given type has no explicit <a href="/content/concepts/tables/#shard-key">shard key</a> defined, the table will be <a href="/content/concepts/tables/#replication">replicated</a>. If <a href="/content/api/cpp/namespacegpudb#ab17cfbe49f1596f55781f32a5872bfc1">false</a>, the table will be <a href="/content/concepts/tables/#sharding">sharded</a> according to the shard key specified in the given <span>typeId</span>, or <a href="/content/concepts/tables/#random-sharding">randomly sharded</a>, if no shard key is specified. Note that a type containing a shard key cannot be used to create a replicated table. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a68723d817c882f8faad2f766b8c7e257">create\_table\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ab17cfbe49f1596f55781f32a5872bfc1">create\_table\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ab17cfbe49f1596f55781f32a5872bfc1">create\_table\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a3f4810f9b5ac72ce020838ad7ae1fa7b">create\_table\_foreign\_keys</a>: Semicolon-separated list of <a href="/content/concepts/tables/#foreign-keys">foreign keys</a>, of the format '(source\_column\_name \[, ...]) references target\_table\_name(primary\_key\_column\_name \[, ...]) \[as foreign\_key\_name]'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ad4682bfc3b6e98ce320f1744ed4ebfc2">create\_table\_foreign\_shard\_key</a>: Foreign shard key of the format 'source\_column references shard\_by\_column from target\_table(primary\_key\_column)'. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a5f288dbab3fe8010bc8b26745edbfaf5">create\_table\_partition\_type</a>: <a href="/content/concepts/tables/#partitioning">Partitioning</a> scheme to use. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#aac595de77c6941518b867c5eb4bc8e09">create\_table\_RANGE</a>: Use <a href="/content/concepts/tables/#partitioning-by-range">range partitioning</a>. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a24db8d104d04c4d5da62b8daccfd3d66">create\_table\_INTERVAL</a>: Use <a href="/content/concepts/tables/#partitioning-by-interval">interval partitioning</a>. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aa220da05672544f5968b40143c155b41">create\_table\_LIST</a>: Use <a href="/content/concepts/tables/#partitioning-by-list">list partitioning</a>. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a31d7cab03373e8c7f89cdcee2d333775">create\_table\_HASH</a>: Use <a href="/content/concepts/tables/#partitioning-by-hash">hash partitioning</a>. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aed61431bd9e0877bf37d4939d86128fb">create\_table\_SERIES</a>: Use <a href="/content/concepts/tables/#partitioning-by-series">series partitioning</a>. </li>
                      </ul>
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#acf1547f910bed470a4ea76dde79ffd97">create\_table\_partition\_keys</a>: Comma-separated list of partition keys, which are the columns or column expressions by which records will be assigned to partitions defined by <a href="/content/api/cpp/namespacegpudb#a62f22ffeb7adf9117dacf811916cb850">partition\_definitions</a>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a62f22ffeb7adf9117dacf811916cb850">create\_table\_partition\_definitions</a>: Comma-separated list of partition definitions, whose format depends on the choice of <a href="/content/api/cpp/namespacegpudb#a5f288dbab3fe8010bc8b26745edbfaf5">partition\_type</a>. See <a href="/content/concepts/tables/#partitioning-by-range">range partitioning</a>, <a href="/content/concepts/tables/#partitioning-by-interval">interval partitioning</a>, <a href="/content/concepts/tables/#partitioning-by-list">list partitioning</a>, <a href="/content/concepts/tables/#partitioning-by-hash">hash partitioning</a>, or <a href="/content/concepts/tables/#partitioning-by-series">series partitioning</a> for example formats. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a43cb4aab1169616535d36a3a7180c40c">create\_table\_is\_automatic\_partition</a>: If <a href="/content/api/cpp/namespacegpudb#a68723d817c882f8faad2f766b8c7e257">true</a>, a new partition will be created for values which don't fall into an existing partition. Currently only supported for <a href="/content/concepts/tables/#partitioning-by-list">list partitions</a>. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a68723d817c882f8faad2f766b8c7e257">create\_table\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ab17cfbe49f1596f55781f32a5872bfc1">create\_table\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ab17cfbe49f1596f55781f32a5872bfc1">create\_table\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#af49995b11df0dfc22a4b090943ec5079">create\_table\_ttl</a>: Sets the <a href="/content/concepts/ttl/">TTL</a> of the table specified in <span>tableName</span>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ab456675e6c896b874d3337e8cd986fac">create\_table\_chunk\_size</a>: Indicates the number of records per chunk to be used for this table. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#acdfeaeb456bc0e07d2d70e78f0cedb87">create\_table\_chunk\_column\_max\_memory</a>: Indicates the target maximum data size for each column in a chunk to be used for this table. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a4f013c37bc4c582d105041a915e3a749">create\_table\_chunk\_max\_memory</a>: Indicates the target maximum data size for all columns in a chunk to be used for this table. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a2a26ae1a59d1e4bf8198e9b14ced4206">create\_table\_is\_result\_table</a>: Indicates whether the table is a <a href="/content/concepts/tables_memory_only/">memory-only table</a>. A result table cannot contain columns with text\_search <a href="/content/concepts/types/#data-handling">data-handling</a>, and it will not be retained if the server is restarted. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a68723d817c882f8faad2f766b8c7e257">create\_table\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ab17cfbe49f1596f55781f32a5872bfc1">create\_table\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ab17cfbe49f1596f55781f32a5872bfc1">create\_table\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#af71f5faa5ea865bbc6779651c3cf10b7">create\_table\_strategy\_definition</a>: The <a href="/content/rm/concepts/#tier-strategies">tier strategy</a> for the table and its columns. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ac5fbcd23a4aea42bc696d4c2a1f7cd2f">create\_table\_compression\_codec</a>: The default <a href="/content/concepts/column_compression/">compression codec</a> for this table's columns. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a4cda2a25a7f3eeb83b863d37cd1f25ad">create\_table\_load\_vectors\_policy</a>: Set startup data loading scheme for the table. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad317bb7b1a5ed5b3c3a0b1e8107ff267">create\_table\_always</a>: Load as much vector data as possible into memory before accepting requests. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a4401fcef8c5e17e1a2b6b89f211873f5">create\_table\_lazy</a>: Load the necessary vector data at start, and load the remainder lazily. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a216b642aff207bee5303342b3b702e00">create\_table\_on\_demand</a>: Load vector data as requests use it. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a96651b624b201e35d2463e0ecde8a776">create\_table\_system</a>: Load vector data using the system-configured default. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a96651b624b201e35d2463e0ecde8a776">create\_table\_system</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ad7001f1b36ac610de60739dcf78cf729">create\_table\_build\_pk\_index\_policy</a>: Set startup primary-key index generation scheme for the table. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad317bb7b1a5ed5b3c3a0b1e8107ff267">create\_table\_always</a>: Generate as much primary key index data as possible before accepting requests. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a4401fcef8c5e17e1a2b6b89f211873f5">create\_table\_lazy</a>: Generate the necessary primary key index data at start, and load the remainder lazily. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a216b642aff207bee5303342b3b702e00">create\_table\_on\_demand</a>: Generate primary key index data as requests use it. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a96651b624b201e35d2463e0ecde8a776">create\_table\_system</a>: Generate primary key index data using the system-configured default. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a96651b624b201e35d2463e0ecde8a776">create\_table\_system</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CreateTableResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CreateTableResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ac963efc014c345b859fc672fd61425c2">◆ </a></span>createTableExternal() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CreateTableExternalResponse">CreateTableExternalResponse</a> gpudb::GPUdb::createTableExternal </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1CreateTableExternalRequest">CreateTableExternalRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Creates a new <a href="/content/concepts/external_tables/">external table</a>, which is a local database object whose source data is located externally to the database. </p>
        <p>The source data can be located either in <a href="/content/tools/kifs/">KiFS</a>; on the cluster, accessible to the database; or remotely, accessible via a pre-defined external <a href="/content/concepts/data_sources/">data source</a>.</p>
        <p>The external table can have its structure defined explicitly, via <a href="/content/api/cpp/structgpudb_1_1CreateTableExternalRequest#ae1a408e0a64ee5e5f38665730e8cfbd8">createTableOptions</a>, which contains many of the options from <a href="#a827d2d54888b00d0dcc69599325de9cf">createTable</a>; or defined implicitly, inferred from the source data.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CreateTableExternalRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CreateTableExternalResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#af50aed1723c9972c56a6422439018d4c">◆ </a></span>createTableExternal() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CreateTableExternalResponse">CreateTableExternalResponse</a> & gpudb::GPUdb::createTableExternal </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1CreateTableExternalRequest">CreateTableExternalRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1CreateTableExternalResponse">CreateTableExternalResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Creates a new <a href="/content/concepts/external_tables/">external table</a>, which is a local database object whose source data is located externally to the database. </p>
        <p>The source data can be located either in <a href="/content/tools/kifs/">KiFS</a>; on the cluster, accessible to the database; or remotely, accessible via a pre-defined external <a href="/content/concepts/data_sources/">data source</a>.</p>
        <p>The external table can have its structure defined explicitly, via <a href="/content/api/cpp/structgpudb_1_1CreateTableExternalRequest#ae1a408e0a64ee5e5f38665730e8cfbd8">createTableOptions</a>, which contains many of the options from <a href="#a827d2d54888b00d0dcc69599325de9cf">createTable</a>; or defined implicitly, inferred from the source data.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CreateTableExternalRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CreateTableExternalResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CreateTableExternalResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ab295ed721682bb4ed0da6ac4e79d7fc2">◆ </a></span>createTableExternal() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CreateTableExternalResponse">CreateTableExternalResponse</a> gpudb::GPUdb::createTableExternal </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< std::string > &</td>
            <td><span><span>filepaths</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::map\< std::string, std::string > > &</td>
            <td><span><span>modifyColumns</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>createTableOptions</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Creates a new <a href="/content/concepts/external_tables/">external table</a>, which is a local database object whose source data is located externally to the database. </p>
        <p>The source data can be located either in <a href="/content/tools/kifs/">KiFS</a>; on the cluster, accessible to the database; or remotely, accessible via a pre-defined external <a href="/content/concepts/data_sources/">data source</a>.</p>
        <p>The external table can have its structure defined explicitly, via <span>createTableOptions</span>, which contains many of the options from <a href="#afa4ded9fdb07b49b4b1cb0835b5ac52a">createTable</a>; or defined implicitly, inferred from the source data.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of the table to be created, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a> and meeting <a href="/content/concepts/tables/#table-naming-criteria">table naming criteria</a>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>filepaths</td>
                <td>A list of file paths from which data will be sourced; For paths in <a href="/content/tools/kifs/">KiFS</a>, use the URI prefix of kifs\:// followed by the path to a file or directory. File matching by prefix is supported, e.g. kifs\://dir/file would match dir/file\_1 and dir/file\_2. When prefix matching is used, the path must start with a full, valid KiFS directory name. If an external data source is specified in <a href="/content/api/cpp/namespacegpudb#ad444d02169146dd13bca3c86408b8113">datasource\_name</a>, these file paths must resolve to accessible files at that data source location. Prefix matching is supported. If the data source is hdfs, prefixes must be aligned with directories, i.e. partial file names will not match. If no data source is specified, the files are assumed to be local to the database and must all be accessible to the gpudb user, residing on the path (or relative to the path) specified by the external files directory in the Kinetica <a href="/content/config/#config-main-external-files">configuration file</a>. Wildcards (\*) can be used to specify a group of files. Prefix matching is supported, the prefixes must be aligned with directories. If the first path ends in .tsv, the text delimiter will be defaulted to a tab character. If the first path ends in .psv, the text delimiter will be defaulted to a pipe character (|). </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>modifyColumns</td>
                <td>Not implemented yet. The default value is an empty map. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>createTableOptions</td>

                <td>
                  <a href="/content/api/cpp/classgpudb_1_1GPUdb_1_1Options">Options</a> from <a href="#afa4ded9fdb07b49b4b1cb0835b5ac52a">createTable</a>, allowing the structure of the table to be defined independently of the data source.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#aa8bb1e5dd87fe408da5a3accf570037b">create\_table\_external\_type\_id</a>: ID of a currently registered <a href="/content/concepts/types/">type</a>. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a2681954465dbfb7fc8edd14fb02ab2d5">create\_table\_external\_no\_error\_if\_exists</a>: If <a href="/content/api/cpp/namespacegpudb#a74ac0af48e9a17bf157856641b2a4ee1">true</a>, prevents an error from occurring if the table already exists and is of the given type. If a table with the same name but a different type exists, it is still an error. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a74ac0af48e9a17bf157856641b2a4ee1">create\_table\_external\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a7bf7ceb49435d162cfaa30d276956f31">create\_table\_external\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a7bf7ceb49435d162cfaa30d276956f31">create\_table\_external\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ab23d5d5611db50321c42e2147610512a">create\_table\_external\_is\_replicated</a>: Affects the <a href="/content/concepts/tables/#distribution">distribution scheme</a> for the table's data. If <a href="/content/api/cpp/namespacegpudb#a74ac0af48e9a17bf157856641b2a4ee1">true</a> and the given table has no explicit <a href="/content/concepts/tables/#shard-key">shard key</a> defined, the table will be <a href="/content/concepts/tables/#replication">replicated</a>. If <a href="/content/api/cpp/namespacegpudb#a7bf7ceb49435d162cfaa30d276956f31">false</a>, the table will be <a href="/content/concepts/tables/#sharding">sharded</a> according to the shard key specified in the given <a href="/content/api/cpp/namespacegpudb#aa8bb1e5dd87fe408da5a3accf570037b">type\_id</a>, or <a href="/content/concepts/tables/#random-sharding">randomly sharded</a>, if no shard key is specified. Note that a type containing a shard key cannot be used to create a replicated table. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a74ac0af48e9a17bf157856641b2a4ee1">create\_table\_external\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a7bf7ceb49435d162cfaa30d276956f31">create\_table\_external\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a7bf7ceb49435d162cfaa30d276956f31">create\_table\_external\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a996652511763c9d40587232d7ae790b2">create\_table\_external\_foreign\_keys</a>: Semicolon-separated list of <a href="/content/concepts/tables/#foreign-keys">foreign keys</a>, of the format '(source\_column\_name \[, ...]) references target\_table\_name(primary\_key\_column\_name \[, ...]) \[as foreign\_key\_name]'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a655f8ef44194d44da70c4a63eb219411">create\_table\_external\_foreign\_shard\_key</a>: Foreign shard key of the format 'source\_column references shard\_by\_column from target\_table(primary\_key\_column)'. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a46b34ad4d205f134a034a27afeab273e">create\_table\_external\_partition\_type</a>: <a href="/content/concepts/tables/#partitioning">Partitioning</a> scheme to use. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#adc4a74362839820a5cb3f601fd5bf650">create\_table\_external\_RANGE</a>: Use <a href="/content/concepts/tables/#partitioning-by-range">range partitioning</a>. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a49a4d76ea92fd6c36eb78ef8948355f2">create\_table\_external\_INTERVAL</a>: Use <a href="/content/concepts/tables/#partitioning-by-interval">interval partitioning</a>. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a503326f8b4db661087ecc3ffbae2bf8f">create\_table\_external\_LIST</a>: Use <a href="/content/concepts/tables/#partitioning-by-list">list partitioning</a>. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a8061b31bc3e2640a3c6da161e0fd25f9">create\_table\_external\_HASH</a>: Use <a href="/content/concepts/tables/#partitioning-by-hash">hash partitioning</a>. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a43f0647bb79240e05be50efc5527d8c0">create\_table\_external\_SERIES</a>: Use <a href="/content/concepts/tables/#partitioning-by-series">series partitioning</a>. </li>
                      </ul>
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a46cba6135481480b3457cab46426fc97">create\_table\_external\_partition\_keys</a>: Comma-separated list of partition keys, which are the columns or column expressions by which records will be assigned to partitions defined by <a href="/content/api/cpp/namespacegpudb#ab0dd3b569308ce2f9436042a1270ba12">partition\_definitions</a>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ab0dd3b569308ce2f9436042a1270ba12">create\_table\_external\_partition\_definitions</a>: Comma-separated list of partition definitions, whose format depends on the choice of <a href="/content/api/cpp/namespacegpudb#a46b34ad4d205f134a034a27afeab273e">partition\_type</a>. See <a href="/content/concepts/tables/#partitioning-by-range">range partitioning</a>, <a href="/content/concepts/tables/#partitioning-by-interval">interval partitioning</a>, <a href="/content/concepts/tables/#partitioning-by-list">list partitioning</a>, <a href="/content/concepts/tables/#partitioning-by-hash">hash partitioning</a>, or <a href="/content/concepts/tables/#partitioning-by-series">series partitioning</a> for example formats. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a9c3078550c65988cea8753b178fb2803">create\_table\_external\_is\_automatic\_partition</a>: If <a href="/content/api/cpp/namespacegpudb#a74ac0af48e9a17bf157856641b2a4ee1">true</a>, a new partition will be created for values which don't fall into an existing partition. Currently, only supported for <a href="/content/concepts/tables/#partitioning-by-list">list partitions</a>. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a74ac0af48e9a17bf157856641b2a4ee1">create\_table\_external\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a7bf7ceb49435d162cfaa30d276956f31">create\_table\_external\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a7bf7ceb49435d162cfaa30d276956f31">create\_table\_external\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#aec22188c6e8ac56ba3f1056346734112">create\_table\_external\_ttl</a>: Sets the <a href="/content/concepts/ttl/">TTL</a> of the table specified in <span>tableName</span>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a88674da171464600dfa4f4ee46e17058">create\_table\_external\_chunk\_size</a>: Indicates the number of records per chunk to be used for this table. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a3e01ad1a24e83efdac933135a48b8037">create\_table\_external\_chunk\_column\_max\_memory</a>: Indicates the target maximum data size for each column in a chunk to be used for this table. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a8a2419a6bf926289df19f9e5ccaa47a6">create\_table\_external\_chunk\_max\_memory</a>: Indicates the target maximum data size for all columns in a chunk to be used for this table. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a80a6b4ba2a704d31d232195ec987cbcd">create\_table\_external\_is\_result\_table</a>: Indicates whether the table is a <a href="/content/concepts/tables_memory_only/">memory-only table</a>. A result table cannot contain columns with text\_search <a href="/content/concepts/types/#data-handling">data-handling</a>, and it will not be retained if the server is restarted. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a74ac0af48e9a17bf157856641b2a4ee1">create\_table\_external\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a7bf7ceb49435d162cfaa30d276956f31">create\_table\_external\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a7bf7ceb49435d162cfaa30d276956f31">create\_table\_external\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a3bd0874901a3bd16d82793d5d41c0111">create\_table\_external\_strategy\_definition</a>: The <a href="/content/rm/concepts/#tier-strategies">tier strategy</a> for the table and its columns. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a0ab03480051b3b6de76df0880db2213d">create\_table\_external\_compression\_codec</a>: The default <a href="/content/concepts/column_compression/">compression codec</a> for this table's columns. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a712426c379b213b16985312d796872ef">create\_table\_external\_bad\_record\_table\_name</a>: Name of a table to which records that were rejected are written. The bad-record-table has the following columns: line\_number (long), line\_rejected (string), error\_message (string). When <a href="/content/api/cpp/namespacegpudb#af9c1b76e77750429862f1aacb27d74fe">error\_handling</a> is <a href="/content/api/cpp/namespacegpudb#a8396f4ebffb3428ab67acddb4342f742">abort</a>, bad records table is not populated. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ad97369e02350785f543f993106d47d1e">create\_table\_external\_bad\_record\_table\_limit</a>: A positive integer indicating the maximum number of records that can be written to the bad-record-table. The default value is '10000'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a3fca82375687fcd688676ad00ded465f">create\_table\_external\_bad\_record\_table\_limit\_per\_input</a>: For subscriptions, a positive integer indicating the maximum number of records that can be written to the bad-record-table per file/payload. Default value will be <a href="/content/api/cpp/namespacegpudb#ad97369e02350785f543f993106d47d1e">bad\_record\_table\_limit</a> and total size of the table per rank is limited to <a href="/content/api/cpp/namespacegpudb#ad97369e02350785f543f993106d47d1e">bad\_record\_table\_limit</a>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ad9c60ee90fd99f72f5227752f1116c85">create\_table\_external\_batch\_size</a>: Number of records to insert per batch when inserting data. The default value is '50000'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aa88bd6c89efff0630a8cff29e5bbf7a1">create\_table\_external\_column\_formats</a>: For each target column specified, applies the column-property-bound format to the source data loaded into that column. Each column format will contain a mapping of one or more of its column properties to an appropriate format for each property. Currently supported column properties include date, time, and datetime. The parameter value must be formatted as a JSON string of maps of column names to maps of column properties to their corresponding column formats, e.g., ' "order\_date" :  "date" : "%Y.%m.%d" , "order\_time" :  "time" : "%H:%M:%S"  '. See <a href="/content/api/cpp/namespacegpudb#a17db89f8b74dd7cd20b13b307c84641b">default\_column\_formats</a> for valid format syntax. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#acf013f75546646fd42c54b3a420f3390">create\_table\_external\_columns\_to\_load</a>: Specifies a comma-delimited list of columns from the source data to load. If more than one file is being loaded, this list applies to all files. Column numbers can be specified discretely or as a range. For example, a value of '5,7,1..3' will insert values from the fifth column in the source data into the first column in the target table, from the seventh column in the source data into the second column in the target table, and from the first through third columns in the source data into the third through fifth columns in the target table. If the source data contains a header, column names matching the file header names may be provided instead of column numbers. If the target table doesn't exist, the table will be created with the columns in this order. If the target table does exist with columns in a different order than the source data, this list can be used to match the order of the target table. For example, a value of 'C, B, A' will create a three column table with column C, followed by column B, followed by column A; or will insert those fields in that order into a table created with columns in that order. If the target table exists, the column names must match the source data field names for a name-mapping to be successful. Mutually exclusive with <a href="/content/api/cpp/namespacegpudb#a0f8e79aac98d4b17242cde7cdc3c6389">columns\_to\_skip</a>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a0f8e79aac98d4b17242cde7cdc3c6389">create\_table\_external\_columns\_to\_skip</a>: Specifies a comma-delimited list of columns from the source data to skip. Mutually exclusive with <a href="/content/api/cpp/namespacegpudb#acf013f75546646fd42c54b3a420f3390">columns\_to\_load</a>. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ae31a6ad1b0fd6dd167a2fce7534bd12c">create\_table\_external\_compression\_type</a>: Source data compression type. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#abd6196795a8a4ff725a1b34e6f9cc9da">create\_table\_external\_none</a>: No compression. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a22784a6e10e41a1121edb4e1bfa7bd8c">create\_table\_external\_auto</a>: Auto detect compression type. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad34bab886db04eda58d347e4ce4bc736">create\_table\_external\_gzip</a>: gzip file compression. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a7fbfd10069490eb048e5a1f4297513ce">create\_table\_external\_bzip2</a>: bzip2 file compression. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a22784a6e10e41a1121edb4e1bfa7bd8c">create\_table\_external\_auto</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#ad444d02169146dd13bca3c86408b8113">create\_table\_external\_datasource\_name</a>: Name of an existing external data source from which data file(s) specified in <span>filepaths</span> will be loaded. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a17db89f8b74dd7cd20b13b307c84641b">create\_table\_external\_default\_column\_formats</a>: Specifies the default format to be applied to source data loaded into columns with the corresponding column property. Currently supported column properties include date, time, and datetime. This default column-property-bound format can be overridden by specifying a column property and format for a given target column in <a href="/content/api/cpp/namespacegpudb#aa88bd6c89efff0630a8cff29e5bbf7a1">column\_formats</a>. For each specified annotation, the format will apply to all columns with that annotation unless a custom <a href="/content/api/cpp/namespacegpudb#aa88bd6c89efff0630a8cff29e5bbf7a1">column\_formats</a> for that annotation is specified. The parameter value must be formatted as a JSON string that is a map of column properties to their respective column formats, e.g., ' "date" : "%Y.%m.%d", "time" : "%H:%M:%S" '. Column formats are specified as a string of control characters and plain text. The supported control characters are 'Y', 'm', 'd', 'H', 'M', 'S', and 's', which follow the Linux 'strptime()' specification, as well as 's', which specifies seconds and fractional seconds (though the fractional component will be truncated past milliseconds). Formats for the 'date' annotation must include the 'Y', 'm', and 'd' control characters. Formats for the 'time' annotation must include the 'H', 'M', and either 'S' or 's' (but not both) control characters. Formats for the 'datetime' annotation meet both the 'date' and 'time' control character requirements. For example, '"datetime" : "%m/%d/%Y %H:%M:%S" ' would be used to interpret text as "05/04/2000 12:12:11". </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a2550044df57f863f6ba90ba441b6b853">create\_table\_external\_datalake\_catalog</a>: Name of an existing datalake(iceberg) catalog used in loading files. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ab59e68fca69b51718f2d42c844f6b0f8">create\_table\_external\_datalake\_path</a>: Path of datalake(iceberg) object. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a333fc00320f9646d6ce9d8607bd1636d">create\_table\_external\_datalake\_snapshot</a>: Snapshot ID of datalake(iceberg) object. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#af9c1b76e77750429862f1aacb27d74fe">create\_table\_external\_error\_handling</a>: Specifies how errors should be handled upon insertion. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a177f9345e6f7506b65b8816300ec970c">create\_table\_external\_permissive</a>: Records with missing columns are populated with nulls if possible; otherwise, the malformed records are skipped. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a4f546b7f243e75507845c3c03c65cf43">create\_table\_external\_skip</a>: Malformed records are skipped. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a91bd540621245d89535180067b0ab5b5">create\_table\_external\_ignore\_bad\_records</a>: Deprecated. Alias for <a href="/content/api/cpp/namespacegpudb#a4f546b7f243e75507845c3c03c65cf43">skip</a>. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a8396f4ebffb3428ab67acddb4342f742">create\_table\_external\_abort</a>: Stops current insertion and aborts entire operation when an error is encountered. Primary key collisions are considered abortable errors in this mode. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a8396f4ebffb3428ab67acddb4342f742">create\_table\_external\_abort</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ae2a9483b364c1adeb9e461f5249ea3e4">create\_table\_external\_external\_table\_type</a>: Specifies whether the external table holds a local copy of the external data. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a8cafd996beb09c737f0965f6b810394c">create\_table\_external\_materialized</a>: Loads a copy of the external data into the database, refreshed on demand. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a20b68d34949cab333e638c4459119fb5">create\_table\_external\_logical</a>: External data will not be loaded into the database; the data will be retrieved from the source upon servicing each query against the external table. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a8cafd996beb09c737f0965f6b810394c">create\_table\_external\_materialized</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a178e68c97ed7ad584aaab835daa52297">create\_table\_external\_file\_type</a>: Specifies the type of the file(s) whose records will be inserted. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a885911e16966aa2d1989d1209323dfcc">create\_table\_external\_avro</a>: Avro file format. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a2962584ff6fefedf4b4e590d9bd6ed4e">create\_table\_external\_delimited\_text</a>: Delimited text file format; e.g., CSV, TSV, PSV, etc. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a233e8511dd974b82fec0a4cf583a3a6c">create\_table\_external\_gdb</a>: Esri/GDB file format. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a273d84c481353905dd6e202b4e0e9765">create\_table\_external\_json</a>: JSON file format. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a75afe036b83f75769efb66ac23e650f1">create\_table\_external\_parquet</a>: Apache Parquet file format. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad965f243f73ef163a409bc7ba5072005">create\_table\_external\_shapefile</a>: ShapeFile file format. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a2962584ff6fefedf4b4e590d9bd6ed4e">create\_table\_external\_delimited\_text</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#afecb87460052a2cac57af73ffce85ca1">create\_table\_external\_flatten\_columns</a>: Specifies how to handle nested columns. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a74ac0af48e9a17bf157856641b2a4ee1">create\_table\_external\_true</a>: Break up nested columns to multiple columns. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a7bf7ceb49435d162cfaa30d276956f31">create\_table\_external\_false</a>: Treat nested columns as JSON columns instead of flattening. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a7bf7ceb49435d162cfaa30d276956f31">create\_table\_external\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#ab152351c4cc8dc642762f7296691843c">create\_table\_external\_gdal\_configuration\_options</a>: Comma separated list of gdal conf options, for the specific requests: key=value. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ad17bbbd531ad3c9626b0a76b563a3cc8">create\_table\_external\_pk\_conflict\_predicate\_higher</a>: The record with higher value for the column resolves the primary-key insert conflict. The default value is ''. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a95838adf968c33ce1bbb3ff5ea7d058f">create\_table\_external\_pk\_conflict\_predicate\_lower</a>: The record with lower value for the column resolves the primary-key insert conflict. The default value is ''. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ac2d8ef4993943d481847a0802bbc18f5">create\_table\_external\_ignore\_existing\_pk</a>: Specifies the record collision error-suppression policy for inserting into a table with a <a href="/content/concepts/tables/#primary-keys">primary key</a>, only used when not in upsert mode (upsert mode is disabled when <a href="/content/api/cpp/namespacegpudb#a59970475a768bc8ff812c6190149b474">update\_on\_existing\_pk</a> is <a href="/content/api/cpp/namespacegpudb#a7bf7ceb49435d162cfaa30d276956f31">false</a>). If set to <a href="/content/api/cpp/namespacegpudb#a74ac0af48e9a17bf157856641b2a4ee1">true</a>, any record being inserted that is rejected for having primary key values that match those of an existing table record will be ignored with no error generated. If <a href="/content/api/cpp/namespacegpudb#a7bf7ceb49435d162cfaa30d276956f31">false</a>, the rejection of any record for having primary key values matching an existing record will result in an error being reported, as determined by <a href="/content/api/cpp/namespacegpudb#af9c1b76e77750429862f1aacb27d74fe">error\_handling</a>. If the specified table does not have a primary key or if upsert mode is in effect (<a href="/content/api/cpp/namespacegpudb#a59970475a768bc8ff812c6190149b474">update\_on\_existing\_pk</a> is <a href="/content/api/cpp/namespacegpudb#a74ac0af48e9a17bf157856641b2a4ee1">true</a>), then this option has no effect. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a74ac0af48e9a17bf157856641b2a4ee1">create\_table\_external\_true</a>: Ignore new records whose primary key values collide with those of existing records. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a7bf7ceb49435d162cfaa30d276956f31">create\_table\_external\_false</a>: Treat as errors any new records whose primary key values collide with those of existing records. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a7bf7ceb49435d162cfaa30d276956f31">create\_table\_external\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a436ed51fc20f87ca9f4cb38841617eeb">create\_table\_external\_ingestion\_mode</a>: Whether to do a full load, dry run, or perform a type inference on the source data. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#aee1afeba03340696867cf4817eae9494">create\_table\_external\_full</a>: Run a type inference on the source data (if needed) and ingest. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a6441cef2053cf9eb99019f4898691744">create\_table\_external\_dry\_run</a>: Does not load data, but walks through the source data and determines the number of valid records, taking into account the current mode of <a href="/content/api/cpp/namespacegpudb#af9c1b76e77750429862f1aacb27d74fe">error\_handling</a>. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a434ad9e487691a2f490b13a4c41419d7">create\_table\_external\_type\_inference\_only</a>: Infer the type of the source data and return, without ingesting any data. The inferred type is returned in the response. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#aee1afeba03340696867cf4817eae9494">create\_table\_external\_full</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a1c95426f566da2a70fde4333df9acbdb">create\_table\_external\_jdbc\_fetch\_size</a>: The JDBC fetch size, which determines how many rows to fetch per round trip. The default value is '50000'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ab9ab2e00a0517ea9941a86adfc9df057">create\_table\_external\_kafka\_consumers\_per\_rank</a>: Number of Kafka consumer threads per rank (valid range 1-6). The default value is '1'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a9960bc15a6b19cc0b609a2ce681a8bce">create\_table\_external\_kafka\_group\_id</a>: The group id to be used when consuming data from a Kafka topic (valid only for Kafka datasource subscriptions). </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a942f220b1652e0e6d1f5746674617d62">create\_table\_external\_kafka\_offset\_reset\_policy</a>: Policy to determine whether the Kafka data consumption starts either at earliest offset or latest offset. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a6a7e63433949f35696d87371919f31cd">create\_table\_external\_earliest</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad27391434237c1855da82b0f1e023523">create\_table\_external\_latest</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a6a7e63433949f35696d87371919f31cd">create\_table\_external\_earliest</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a2f329fec52de77614f12c5c2a3a244b4">create\_table\_external\_kafka\_optimistic\_ingest</a>: Enable optimistic ingestion where Kafka topic offsets and table data are committed independently to achieve parallelism. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a74ac0af48e9a17bf157856641b2a4ee1">create\_table\_external\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a7bf7ceb49435d162cfaa30d276956f31">create\_table\_external\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a7bf7ceb49435d162cfaa30d276956f31">create\_table\_external\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a69ecd65146fe5038dda24e7511cdff91">create\_table\_external\_kafka\_subscription\_cancel\_after</a>: Sets the Kafka subscription lifespan (in minutes). Expired subscription will be cancelled automatically. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a79a5e0b21bba5b500bd2afef1010b994">create\_table\_external\_kafka\_type\_inference\_fetch\_timeout</a>: Maximum time to collect Kafka messages before type inferencing on the set of them. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a619ba1d9529188d808124fc1604e4f8e">create\_table\_external\_layer</a>: Geo files layer(s) name(s): comma separated. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a76f7f969a8a2c5bc4fb5f7dcf96ecf07">create\_table\_external\_loading\_mode</a>: Scheme for distributing the extraction and loading of data from the source data file(s). This option applies only when loading files that are local to the database. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#acbb66cf3ef158ccc845856424b2069be">create\_table\_external\_head</a>: The head node loads all data. All files must be available to the head node. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a7a4ab8985c363e02926df4137847a3ec">create\_table\_external\_distributed\_shared</a>: The head node coordinates loading data by worker processes across all nodes from shared files available to all workers. NOTE: Instead of existing on a shared source, the files can be duplicated on a source local to each host to improve performance, though the files must appear as the same data set from the perspective of all hosts performing the load. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a9dedda6d35ebb43c2d9d8af6e927cb5b">create\_table\_external\_distributed\_local</a>: A single worker process on each node loads all files that are available to it. This option works best when each worker loads files from its own file system, to maximize performance. In order to avoid data duplication, either each worker performing the load needs to have visibility to a set of files unique to it (no file is visible to more than one node) or the target table needs to have a primary key (which will allow the worker to automatically deduplicate data). NOTE: If the target table doesn't exist, the table structure will be determined by the head node. If the head node has no files local to it, it will be unable to determine the structure and the request will fail. If the head node is configured to have no worker processes, no data strictly accessible to the head node will be loaded. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#acbb66cf3ef158ccc845856424b2069be">create\_table\_external\_head</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#ac08a8fc7dccbb258c888ce78c3901b7a">create\_table\_external\_local\_time\_offset</a>: Apply an offset to Avro local timestamp columns. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a25944417ae2a437020661ae12c79a94b">create\_table\_external\_max\_records\_to\_load</a>: Limit the number of records to load in this request: if this number is larger than <a href="/content/api/cpp/namespacegpudb#ad9c60ee90fd99f72f5227752f1116c85">batch\_size</a>, then the number of records loaded will be limited to the next whole number of <a href="/content/api/cpp/namespacegpudb#ad9c60ee90fd99f72f5227752f1116c85">batch\_size</a> (per working thread). </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a56eb1b921e8058949109bc451bf4610c">create\_table\_external\_name\_columns\_from\_file</a>: Specifies a comma-delimited list of column names to be used as the source-data column names. If the file has a header row (i.e., <a href="/content/api/cpp/namespacegpudb#acf2099b6030b751f27b2b1e134ccf5dc">text\_has\_header</a> is <a href="/content/api/cpp/namespacegpudb#a74ac0af48e9a17bf157856641b2a4ee1">true</a>), these names override the file's header names. If the file has no header row, these names are used as the source-data column names. Either way, the i-th name in this list applies to the i-th column in the file, enabling name-based matching against the target table's columns (and use with <a href="/content/api/cpp/namespacegpudb#acf013f75546646fd42c54b3a420f3390">columns\_to\_load</a> / <a href="/content/api/cpp/namespacegpudb#a0f8e79aac98d4b17242cde7cdc3c6389">columns\_to\_skip</a>). </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a203c159810c804bc653c888a3502f6bf">create\_table\_external\_num\_tasks\_per\_rank</a>: Number of tasks for reading file per rank. Default will be system configuration parameter, external\_file\_reader\_num\_tasks. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ac0a3738e6c1a9d765c5ffcfea5280130">create\_table\_external\_poll\_interval</a>: If <a href="/content/api/cpp/namespacegpudb#a74ac0af48e9a17bf157856641b2a4ee1">true</a>, the number of seconds between attempts to load external files into the table. If zero, polling will be continuous as long as data is found. If no data is found, the interval will steadily increase to a maximum of 60 seconds. The default value is '0'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ae867839e185166b1095aa5626649451e">create\_table\_external\_primary\_keys</a>: Comma separated list of column names to set as primary keys, when not specified in the type. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a4775a1e6c3ce899efded34ac5899103b">create\_table\_external\_refresh\_method</a>: Method by which the table can be refreshed from its source data. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a235392354a05fd4e41a09a83e7c5ead3">create\_table\_external\_manual</a>: Refresh only occurs when manually requested by invoking the refresh action of <a href="#a25df43fa85e02f0cdb3dab9e498995ce">alterTable</a> on this table. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a7ab17621b1d728e5ce593b30c16111e2">create\_table\_external\_on\_start</a>: Refresh table on database startup and when manually requested by invoking the refresh action of <a href="#a25df43fa85e02f0cdb3dab9e498995ce">alterTable</a> on this table. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a235392354a05fd4e41a09a83e7c5ead3">create\_table\_external\_manual</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a73595a2ad41ea7acab4a7c730e313423">create\_table\_external\_schema\_registry\_connection\_retries</a>: Confluent Schema registry connection timeout (in secs). </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a8d72d614eadb06606998f9d8ca20301e">create\_table\_external\_schema\_registry\_connection\_timeout</a>: Confluent Schema registry connection timeout (in secs). </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a72f12f05bcfe2a86be945ffd41501b91">create\_table\_external\_schema\_registry\_max\_consecutive\_connection\_failures</a>: Max records to skip due to SR connection failures, before failing. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a2a65e6cf6b0491a171cf2a9ba6f7e7d7">create\_table\_external\_max\_consecutive\_invalid\_schema\_failure</a>: Max records to skip due to schema related errors, before failing. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a422d1815fad489942fd7f0676d75f391">create\_table\_external\_schema\_registry\_schema\_name</a>: Name of the Avro schema in the schema registry to use when reading Avro records. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a892fd29330ba46649ad084b5114414e4">create\_table\_external\_shard\_keys</a>: Comma separated list of column names to set as shard keys, when not specified in the type. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a6dd75878ad8c2ebce787389a573c742f">create\_table\_external\_skip\_lines</a>: Skip a number of lines from the beginning of the file. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a57b84b771783bcb75babf18577e3b655">create\_table\_external\_start\_offsets</a>: Starting offsets by partition to fetch from kafka. A comma separated list of partition:offset pairs. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a7e233debd2960b19635177b24d5acaf8">create\_table\_external\_subscribe</a>: Continuously poll the data source to check for new data and load it into the table. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a74ac0af48e9a17bf157856641b2a4ee1">create\_table\_external\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a7bf7ceb49435d162cfaa30d276956f31">create\_table\_external\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a7bf7ceb49435d162cfaa30d276956f31">create\_table\_external\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a9e8c328ad6e067daf7b90ded81b6352a">create\_table\_external\_table\_insert\_mode</a>: Insertion scheme to use when inserting records from multiple shapefiles. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a7327acc86a9445e624dea5a4dd00f855">create\_table\_external\_single</a>: Insert all records into a single table. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a9eaa52277342f80d8e055380e5b56659">create\_table\_external\_table\_per\_file</a>: Insert records from each file into a new table corresponding to that file. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a7327acc86a9445e624dea5a4dd00f855">create\_table\_external\_single</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a8ab0d48b8b2e90841ce730f44c3f746b">create\_table\_external\_text\_comment\_string</a>: Specifies the character string that should be interpreted as a comment line prefix in the source data. All lines in the data starting with the provided string are ignored. For <a href="/content/api/cpp/namespacegpudb#a2962584ff6fefedf4b4e590d9bd6ed4e">delimited\_text</a> <a href="/content/api/cpp/namespacegpudb#a178e68c97ed7ad584aaab835daa52297">file\_type</a> only. The default value is '#'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a94f6a5e1a80c3eeaedabbc14d9c9f632">create\_table\_external\_text\_delimiter</a>: Specifies the character delimiting field values in the source data and field names in the header (if present). For <a href="/content/api/cpp/namespacegpudb#a2962584ff6fefedf4b4e590d9bd6ed4e">delimited\_text</a> <a href="/content/api/cpp/namespacegpudb#a178e68c97ed7ad584aaab835daa52297">file\_type</a> only. The default value is ','. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ae313bc0f07e239df2a5af1119dac74de">create\_table\_external\_text\_escape\_character</a>: Specifies the character that is used to escape other characters in the source data. An 'a', 'b', 'f', 'n', 'r', 't', or 'v' preceded by an escape character will be interpreted as the ASCII bell, backspace, form feed, line feed, carriage return, horizontal tab, and vertical tab, respectively. For example, the escape character followed by an 'n' will be interpreted as a newline within a field value. The escape character can also be used to escape the quoting character, and will be treated as an escape character whether it is within a quoted field value or not. For <a href="/content/api/cpp/namespacegpudb#a2962584ff6fefedf4b4e590d9bd6ed4e">delimited\_text</a> <a href="/content/api/cpp/namespacegpudb#a178e68c97ed7ad584aaab835daa52297">file\_type</a> only. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#acf2099b6030b751f27b2b1e134ccf5dc">create\_table\_external\_text\_has\_header</a>: Indicates whether the source data contains a header row. For <a href="/content/api/cpp/namespacegpudb#a2962584ff6fefedf4b4e590d9bd6ed4e">delimited\_text</a><a href="/content/api/cpp/namespacegpudb#a178e68c97ed7ad584aaab835daa52297">file\_type</a> only. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a74ac0af48e9a17bf157856641b2a4ee1">create\_table\_external\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a7bf7ceb49435d162cfaa30d276956f31">create\_table\_external\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a74ac0af48e9a17bf157856641b2a4ee1">create\_table\_external\_true</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#af59c4fd330c8b3fc44bc04d1dc917bdb">create\_table\_external\_text\_header\_property\_delimiter</a>: Specifies the delimiter for <a href="/content/concepts/types/#column-properties">column properties</a> in the header row (if present). Cannot be set to same value as <a href="/content/api/cpp/namespacegpudb#a94f6a5e1a80c3eeaedabbc14d9c9f632">text\_delimiter</a>. For <a href="/content/api/cpp/namespacegpudb#a2962584ff6fefedf4b4e590d9bd6ed4e">delimited\_text</a> <a href="/content/api/cpp/namespacegpudb#a178e68c97ed7ad584aaab835daa52297">file\_type</a> only. The default value is '|'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#adbb252f3491ecbfe457c206fa2bfdaac">create\_table\_external\_text\_null\_string</a>: Specifies the character string that should be interpreted as a null value in the source data. For <a href="/content/api/cpp/namespacegpudb#a2962584ff6fefedf4b4e590d9bd6ed4e">delimited\_text</a> <a href="/content/api/cpp/namespacegpudb#a178e68c97ed7ad584aaab835daa52297">file\_type</a> only. The default value is '\N'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#afdea1531cb86d2285b1d9c3e67eab21a">create\_table\_external\_text\_quote\_character</a>: Specifies the character that should be interpreted as a field value quoting character in the source data. The character must appear at beginning and end of field value to take effect. Delimiters within quoted fields are treated as literals and not delimiters. Within a quoted field, two consecutive quote characters will be interpreted as a single literal quote character, effectively escaping it. To not have a quote character, specify an empty string. For <a href="/content/api/cpp/namespacegpudb#a2962584ff6fefedf4b4e590d9bd6ed4e">delimited\_text</a> <a href="/content/api/cpp/namespacegpudb#a178e68c97ed7ad584aaab835daa52297">file\_type</a> only. The default value is '"'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a41b4c1f98ae28d26e8b8e0e092343e9c">create\_table\_external\_text\_search\_columns</a>: Add 'text\_search' property to internally inferenced string columns. Comma separated list of column names or '\*' for all columns. To add 'text\_search' property only to string columns greater than or equal to a minimum size, also set the <a href="/content/api/cpp/namespacegpudb#ad34b1babf7c2b1e67ff8bb2638790287">text\_search\_min\_column\_length</a> </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ad34b1babf7c2b1e67ff8bb2638790287">create\_table\_external\_text\_search\_min\_column\_length</a>: Set the minimum column size for strings to apply the 'text\_search' property to. Used only when <a href="/content/api/cpp/namespacegpudb#a41b4c1f98ae28d26e8b8e0e092343e9c">text\_search\_columns</a> has a value. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a7fd0612904a547e5040d34b1ea77e053">create\_table\_external\_transformations</a>: Comma-separated expressions, one per target table column. Each expression is evaluated per record. Empty entries (two consecutive commas) mean no transformation for that column – the value is resolved from the input record, table default, NULL, or an error. Expressions may reference input columns by name or by position ($1 for the first input column, $2 for the second, etc.). The default value is ''. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#acf364b97c28f8fb87d9ad0f7aed3f05e">create\_table\_external\_trim\_space</a>: If set to <a href="/content/api/cpp/namespacegpudb#a74ac0af48e9a17bf157856641b2a4ee1">true</a>, remove leading or trailing space from fields. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a74ac0af48e9a17bf157856641b2a4ee1">create\_table\_external\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a7bf7ceb49435d162cfaa30d276956f31">create\_table\_external\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a7bf7ceb49435d162cfaa30d276956f31">create\_table\_external\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ac069b52aab48bf37a43078157cad490b">create\_table\_external\_truncate\_strings</a>: If set to <a href="/content/api/cpp/namespacegpudb#a74ac0af48e9a17bf157856641b2a4ee1">true</a>, truncate string values that are longer than the column's type size. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a74ac0af48e9a17bf157856641b2a4ee1">create\_table\_external\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a7bf7ceb49435d162cfaa30d276956f31">create\_table\_external\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a7bf7ceb49435d162cfaa30d276956f31">create\_table\_external\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a7fce1e8894572333f6b4acb6f93e7847">create\_table\_external\_truncate\_table</a>: If set to <a href="/content/api/cpp/namespacegpudb#a74ac0af48e9a17bf157856641b2a4ee1">true</a>, truncates the table specified by <span>tableName</span> prior to loading the file(s). Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a74ac0af48e9a17bf157856641b2a4ee1">create\_table\_external\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a7bf7ceb49435d162cfaa30d276956f31">create\_table\_external\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a7bf7ceb49435d162cfaa30d276956f31">create\_table\_external\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#adb01822f89a05c655110f84723aca118">create\_table\_external\_type\_inference\_max\_records\_read</a> </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a1002f2593efe41ced99e06868def2d4a">create\_table\_external\_type\_inference\_mode</a>: Optimize type inferencing for either speed or accuracy. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a29c4fc02a0a8c31ee61ac344569ecc71">create\_table\_external\_accuracy</a>: Scans data to get exactly-typed and sized columns for all data scanned. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aee53262c449fbe883ab2f1afbac0f6bb">create\_table\_external\_speed</a>: Scans data and picks the widest possible column types so that 'all' values will fit with minimum data scanned. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#aee53262c449fbe883ab2f1afbac0f6bb">create\_table\_external\_speed</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a72b7161022d11281d3e84c3feb610caa">create\_table\_external\_remote\_query</a>: Remote SQL query from which data will be sourced. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ad793613c9ae3ed4b091a169bbc17b5f0">create\_table\_external\_remote\_query\_filter\_column</a>: Name of column to be used for splitting <a href="/content/api/cpp/namespacegpudb#a72b7161022d11281d3e84c3feb610caa">remote\_query</a> into multiple sub-queries using the data distribution of given column. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a2560cc1fa35a63f0fa1aedf5fd628b1f">create\_table\_external\_remote\_query\_increasing\_column</a>: Column on subscribed remote query result that will increase for new records (e.g., TIMESTAMP). </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a35b5cc2eb9e332b2586f148a22ad784d">create\_table\_external\_remote\_query\_partition\_column</a>: Alias name for <a href="/content/api/cpp/namespacegpudb#ad793613c9ae3ed4b091a169bbc17b5f0">remote\_query\_filter\_column</a>. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a3b50a0a5d94afd655f5f9ad8a7648f95">create\_table\_external\_enable\_inplace\_updates</a>: Applies only when upserting (when update\_on\_existing\_pk is true). If set to true (the default), an existing record matched by primary key is modified in place. If set to false, the matched record is updated by deleting it and inserting a replacement (delete and insert), which prevents the change from being reflected in dependent materialized views until they are refreshed. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a74ac0af48e9a17bf157856641b2a4ee1">create\_table\_external\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a7bf7ceb49435d162cfaa30d276956f31">create\_table\_external\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a74ac0af48e9a17bf157856641b2a4ee1">create\_table\_external\_true</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a59970475a768bc8ff812c6190149b474">create\_table\_external\_update\_on\_existing\_pk</a>: Specifies the record collision policy for inserting into a table with a <a href="/content/concepts/tables/#primary-keys">primary key</a>. If set to <a href="/content/api/cpp/namespacegpudb#a74ac0af48e9a17bf157856641b2a4ee1">true</a>, any existing table record with primary key values that match those of a record being inserted will be replaced by that new record (the new data will be 'upserted'). If set to <a href="/content/api/cpp/namespacegpudb#a7bf7ceb49435d162cfaa30d276956f31">false</a>, any existing table record with primary key values that match those of a record being inserted will remain unchanged, while the new record will be rejected and the error handled as determined by <a href="/content/api/cpp/namespacegpudb#ac2d8ef4993943d481847a0802bbc18f5">ignore\_existing\_pk</a> and <a href="/content/api/cpp/namespacegpudb#af9c1b76e77750429862f1aacb27d74fe">error\_handling</a>. If the specified table does not have a primary key, then this option has no effect. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a74ac0af48e9a17bf157856641b2a4ee1">create\_table\_external\_true</a>: Upsert new records when primary keys match existing records. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a7bf7ceb49435d162cfaa30d276956f31">create\_table\_external\_false</a>: Reject new records when primary keys match existing records. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a7bf7ceb49435d162cfaa30d276956f31">create\_table\_external\_false</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CreateTableExternalResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#aa8ac79e9d3b97f1d6e4addb282293a2f">◆ </a></span>createTableExternal() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CreateTableExternalResponse">CreateTableExternalResponse</a> & gpudb::GPUdb::createTableExternal </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< std::string > &</td>
            <td><span><span>filepaths</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::map\< std::string, std::string > > &</td>
            <td><span><span>modifyColumns</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>createTableOptions</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1CreateTableExternalResponse">CreateTableExternalResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Creates a new <a href="/content/concepts/external_tables/">external table</a>, which is a local database object whose source data is located externally to the database. </p>
        <p>The source data can be located either in <a href="/content/tools/kifs/">KiFS</a>; on the cluster, accessible to the database; or remotely, accessible via a pre-defined external <a href="/content/concepts/data_sources/">data source</a>.</p>
        <p>The external table can have its structure defined explicitly, via <span>createTableOptions</span>, which contains many of the options from <a href="#afa4ded9fdb07b49b4b1cb0835b5ac52a">createTable</a>; or defined implicitly, inferred from the source data.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of the table to be created, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a> and meeting <a href="/content/concepts/tables/#table-naming-criteria">table naming criteria</a>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>filepaths</td>
                <td>A list of file paths from which data will be sourced; For paths in <a href="/content/tools/kifs/">KiFS</a>, use the URI prefix of kifs\:// followed by the path to a file or directory. File matching by prefix is supported, e.g. kifs\://dir/file would match dir/file\_1 and dir/file\_2. When prefix matching is used, the path must start with a full, valid KiFS directory name. If an external data source is specified in <a href="/content/api/cpp/namespacegpudb#ad444d02169146dd13bca3c86408b8113">datasource\_name</a>, these file paths must resolve to accessible files at that data source location. Prefix matching is supported. If the data source is hdfs, prefixes must be aligned with directories, i.e. partial file names will not match. If no data source is specified, the files are assumed to be local to the database and must all be accessible to the gpudb user, residing on the path (or relative to the path) specified by the external files directory in the Kinetica <a href="/content/config/#config-main-external-files">configuration file</a>. Wildcards (\*) can be used to specify a group of files. Prefix matching is supported, the prefixes must be aligned with directories. If the first path ends in .tsv, the text delimiter will be defaulted to a tab character. If the first path ends in .psv, the text delimiter will be defaulted to a pipe character (|). </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>modifyColumns</td>
                <td>Not implemented yet. The default value is an empty map. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>createTableOptions</td>

                <td>
                  <a href="/content/api/cpp/classgpudb_1_1GPUdb_1_1Options">Options</a> from <a href="#afa4ded9fdb07b49b4b1cb0835b5ac52a">createTable</a>, allowing the structure of the table to be defined independently of the data source.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#aa8bb1e5dd87fe408da5a3accf570037b">create\_table\_external\_type\_id</a>: ID of a currently registered <a href="/content/concepts/types/">type</a>. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a2681954465dbfb7fc8edd14fb02ab2d5">create\_table\_external\_no\_error\_if\_exists</a>: If <a href="/content/api/cpp/namespacegpudb#a74ac0af48e9a17bf157856641b2a4ee1">true</a>, prevents an error from occurring if the table already exists and is of the given type. If a table with the same name but a different type exists, it is still an error. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a74ac0af48e9a17bf157856641b2a4ee1">create\_table\_external\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a7bf7ceb49435d162cfaa30d276956f31">create\_table\_external\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a7bf7ceb49435d162cfaa30d276956f31">create\_table\_external\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ab23d5d5611db50321c42e2147610512a">create\_table\_external\_is\_replicated</a>: Affects the <a href="/content/concepts/tables/#distribution">distribution scheme</a> for the table's data. If <a href="/content/api/cpp/namespacegpudb#a74ac0af48e9a17bf157856641b2a4ee1">true</a> and the given table has no explicit <a href="/content/concepts/tables/#shard-key">shard key</a> defined, the table will be <a href="/content/concepts/tables/#replication">replicated</a>. If <a href="/content/api/cpp/namespacegpudb#a7bf7ceb49435d162cfaa30d276956f31">false</a>, the table will be <a href="/content/concepts/tables/#sharding">sharded</a> according to the shard key specified in the given <a href="/content/api/cpp/namespacegpudb#aa8bb1e5dd87fe408da5a3accf570037b">type\_id</a>, or <a href="/content/concepts/tables/#random-sharding">randomly sharded</a>, if no shard key is specified. Note that a type containing a shard key cannot be used to create a replicated table. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a74ac0af48e9a17bf157856641b2a4ee1">create\_table\_external\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a7bf7ceb49435d162cfaa30d276956f31">create\_table\_external\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a7bf7ceb49435d162cfaa30d276956f31">create\_table\_external\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a996652511763c9d40587232d7ae790b2">create\_table\_external\_foreign\_keys</a>: Semicolon-separated list of <a href="/content/concepts/tables/#foreign-keys">foreign keys</a>, of the format '(source\_column\_name \[, ...]) references target\_table\_name(primary\_key\_column\_name \[, ...]) \[as foreign\_key\_name]'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a655f8ef44194d44da70c4a63eb219411">create\_table\_external\_foreign\_shard\_key</a>: Foreign shard key of the format 'source\_column references shard\_by\_column from target\_table(primary\_key\_column)'. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a46b34ad4d205f134a034a27afeab273e">create\_table\_external\_partition\_type</a>: <a href="/content/concepts/tables/#partitioning">Partitioning</a> scheme to use. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#adc4a74362839820a5cb3f601fd5bf650">create\_table\_external\_RANGE</a>: Use <a href="/content/concepts/tables/#partitioning-by-range">range partitioning</a>. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a49a4d76ea92fd6c36eb78ef8948355f2">create\_table\_external\_INTERVAL</a>: Use <a href="/content/concepts/tables/#partitioning-by-interval">interval partitioning</a>. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a503326f8b4db661087ecc3ffbae2bf8f">create\_table\_external\_LIST</a>: Use <a href="/content/concepts/tables/#partitioning-by-list">list partitioning</a>. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a8061b31bc3e2640a3c6da161e0fd25f9">create\_table\_external\_HASH</a>: Use <a href="/content/concepts/tables/#partitioning-by-hash">hash partitioning</a>. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a43f0647bb79240e05be50efc5527d8c0">create\_table\_external\_SERIES</a>: Use <a href="/content/concepts/tables/#partitioning-by-series">series partitioning</a>. </li>
                      </ul>
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a46cba6135481480b3457cab46426fc97">create\_table\_external\_partition\_keys</a>: Comma-separated list of partition keys, which are the columns or column expressions by which records will be assigned to partitions defined by <a href="/content/api/cpp/namespacegpudb#ab0dd3b569308ce2f9436042a1270ba12">partition\_definitions</a>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ab0dd3b569308ce2f9436042a1270ba12">create\_table\_external\_partition\_definitions</a>: Comma-separated list of partition definitions, whose format depends on the choice of <a href="/content/api/cpp/namespacegpudb#a46b34ad4d205f134a034a27afeab273e">partition\_type</a>. See <a href="/content/concepts/tables/#partitioning-by-range">range partitioning</a>, <a href="/content/concepts/tables/#partitioning-by-interval">interval partitioning</a>, <a href="/content/concepts/tables/#partitioning-by-list">list partitioning</a>, <a href="/content/concepts/tables/#partitioning-by-hash">hash partitioning</a>, or <a href="/content/concepts/tables/#partitioning-by-series">series partitioning</a> for example formats. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a9c3078550c65988cea8753b178fb2803">create\_table\_external\_is\_automatic\_partition</a>: If <a href="/content/api/cpp/namespacegpudb#a74ac0af48e9a17bf157856641b2a4ee1">true</a>, a new partition will be created for values which don't fall into an existing partition. Currently, only supported for <a href="/content/concepts/tables/#partitioning-by-list">list partitions</a>. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a74ac0af48e9a17bf157856641b2a4ee1">create\_table\_external\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a7bf7ceb49435d162cfaa30d276956f31">create\_table\_external\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a7bf7ceb49435d162cfaa30d276956f31">create\_table\_external\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#aec22188c6e8ac56ba3f1056346734112">create\_table\_external\_ttl</a>: Sets the <a href="/content/concepts/ttl/">TTL</a> of the table specified in <span>tableName</span>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a88674da171464600dfa4f4ee46e17058">create\_table\_external\_chunk\_size</a>: Indicates the number of records per chunk to be used for this table. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a3e01ad1a24e83efdac933135a48b8037">create\_table\_external\_chunk\_column\_max\_memory</a>: Indicates the target maximum data size for each column in a chunk to be used for this table. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a8a2419a6bf926289df19f9e5ccaa47a6">create\_table\_external\_chunk\_max\_memory</a>: Indicates the target maximum data size for all columns in a chunk to be used for this table. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a80a6b4ba2a704d31d232195ec987cbcd">create\_table\_external\_is\_result\_table</a>: Indicates whether the table is a <a href="/content/concepts/tables_memory_only/">memory-only table</a>. A result table cannot contain columns with text\_search <a href="/content/concepts/types/#data-handling">data-handling</a>, and it will not be retained if the server is restarted. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a74ac0af48e9a17bf157856641b2a4ee1">create\_table\_external\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a7bf7ceb49435d162cfaa30d276956f31">create\_table\_external\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a7bf7ceb49435d162cfaa30d276956f31">create\_table\_external\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a3bd0874901a3bd16d82793d5d41c0111">create\_table\_external\_strategy\_definition</a>: The <a href="/content/rm/concepts/#tier-strategies">tier strategy</a> for the table and its columns. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a0ab03480051b3b6de76df0880db2213d">create\_table\_external\_compression\_codec</a>: The default <a href="/content/concepts/column_compression/">compression codec</a> for this table's columns. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a712426c379b213b16985312d796872ef">create\_table\_external\_bad\_record\_table\_name</a>: Name of a table to which records that were rejected are written. The bad-record-table has the following columns: line\_number (long), line\_rejected (string), error\_message (string). When <a href="/content/api/cpp/namespacegpudb#af9c1b76e77750429862f1aacb27d74fe">error\_handling</a> is <a href="/content/api/cpp/namespacegpudb#a8396f4ebffb3428ab67acddb4342f742">abort</a>, bad records table is not populated. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ad97369e02350785f543f993106d47d1e">create\_table\_external\_bad\_record\_table\_limit</a>: A positive integer indicating the maximum number of records that can be written to the bad-record-table. The default value is '10000'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a3fca82375687fcd688676ad00ded465f">create\_table\_external\_bad\_record\_table\_limit\_per\_input</a>: For subscriptions, a positive integer indicating the maximum number of records that can be written to the bad-record-table per file/payload. Default value will be <a href="/content/api/cpp/namespacegpudb#ad97369e02350785f543f993106d47d1e">bad\_record\_table\_limit</a> and total size of the table per rank is limited to <a href="/content/api/cpp/namespacegpudb#ad97369e02350785f543f993106d47d1e">bad\_record\_table\_limit</a>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ad9c60ee90fd99f72f5227752f1116c85">create\_table\_external\_batch\_size</a>: Number of records to insert per batch when inserting data. The default value is '50000'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aa88bd6c89efff0630a8cff29e5bbf7a1">create\_table\_external\_column\_formats</a>: For each target column specified, applies the column-property-bound format to the source data loaded into that column. Each column format will contain a mapping of one or more of its column properties to an appropriate format for each property. Currently supported column properties include date, time, and datetime. The parameter value must be formatted as a JSON string of maps of column names to maps of column properties to their corresponding column formats, e.g., ' "order\_date" :  "date" : "%Y.%m.%d" , "order\_time" :  "time" : "%H:%M:%S"  '. See <a href="/content/api/cpp/namespacegpudb#a17db89f8b74dd7cd20b13b307c84641b">default\_column\_formats</a> for valid format syntax. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#acf013f75546646fd42c54b3a420f3390">create\_table\_external\_columns\_to\_load</a>: Specifies a comma-delimited list of columns from the source data to load. If more than one file is being loaded, this list applies to all files. Column numbers can be specified discretely or as a range. For example, a value of '5,7,1..3' will insert values from the fifth column in the source data into the first column in the target table, from the seventh column in the source data into the second column in the target table, and from the first through third columns in the source data into the third through fifth columns in the target table. If the source data contains a header, column names matching the file header names may be provided instead of column numbers. If the target table doesn't exist, the table will be created with the columns in this order. If the target table does exist with columns in a different order than the source data, this list can be used to match the order of the target table. For example, a value of 'C, B, A' will create a three column table with column C, followed by column B, followed by column A; or will insert those fields in that order into a table created with columns in that order. If the target table exists, the column names must match the source data field names for a name-mapping to be successful. Mutually exclusive with <a href="/content/api/cpp/namespacegpudb#a0f8e79aac98d4b17242cde7cdc3c6389">columns\_to\_skip</a>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a0f8e79aac98d4b17242cde7cdc3c6389">create\_table\_external\_columns\_to\_skip</a>: Specifies a comma-delimited list of columns from the source data to skip. Mutually exclusive with <a href="/content/api/cpp/namespacegpudb#acf013f75546646fd42c54b3a420f3390">columns\_to\_load</a>. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ae31a6ad1b0fd6dd167a2fce7534bd12c">create\_table\_external\_compression\_type</a>: Source data compression type. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#abd6196795a8a4ff725a1b34e6f9cc9da">create\_table\_external\_none</a>: No compression. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a22784a6e10e41a1121edb4e1bfa7bd8c">create\_table\_external\_auto</a>: Auto detect compression type. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad34bab886db04eda58d347e4ce4bc736">create\_table\_external\_gzip</a>: gzip file compression. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a7fbfd10069490eb048e5a1f4297513ce">create\_table\_external\_bzip2</a>: bzip2 file compression. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a22784a6e10e41a1121edb4e1bfa7bd8c">create\_table\_external\_auto</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#ad444d02169146dd13bca3c86408b8113">create\_table\_external\_datasource\_name</a>: Name of an existing external data source from which data file(s) specified in <span>filepaths</span> will be loaded. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a17db89f8b74dd7cd20b13b307c84641b">create\_table\_external\_default\_column\_formats</a>: Specifies the default format to be applied to source data loaded into columns with the corresponding column property. Currently supported column properties include date, time, and datetime. This default column-property-bound format can be overridden by specifying a column property and format for a given target column in <a href="/content/api/cpp/namespacegpudb#aa88bd6c89efff0630a8cff29e5bbf7a1">column\_formats</a>. For each specified annotation, the format will apply to all columns with that annotation unless a custom <a href="/content/api/cpp/namespacegpudb#aa88bd6c89efff0630a8cff29e5bbf7a1">column\_formats</a> for that annotation is specified. The parameter value must be formatted as a JSON string that is a map of column properties to their respective column formats, e.g., ' "date" : "%Y.%m.%d", "time" : "%H:%M:%S" '. Column formats are specified as a string of control characters and plain text. The supported control characters are 'Y', 'm', 'd', 'H', 'M', 'S', and 's', which follow the Linux 'strptime()' specification, as well as 's', which specifies seconds and fractional seconds (though the fractional component will be truncated past milliseconds). Formats for the 'date' annotation must include the 'Y', 'm', and 'd' control characters. Formats for the 'time' annotation must include the 'H', 'M', and either 'S' or 's' (but not both) control characters. Formats for the 'datetime' annotation meet both the 'date' and 'time' control character requirements. For example, '"datetime" : "%m/%d/%Y %H:%M:%S" ' would be used to interpret text as "05/04/2000 12:12:11". </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a2550044df57f863f6ba90ba441b6b853">create\_table\_external\_datalake\_catalog</a>: Name of an existing datalake(iceberg) catalog used in loading files. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ab59e68fca69b51718f2d42c844f6b0f8">create\_table\_external\_datalake\_path</a>: Path of datalake(iceberg) object. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a333fc00320f9646d6ce9d8607bd1636d">create\_table\_external\_datalake\_snapshot</a>: Snapshot ID of datalake(iceberg) object. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#af9c1b76e77750429862f1aacb27d74fe">create\_table\_external\_error\_handling</a>: Specifies how errors should be handled upon insertion. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a177f9345e6f7506b65b8816300ec970c">create\_table\_external\_permissive</a>: Records with missing columns are populated with nulls if possible; otherwise, the malformed records are skipped. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a4f546b7f243e75507845c3c03c65cf43">create\_table\_external\_skip</a>: Malformed records are skipped. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a91bd540621245d89535180067b0ab5b5">create\_table\_external\_ignore\_bad\_records</a>: Deprecated. Alias for <a href="/content/api/cpp/namespacegpudb#a4f546b7f243e75507845c3c03c65cf43">skip</a>. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a8396f4ebffb3428ab67acddb4342f742">create\_table\_external\_abort</a>: Stops current insertion and aborts entire operation when an error is encountered. Primary key collisions are considered abortable errors in this mode. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a8396f4ebffb3428ab67acddb4342f742">create\_table\_external\_abort</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ae2a9483b364c1adeb9e461f5249ea3e4">create\_table\_external\_external\_table\_type</a>: Specifies whether the external table holds a local copy of the external data. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a8cafd996beb09c737f0965f6b810394c">create\_table\_external\_materialized</a>: Loads a copy of the external data into the database, refreshed on demand. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a20b68d34949cab333e638c4459119fb5">create\_table\_external\_logical</a>: External data will not be loaded into the database; the data will be retrieved from the source upon servicing each query against the external table. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a8cafd996beb09c737f0965f6b810394c">create\_table\_external\_materialized</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a178e68c97ed7ad584aaab835daa52297">create\_table\_external\_file\_type</a>: Specifies the type of the file(s) whose records will be inserted. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a885911e16966aa2d1989d1209323dfcc">create\_table\_external\_avro</a>: Avro file format. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a2962584ff6fefedf4b4e590d9bd6ed4e">create\_table\_external\_delimited\_text</a>: Delimited text file format; e.g., CSV, TSV, PSV, etc. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a233e8511dd974b82fec0a4cf583a3a6c">create\_table\_external\_gdb</a>: Esri/GDB file format. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a273d84c481353905dd6e202b4e0e9765">create\_table\_external\_json</a>: JSON file format. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a75afe036b83f75769efb66ac23e650f1">create\_table\_external\_parquet</a>: Apache Parquet file format. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad965f243f73ef163a409bc7ba5072005">create\_table\_external\_shapefile</a>: ShapeFile file format. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a2962584ff6fefedf4b4e590d9bd6ed4e">create\_table\_external\_delimited\_text</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#afecb87460052a2cac57af73ffce85ca1">create\_table\_external\_flatten\_columns</a>: Specifies how to handle nested columns. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a74ac0af48e9a17bf157856641b2a4ee1">create\_table\_external\_true</a>: Break up nested columns to multiple columns. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a7bf7ceb49435d162cfaa30d276956f31">create\_table\_external\_false</a>: Treat nested columns as JSON columns instead of flattening. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a7bf7ceb49435d162cfaa30d276956f31">create\_table\_external\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#ab152351c4cc8dc642762f7296691843c">create\_table\_external\_gdal\_configuration\_options</a>: Comma separated list of gdal conf options, for the specific requests: key=value. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ad17bbbd531ad3c9626b0a76b563a3cc8">create\_table\_external\_pk\_conflict\_predicate\_higher</a>: The record with higher value for the column resolves the primary-key insert conflict. The default value is ''. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a95838adf968c33ce1bbb3ff5ea7d058f">create\_table\_external\_pk\_conflict\_predicate\_lower</a>: The record with lower value for the column resolves the primary-key insert conflict. The default value is ''. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ac2d8ef4993943d481847a0802bbc18f5">create\_table\_external\_ignore\_existing\_pk</a>: Specifies the record collision error-suppression policy for inserting into a table with a <a href="/content/concepts/tables/#primary-keys">primary key</a>, only used when not in upsert mode (upsert mode is disabled when <a href="/content/api/cpp/namespacegpudb#a59970475a768bc8ff812c6190149b474">update\_on\_existing\_pk</a> is <a href="/content/api/cpp/namespacegpudb#a7bf7ceb49435d162cfaa30d276956f31">false</a>). If set to <a href="/content/api/cpp/namespacegpudb#a74ac0af48e9a17bf157856641b2a4ee1">true</a>, any record being inserted that is rejected for having primary key values that match those of an existing table record will be ignored with no error generated. If <a href="/content/api/cpp/namespacegpudb#a7bf7ceb49435d162cfaa30d276956f31">false</a>, the rejection of any record for having primary key values matching an existing record will result in an error being reported, as determined by <a href="/content/api/cpp/namespacegpudb#af9c1b76e77750429862f1aacb27d74fe">error\_handling</a>. If the specified table does not have a primary key or if upsert mode is in effect (<a href="/content/api/cpp/namespacegpudb#a59970475a768bc8ff812c6190149b474">update\_on\_existing\_pk</a> is <a href="/content/api/cpp/namespacegpudb#a74ac0af48e9a17bf157856641b2a4ee1">true</a>), then this option has no effect. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a74ac0af48e9a17bf157856641b2a4ee1">create\_table\_external\_true</a>: Ignore new records whose primary key values collide with those of existing records. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a7bf7ceb49435d162cfaa30d276956f31">create\_table\_external\_false</a>: Treat as errors any new records whose primary key values collide with those of existing records. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a7bf7ceb49435d162cfaa30d276956f31">create\_table\_external\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a436ed51fc20f87ca9f4cb38841617eeb">create\_table\_external\_ingestion\_mode</a>: Whether to do a full load, dry run, or perform a type inference on the source data. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#aee1afeba03340696867cf4817eae9494">create\_table\_external\_full</a>: Run a type inference on the source data (if needed) and ingest. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a6441cef2053cf9eb99019f4898691744">create\_table\_external\_dry\_run</a>: Does not load data, but walks through the source data and determines the number of valid records, taking into account the current mode of <a href="/content/api/cpp/namespacegpudb#af9c1b76e77750429862f1aacb27d74fe">error\_handling</a>. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a434ad9e487691a2f490b13a4c41419d7">create\_table\_external\_type\_inference\_only</a>: Infer the type of the source data and return, without ingesting any data. The inferred type is returned in the response. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#aee1afeba03340696867cf4817eae9494">create\_table\_external\_full</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a1c95426f566da2a70fde4333df9acbdb">create\_table\_external\_jdbc\_fetch\_size</a>: The JDBC fetch size, which determines how many rows to fetch per round trip. The default value is '50000'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ab9ab2e00a0517ea9941a86adfc9df057">create\_table\_external\_kafka\_consumers\_per\_rank</a>: Number of Kafka consumer threads per rank (valid range 1-6). The default value is '1'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a9960bc15a6b19cc0b609a2ce681a8bce">create\_table\_external\_kafka\_group\_id</a>: The group id to be used when consuming data from a Kafka topic (valid only for Kafka datasource subscriptions). </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a942f220b1652e0e6d1f5746674617d62">create\_table\_external\_kafka\_offset\_reset\_policy</a>: Policy to determine whether the Kafka data consumption starts either at earliest offset or latest offset. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a6a7e63433949f35696d87371919f31cd">create\_table\_external\_earliest</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad27391434237c1855da82b0f1e023523">create\_table\_external\_latest</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a6a7e63433949f35696d87371919f31cd">create\_table\_external\_earliest</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a2f329fec52de77614f12c5c2a3a244b4">create\_table\_external\_kafka\_optimistic\_ingest</a>: Enable optimistic ingestion where Kafka topic offsets and table data are committed independently to achieve parallelism. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a74ac0af48e9a17bf157856641b2a4ee1">create\_table\_external\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a7bf7ceb49435d162cfaa30d276956f31">create\_table\_external\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a7bf7ceb49435d162cfaa30d276956f31">create\_table\_external\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a69ecd65146fe5038dda24e7511cdff91">create\_table\_external\_kafka\_subscription\_cancel\_after</a>: Sets the Kafka subscription lifespan (in minutes). Expired subscription will be cancelled automatically. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a79a5e0b21bba5b500bd2afef1010b994">create\_table\_external\_kafka\_type\_inference\_fetch\_timeout</a>: Maximum time to collect Kafka messages before type inferencing on the set of them. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a619ba1d9529188d808124fc1604e4f8e">create\_table\_external\_layer</a>: Geo files layer(s) name(s): comma separated. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a76f7f969a8a2c5bc4fb5f7dcf96ecf07">create\_table\_external\_loading\_mode</a>: Scheme for distributing the extraction and loading of data from the source data file(s). This option applies only when loading files that are local to the database. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#acbb66cf3ef158ccc845856424b2069be">create\_table\_external\_head</a>: The head node loads all data. All files must be available to the head node. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a7a4ab8985c363e02926df4137847a3ec">create\_table\_external\_distributed\_shared</a>: The head node coordinates loading data by worker processes across all nodes from shared files available to all workers. NOTE: Instead of existing on a shared source, the files can be duplicated on a source local to each host to improve performance, though the files must appear as the same data set from the perspective of all hosts performing the load. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a9dedda6d35ebb43c2d9d8af6e927cb5b">create\_table\_external\_distributed\_local</a>: A single worker process on each node loads all files that are available to it. This option works best when each worker loads files from its own file system, to maximize performance. In order to avoid data duplication, either each worker performing the load needs to have visibility to a set of files unique to it (no file is visible to more than one node) or the target table needs to have a primary key (which will allow the worker to automatically deduplicate data). NOTE: If the target table doesn't exist, the table structure will be determined by the head node. If the head node has no files local to it, it will be unable to determine the structure and the request will fail. If the head node is configured to have no worker processes, no data strictly accessible to the head node will be loaded. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#acbb66cf3ef158ccc845856424b2069be">create\_table\_external\_head</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#ac08a8fc7dccbb258c888ce78c3901b7a">create\_table\_external\_local\_time\_offset</a>: Apply an offset to Avro local timestamp columns. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a25944417ae2a437020661ae12c79a94b">create\_table\_external\_max\_records\_to\_load</a>: Limit the number of records to load in this request: if this number is larger than <a href="/content/api/cpp/namespacegpudb#ad9c60ee90fd99f72f5227752f1116c85">batch\_size</a>, then the number of records loaded will be limited to the next whole number of <a href="/content/api/cpp/namespacegpudb#ad9c60ee90fd99f72f5227752f1116c85">batch\_size</a> (per working thread). </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a56eb1b921e8058949109bc451bf4610c">create\_table\_external\_name\_columns\_from\_file</a>: Specifies a comma-delimited list of column names to be used as the source-data column names. If the file has a header row (i.e., <a href="/content/api/cpp/namespacegpudb#acf2099b6030b751f27b2b1e134ccf5dc">text\_has\_header</a> is <a href="/content/api/cpp/namespacegpudb#a74ac0af48e9a17bf157856641b2a4ee1">true</a>), these names override the file's header names. If the file has no header row, these names are used as the source-data column names. Either way, the i-th name in this list applies to the i-th column in the file, enabling name-based matching against the target table's columns (and use with <a href="/content/api/cpp/namespacegpudb#acf013f75546646fd42c54b3a420f3390">columns\_to\_load</a> / <a href="/content/api/cpp/namespacegpudb#a0f8e79aac98d4b17242cde7cdc3c6389">columns\_to\_skip</a>). </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a203c159810c804bc653c888a3502f6bf">create\_table\_external\_num\_tasks\_per\_rank</a>: Number of tasks for reading file per rank. Default will be system configuration parameter, external\_file\_reader\_num\_tasks. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ac0a3738e6c1a9d765c5ffcfea5280130">create\_table\_external\_poll\_interval</a>: If <a href="/content/api/cpp/namespacegpudb#a74ac0af48e9a17bf157856641b2a4ee1">true</a>, the number of seconds between attempts to load external files into the table. If zero, polling will be continuous as long as data is found. If no data is found, the interval will steadily increase to a maximum of 60 seconds. The default value is '0'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ae867839e185166b1095aa5626649451e">create\_table\_external\_primary\_keys</a>: Comma separated list of column names to set as primary keys, when not specified in the type. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a4775a1e6c3ce899efded34ac5899103b">create\_table\_external\_refresh\_method</a>: Method by which the table can be refreshed from its source data. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a235392354a05fd4e41a09a83e7c5ead3">create\_table\_external\_manual</a>: Refresh only occurs when manually requested by invoking the refresh action of <a href="#a25df43fa85e02f0cdb3dab9e498995ce">alterTable</a> on this table. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a7ab17621b1d728e5ce593b30c16111e2">create\_table\_external\_on\_start</a>: Refresh table on database startup and when manually requested by invoking the refresh action of <a href="#a25df43fa85e02f0cdb3dab9e498995ce">alterTable</a> on this table. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a235392354a05fd4e41a09a83e7c5ead3">create\_table\_external\_manual</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a73595a2ad41ea7acab4a7c730e313423">create\_table\_external\_schema\_registry\_connection\_retries</a>: Confluent Schema registry connection timeout (in secs). </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a8d72d614eadb06606998f9d8ca20301e">create\_table\_external\_schema\_registry\_connection\_timeout</a>: Confluent Schema registry connection timeout (in secs). </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a72f12f05bcfe2a86be945ffd41501b91">create\_table\_external\_schema\_registry\_max\_consecutive\_connection\_failures</a>: Max records to skip due to SR connection failures, before failing. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a2a65e6cf6b0491a171cf2a9ba6f7e7d7">create\_table\_external\_max\_consecutive\_invalid\_schema\_failure</a>: Max records to skip due to schema related errors, before failing. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a422d1815fad489942fd7f0676d75f391">create\_table\_external\_schema\_registry\_schema\_name</a>: Name of the Avro schema in the schema registry to use when reading Avro records. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a892fd29330ba46649ad084b5114414e4">create\_table\_external\_shard\_keys</a>: Comma separated list of column names to set as shard keys, when not specified in the type. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a6dd75878ad8c2ebce787389a573c742f">create\_table\_external\_skip\_lines</a>: Skip a number of lines from the beginning of the file. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a57b84b771783bcb75babf18577e3b655">create\_table\_external\_start\_offsets</a>: Starting offsets by partition to fetch from kafka. A comma separated list of partition:offset pairs. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a7e233debd2960b19635177b24d5acaf8">create\_table\_external\_subscribe</a>: Continuously poll the data source to check for new data and load it into the table. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a74ac0af48e9a17bf157856641b2a4ee1">create\_table\_external\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a7bf7ceb49435d162cfaa30d276956f31">create\_table\_external\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a7bf7ceb49435d162cfaa30d276956f31">create\_table\_external\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a9e8c328ad6e067daf7b90ded81b6352a">create\_table\_external\_table\_insert\_mode</a>: Insertion scheme to use when inserting records from multiple shapefiles. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a7327acc86a9445e624dea5a4dd00f855">create\_table\_external\_single</a>: Insert all records into a single table. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a9eaa52277342f80d8e055380e5b56659">create\_table\_external\_table\_per\_file</a>: Insert records from each file into a new table corresponding to that file. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a7327acc86a9445e624dea5a4dd00f855">create\_table\_external\_single</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a8ab0d48b8b2e90841ce730f44c3f746b">create\_table\_external\_text\_comment\_string</a>: Specifies the character string that should be interpreted as a comment line prefix in the source data. All lines in the data starting with the provided string are ignored. For <a href="/content/api/cpp/namespacegpudb#a2962584ff6fefedf4b4e590d9bd6ed4e">delimited\_text</a> <a href="/content/api/cpp/namespacegpudb#a178e68c97ed7ad584aaab835daa52297">file\_type</a> only. The default value is '#'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a94f6a5e1a80c3eeaedabbc14d9c9f632">create\_table\_external\_text\_delimiter</a>: Specifies the character delimiting field values in the source data and field names in the header (if present). For <a href="/content/api/cpp/namespacegpudb#a2962584ff6fefedf4b4e590d9bd6ed4e">delimited\_text</a> <a href="/content/api/cpp/namespacegpudb#a178e68c97ed7ad584aaab835daa52297">file\_type</a> only. The default value is ','. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ae313bc0f07e239df2a5af1119dac74de">create\_table\_external\_text\_escape\_character</a>: Specifies the character that is used to escape other characters in the source data. An 'a', 'b', 'f', 'n', 'r', 't', or 'v' preceded by an escape character will be interpreted as the ASCII bell, backspace, form feed, line feed, carriage return, horizontal tab, and vertical tab, respectively. For example, the escape character followed by an 'n' will be interpreted as a newline within a field value. The escape character can also be used to escape the quoting character, and will be treated as an escape character whether it is within a quoted field value or not. For <a href="/content/api/cpp/namespacegpudb#a2962584ff6fefedf4b4e590d9bd6ed4e">delimited\_text</a> <a href="/content/api/cpp/namespacegpudb#a178e68c97ed7ad584aaab835daa52297">file\_type</a> only. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#acf2099b6030b751f27b2b1e134ccf5dc">create\_table\_external\_text\_has\_header</a>: Indicates whether the source data contains a header row. For <a href="/content/api/cpp/namespacegpudb#a2962584ff6fefedf4b4e590d9bd6ed4e">delimited\_text</a><a href="/content/api/cpp/namespacegpudb#a178e68c97ed7ad584aaab835daa52297">file\_type</a> only. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a74ac0af48e9a17bf157856641b2a4ee1">create\_table\_external\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a7bf7ceb49435d162cfaa30d276956f31">create\_table\_external\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a74ac0af48e9a17bf157856641b2a4ee1">create\_table\_external\_true</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#af59c4fd330c8b3fc44bc04d1dc917bdb">create\_table\_external\_text\_header\_property\_delimiter</a>: Specifies the delimiter for <a href="/content/concepts/types/#column-properties">column properties</a> in the header row (if present). Cannot be set to same value as <a href="/content/api/cpp/namespacegpudb#a94f6a5e1a80c3eeaedabbc14d9c9f632">text\_delimiter</a>. For <a href="/content/api/cpp/namespacegpudb#a2962584ff6fefedf4b4e590d9bd6ed4e">delimited\_text</a> <a href="/content/api/cpp/namespacegpudb#a178e68c97ed7ad584aaab835daa52297">file\_type</a> only. The default value is '|'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#adbb252f3491ecbfe457c206fa2bfdaac">create\_table\_external\_text\_null\_string</a>: Specifies the character string that should be interpreted as a null value in the source data. For <a href="/content/api/cpp/namespacegpudb#a2962584ff6fefedf4b4e590d9bd6ed4e">delimited\_text</a> <a href="/content/api/cpp/namespacegpudb#a178e68c97ed7ad584aaab835daa52297">file\_type</a> only. The default value is '\N'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#afdea1531cb86d2285b1d9c3e67eab21a">create\_table\_external\_text\_quote\_character</a>: Specifies the character that should be interpreted as a field value quoting character in the source data. The character must appear at beginning and end of field value to take effect. Delimiters within quoted fields are treated as literals and not delimiters. Within a quoted field, two consecutive quote characters will be interpreted as a single literal quote character, effectively escaping it. To not have a quote character, specify an empty string. For <a href="/content/api/cpp/namespacegpudb#a2962584ff6fefedf4b4e590d9bd6ed4e">delimited\_text</a> <a href="/content/api/cpp/namespacegpudb#a178e68c97ed7ad584aaab835daa52297">file\_type</a> only. The default value is '"'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a41b4c1f98ae28d26e8b8e0e092343e9c">create\_table\_external\_text\_search\_columns</a>: Add 'text\_search' property to internally inferenced string columns. Comma separated list of column names or '\*' for all columns. To add 'text\_search' property only to string columns greater than or equal to a minimum size, also set the <a href="/content/api/cpp/namespacegpudb#ad34b1babf7c2b1e67ff8bb2638790287">text\_search\_min\_column\_length</a> </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ad34b1babf7c2b1e67ff8bb2638790287">create\_table\_external\_text\_search\_min\_column\_length</a>: Set the minimum column size for strings to apply the 'text\_search' property to. Used only when <a href="/content/api/cpp/namespacegpudb#a41b4c1f98ae28d26e8b8e0e092343e9c">text\_search\_columns</a> has a value. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a7fd0612904a547e5040d34b1ea77e053">create\_table\_external\_transformations</a>: Comma-separated expressions, one per target table column. Each expression is evaluated per record. Empty entries (two consecutive commas) mean no transformation for that column – the value is resolved from the input record, table default, NULL, or an error. Expressions may reference input columns by name or by position ($1 for the first input column, $2 for the second, etc.). The default value is ''. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#acf364b97c28f8fb87d9ad0f7aed3f05e">create\_table\_external\_trim\_space</a>: If set to <a href="/content/api/cpp/namespacegpudb#a74ac0af48e9a17bf157856641b2a4ee1">true</a>, remove leading or trailing space from fields. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a74ac0af48e9a17bf157856641b2a4ee1">create\_table\_external\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a7bf7ceb49435d162cfaa30d276956f31">create\_table\_external\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a7bf7ceb49435d162cfaa30d276956f31">create\_table\_external\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ac069b52aab48bf37a43078157cad490b">create\_table\_external\_truncate\_strings</a>: If set to <a href="/content/api/cpp/namespacegpudb#a74ac0af48e9a17bf157856641b2a4ee1">true</a>, truncate string values that are longer than the column's type size. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a74ac0af48e9a17bf157856641b2a4ee1">create\_table\_external\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a7bf7ceb49435d162cfaa30d276956f31">create\_table\_external\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a7bf7ceb49435d162cfaa30d276956f31">create\_table\_external\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a7fce1e8894572333f6b4acb6f93e7847">create\_table\_external\_truncate\_table</a>: If set to <a href="/content/api/cpp/namespacegpudb#a74ac0af48e9a17bf157856641b2a4ee1">true</a>, truncates the table specified by <span>tableName</span> prior to loading the file(s). Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a74ac0af48e9a17bf157856641b2a4ee1">create\_table\_external\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a7bf7ceb49435d162cfaa30d276956f31">create\_table\_external\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a7bf7ceb49435d162cfaa30d276956f31">create\_table\_external\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#adb01822f89a05c655110f84723aca118">create\_table\_external\_type\_inference\_max\_records\_read</a> </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a1002f2593efe41ced99e06868def2d4a">create\_table\_external\_type\_inference\_mode</a>: Optimize type inferencing for either speed or accuracy. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a29c4fc02a0a8c31ee61ac344569ecc71">create\_table\_external\_accuracy</a>: Scans data to get exactly-typed and sized columns for all data scanned. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aee53262c449fbe883ab2f1afbac0f6bb">create\_table\_external\_speed</a>: Scans data and picks the widest possible column types so that 'all' values will fit with minimum data scanned. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#aee53262c449fbe883ab2f1afbac0f6bb">create\_table\_external\_speed</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a72b7161022d11281d3e84c3feb610caa">create\_table\_external\_remote\_query</a>: Remote SQL query from which data will be sourced. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ad793613c9ae3ed4b091a169bbc17b5f0">create\_table\_external\_remote\_query\_filter\_column</a>: Name of column to be used for splitting <a href="/content/api/cpp/namespacegpudb#a72b7161022d11281d3e84c3feb610caa">remote\_query</a> into multiple sub-queries using the data distribution of given column. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a2560cc1fa35a63f0fa1aedf5fd628b1f">create\_table\_external\_remote\_query\_increasing\_column</a>: Column on subscribed remote query result that will increase for new records (e.g., TIMESTAMP). </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a35b5cc2eb9e332b2586f148a22ad784d">create\_table\_external\_remote\_query\_partition\_column</a>: Alias name for <a href="/content/api/cpp/namespacegpudb#ad793613c9ae3ed4b091a169bbc17b5f0">remote\_query\_filter\_column</a>. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a3b50a0a5d94afd655f5f9ad8a7648f95">create\_table\_external\_enable\_inplace\_updates</a>: Applies only when upserting (when update\_on\_existing\_pk is true). If set to true (the default), an existing record matched by primary key is modified in place. If set to false, the matched record is updated by deleting it and inserting a replacement (delete and insert), which prevents the change from being reflected in dependent materialized views until they are refreshed. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a74ac0af48e9a17bf157856641b2a4ee1">create\_table\_external\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a7bf7ceb49435d162cfaa30d276956f31">create\_table\_external\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a74ac0af48e9a17bf157856641b2a4ee1">create\_table\_external\_true</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a59970475a768bc8ff812c6190149b474">create\_table\_external\_update\_on\_existing\_pk</a>: Specifies the record collision policy for inserting into a table with a <a href="/content/concepts/tables/#primary-keys">primary key</a>. If set to <a href="/content/api/cpp/namespacegpudb#a74ac0af48e9a17bf157856641b2a4ee1">true</a>, any existing table record with primary key values that match those of a record being inserted will be replaced by that new record (the new data will be 'upserted'). If set to <a href="/content/api/cpp/namespacegpudb#a7bf7ceb49435d162cfaa30d276956f31">false</a>, any existing table record with primary key values that match those of a record being inserted will remain unchanged, while the new record will be rejected and the error handled as determined by <a href="/content/api/cpp/namespacegpudb#ac2d8ef4993943d481847a0802bbc18f5">ignore\_existing\_pk</a> and <a href="/content/api/cpp/namespacegpudb#af9c1b76e77750429862f1aacb27d74fe">error\_handling</a>. If the specified table does not have a primary key, then this option has no effect. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a74ac0af48e9a17bf157856641b2a4ee1">create\_table\_external\_true</a>: Upsert new records when primary keys match existing records. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a7bf7ceb49435d162cfaa30d276956f31">create\_table\_external\_false</a>: Reject new records when primary keys match existing records. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a7bf7ceb49435d162cfaa30d276956f31">create\_table\_external\_false</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CreateTableExternalResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CreateTableExternalResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ab379d6656d94cb2e54be2671ecd05d6c">◆ </a></span>createTableMonitor() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CreateTableMonitorResponse">CreateTableMonitorResponse</a> gpudb::GPUdb::createTableMonitor </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1CreateTableMonitorRequest">CreateTableMonitorRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Creates a monitor that watches for a single table modification event type (insert, update, or delete) on a particular table (identified by <a href="/content/api/cpp/structgpudb_1_1CreateTableMonitorRequest#a0e8f2441270fcee8e907355690991ec4">tableName</a>) and forwards event notifications to subscribers via ZMQ. </p>
        <p>After this call completes, subscribe to the returned <a href="/content/api/cpp/structgpudb_1_1CreateTableMonitorResponse#a4498d9c99e9502363ab4e63d7b0c998a">topicId</a> on the ZMQ table monitor port (default 9002). Each time an operation of the given type on the table completes, a multipart message is published for that topic; the first part contains only the topic ID, and each subsequent part contains one binary-encoded Avro object that corresponds to the event and can be decoded using <a href="/content/api/cpp/structgpudb_1_1CreateTableMonitorResponse#aa168cadead6d2e3ed252e54c25f6fbe1">typeSchema</a>. The monitor will continue to run (regardless of whether or not there are any subscribers) until deactivated with <a href="#ad2bf08c0671686d9fd13ec177214fa1c">clearTableMonitor</a>.</p>
        <p>For more information on table monitors, see <a href="/content/concepts/table_monitors/">Table Monitors</a>.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CreateTableMonitorRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CreateTableMonitorResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a0efddb12766e77b5014d575272644633">◆ </a></span>createTableMonitor() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CreateTableMonitorResponse">CreateTableMonitorResponse</a> & gpudb::GPUdb::createTableMonitor </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1CreateTableMonitorRequest">CreateTableMonitorRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1CreateTableMonitorResponse">CreateTableMonitorResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Creates a monitor that watches for a single table modification event type (insert, update, or delete) on a particular table (identified by <a href="/content/api/cpp/structgpudb_1_1CreateTableMonitorRequest#a0e8f2441270fcee8e907355690991ec4">tableName</a>) and forwards event notifications to subscribers via ZMQ. </p>
        <p>After this call completes, subscribe to the returned <a href="/content/api/cpp/structgpudb_1_1CreateTableMonitorResponse#a4498d9c99e9502363ab4e63d7b0c998a">topicId</a> on the ZMQ table monitor port (default 9002). Each time an operation of the given type on the table completes, a multipart message is published for that topic; the first part contains only the topic ID, and each subsequent part contains one binary-encoded Avro object that corresponds to the event and can be decoded using <a href="/content/api/cpp/structgpudb_1_1CreateTableMonitorResponse#aa168cadead6d2e3ed252e54c25f6fbe1">typeSchema</a>. The monitor will continue to run (regardless of whether or not there are any subscribers) until deactivated with <a href="#ad2bf08c0671686d9fd13ec177214fa1c">clearTableMonitor</a>.</p>
        <p>For more information on table monitors, see <a href="/content/concepts/table_monitors/">Table Monitors</a>.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CreateTableMonitorRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CreateTableMonitorResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CreateTableMonitorResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a562dc443f79f57ea572cb5ec0f2e8093">◆ </a></span>createTableMonitor() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CreateTableMonitorResponse">CreateTableMonitorResponse</a> gpudb::GPUdb::createTableMonitor </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Creates a monitor that watches for a single table modification event type (insert, update, or delete) on a particular table (identified by <span>tableName</span>) and forwards event notifications to subscribers via ZMQ. </p>
        <p>After this call completes, subscribe to the returned <a href="/content/api/cpp/structgpudb_1_1CreateTableMonitorResponse#a4498d9c99e9502363ab4e63d7b0c998a">topicId</a> on the ZMQ table monitor port (default 9002). Each time an operation of the given type on the table completes, a multipart message is published for that topic; the first part contains only the topic ID, and each subsequent part contains one binary-encoded Avro object that corresponds to the event and can be decoded using <a href="/content/api/cpp/structgpudb_1_1CreateTableMonitorResponse#aa168cadead6d2e3ed252e54c25f6fbe1">typeSchema</a>. The monitor will continue to run (regardless of whether or not there are any subscribers) until deactivated with <a href="#ad85f24dc8ca9ac3d649aaa969febcf25">clearTableMonitor</a>.</p>
        <p>For more information on table monitors, see <a href="/content/concepts/table_monitors/">Table Monitors</a>.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of the table to monitor, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a135e0633be241008715990221ac0495a">create\_table\_monitor\_event</a>: <a href="/content/api/cpp/classgpudb_1_1Type">Type</a> of modification event on the target table to be monitored by this table monitor. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad34e70b72e3397c92a500cb8201ddf07">create\_table\_monitor\_insert</a>: Get notifications of new record insertions. The new row images are forwarded to the subscribers. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a683f1dacbbb8985389e3699e8dc6718b">create\_table\_monitor\_update</a>: Get notifications of update operations. The modified row count information is forwarded to the subscribers. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a2b47127043d14274d25aac538b3fa69e">create\_table\_monitor\_delete</a>: Get notifications of delete operations. The deleted row count information is forwarded to the subscribers. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ad34e70b72e3397c92a500cb8201ddf07">create\_table\_monitor\_insert</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#aaba6dfd6afeb3f9c248c3dbae68f9adb">create\_table\_monitor\_monitor\_id</a>: ID to use for this monitor instead of a randomly generated one. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a06251099009a5e7b8ceb2fc4f0668fda">create\_table\_monitor\_datasink\_name</a>: Name of an existing <a href="/content/concepts/data_sinks/">data sink</a> to send change data notifications to. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a21aba3472f4b1175e6bdef2d687e8181">create\_table\_monitor\_max\_consecutive\_failures</a>: Maximum number of consecutive failed notification attempts before suspending the stream. A value of -1 (default) disables auto-suspend. This value is by rank and not overall. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ad928e8ce43122c6aba90e31f7b304328">create\_table\_monitor\_failed\_notifications\_table\_name</a>: Name of a <a href="/content/concepts/tables/">table</a> to which failed stream notifications are written when the stream is suspended. The database will attempt to send notifications persisted in this table when the stream is resumed. The table has the following columns: rank (long), job\_id (long), uuid (uuid), timestamp (timestamp), error\_msg (string), payload (bytes). Leave this option empty to disable persisting failed notification events. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#adb584a371ba88fa4eb2ae16d94a3c366">create\_table\_monitor\_destination</a>: Destination for the output data in format 'destination\_type://path\[:port]'. Supported destination types are 'http', 'https' and 'kafka'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a03839aaa51c1c757ee367e370d00faa4">create\_table\_monitor\_kafka\_topic\_name</a>: Name of the Kafka topic to publish to if <a href="/content/api/cpp/namespacegpudb#adb584a371ba88fa4eb2ae16d94a3c366">destination</a> in <span>options</span> is specified and is a Kafka broker. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a3e72f2f1e0f424dc98bef24fa49eb152">create\_table\_monitor\_increasing\_column</a>: Column on subscribed table that will increase for new records (e.g., TIMESTAMP). </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a1980694b070a96500ac2b08dc2096907">create\_table\_monitor\_expression</a>: Filter expression to limit records for notification. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ae536704522694dbe7c1a161fa5e8a3e9">create\_table\_monitor\_join\_table\_names</a>: A comma-separated list of tables (optionally with aliases) to include in the join. The monitored table <span>tableName</span> must be included, representing only the newly inserted rows (deltas) since the last notification. Other tables can be any existing tables or views. Aliases can be used with the 'table\_name as alias' syntax. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a67e45db37527e8ce933b1c89f11ebcb8">create\_table\_monitor\_join\_column\_names</a>: A comma-separated list of columns or expressions to include from the joined tables. Column references can use table names or aliases defined in 'join\_table\_names'. Each column can optionally be aliased using 'as'. The selected columns will also appear in the notification output. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a681bf238163c72f640502cb191abba50">create\_table\_monitor\_join\_expressions</a>: Filter or join expressions to apply when combining the tables. Expressions are standard SQL-style conditions and can reference any table or alias listed in 'join\_table\_names'. This corresponds to the WHERE clause of the underlying join, and can include conditions to filter the delta rows. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ab8e4dd01b0a783ac97539226d8aca2a4">create\_table\_monitor\_refresh\_method</a>: Method controlling when the table monitor reports changes to the <span>tableName</span>. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a3ead863f17f673afd2488d57db643c25">create\_table\_monitor\_on\_change</a>: Report changes as they occur. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a7ed69c26a0ee0e14af20a34c3b6a6a4b">create\_table\_monitor\_periodic</a>: Report changes periodically at rate specified by <a href="/content/api/cpp/namespacegpudb#aada545fed7ec124f5a431391ae428a3c">refresh\_period</a>. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a3ead863f17f673afd2488d57db643c25">create\_table\_monitor\_on\_change</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#aada545fed7ec124f5a431391ae428a3c">create\_table\_monitor\_refresh\_period</a>: When <a href="/content/api/cpp/namespacegpudb#ab8e4dd01b0a783ac97539226d8aca2a4">refresh\_method</a> is <a href="/content/api/cpp/namespacegpudb#a7ed69c26a0ee0e14af20a34c3b6a6a4b">periodic</a>, specifies the period in seconds at which changes are reported. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a409c9238bc4f2d6b19093b6433984a92">create\_table\_monitor\_refresh\_start\_time</a>: When <a href="/content/api/cpp/namespacegpudb#ab8e4dd01b0a783ac97539226d8aca2a4">refresh\_method</a> is <a href="/content/api/cpp/namespacegpudb#a7ed69c26a0ee0e14af20a34c3b6a6a4b">periodic</a>, specifies the first time at which changes are reported. Value is a datetime string with format 'YYYY-MM-DD HH:MM:SS'. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CreateTableMonitorResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a2cd20ebde22e894c8d7ccb47f4af4fb4">◆ </a></span>createTableMonitor() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CreateTableMonitorResponse">CreateTableMonitorResponse</a> & gpudb::GPUdb::createTableMonitor </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1CreateTableMonitorResponse">CreateTableMonitorResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Creates a monitor that watches for a single table modification event type (insert, update, or delete) on a particular table (identified by <span>tableName</span>) and forwards event notifications to subscribers via ZMQ. </p>
        <p>After this call completes, subscribe to the returned <a href="/content/api/cpp/structgpudb_1_1CreateTableMonitorResponse#a4498d9c99e9502363ab4e63d7b0c998a">topicId</a> on the ZMQ table monitor port (default 9002). Each time an operation of the given type on the table completes, a multipart message is published for that topic; the first part contains only the topic ID, and each subsequent part contains one binary-encoded Avro object that corresponds to the event and can be decoded using <a href="/content/api/cpp/structgpudb_1_1CreateTableMonitorResponse#aa168cadead6d2e3ed252e54c25f6fbe1">typeSchema</a>. The monitor will continue to run (regardless of whether or not there are any subscribers) until deactivated with <a href="#ad85f24dc8ca9ac3d649aaa969febcf25">clearTableMonitor</a>.</p>
        <p>For more information on table monitors, see <a href="/content/concepts/table_monitors/">Table Monitors</a>.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of the table to monitor, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a135e0633be241008715990221ac0495a">create\_table\_monitor\_event</a>: <a href="/content/api/cpp/classgpudb_1_1Type">Type</a> of modification event on the target table to be monitored by this table monitor. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad34e70b72e3397c92a500cb8201ddf07">create\_table\_monitor\_insert</a>: Get notifications of new record insertions. The new row images are forwarded to the subscribers. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a683f1dacbbb8985389e3699e8dc6718b">create\_table\_monitor\_update</a>: Get notifications of update operations. The modified row count information is forwarded to the subscribers. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a2b47127043d14274d25aac538b3fa69e">create\_table\_monitor\_delete</a>: Get notifications of delete operations. The deleted row count information is forwarded to the subscribers. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ad34e70b72e3397c92a500cb8201ddf07">create\_table\_monitor\_insert</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#aaba6dfd6afeb3f9c248c3dbae68f9adb">create\_table\_monitor\_monitor\_id</a>: ID to use for this monitor instead of a randomly generated one. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a06251099009a5e7b8ceb2fc4f0668fda">create\_table\_monitor\_datasink\_name</a>: Name of an existing <a href="/content/concepts/data_sinks/">data sink</a> to send change data notifications to. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a21aba3472f4b1175e6bdef2d687e8181">create\_table\_monitor\_max\_consecutive\_failures</a>: Maximum number of consecutive failed notification attempts before suspending the stream. A value of -1 (default) disables auto-suspend. This value is by rank and not overall. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ad928e8ce43122c6aba90e31f7b304328">create\_table\_monitor\_failed\_notifications\_table\_name</a>: Name of a <a href="/content/concepts/tables/">table</a> to which failed stream notifications are written when the stream is suspended. The database will attempt to send notifications persisted in this table when the stream is resumed. The table has the following columns: rank (long), job\_id (long), uuid (uuid), timestamp (timestamp), error\_msg (string), payload (bytes). Leave this option empty to disable persisting failed notification events. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#adb584a371ba88fa4eb2ae16d94a3c366">create\_table\_monitor\_destination</a>: Destination for the output data in format 'destination\_type://path\[:port]'. Supported destination types are 'http', 'https' and 'kafka'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a03839aaa51c1c757ee367e370d00faa4">create\_table\_monitor\_kafka\_topic\_name</a>: Name of the Kafka topic to publish to if <a href="/content/api/cpp/namespacegpudb#adb584a371ba88fa4eb2ae16d94a3c366">destination</a> in <span>options</span> is specified and is a Kafka broker. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a3e72f2f1e0f424dc98bef24fa49eb152">create\_table\_monitor\_increasing\_column</a>: Column on subscribed table that will increase for new records (e.g., TIMESTAMP). </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a1980694b070a96500ac2b08dc2096907">create\_table\_monitor\_expression</a>: Filter expression to limit records for notification. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ae536704522694dbe7c1a161fa5e8a3e9">create\_table\_monitor\_join\_table\_names</a>: A comma-separated list of tables (optionally with aliases) to include in the join. The monitored table <span>tableName</span> must be included, representing only the newly inserted rows (deltas) since the last notification. Other tables can be any existing tables or views. Aliases can be used with the 'table\_name as alias' syntax. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a67e45db37527e8ce933b1c89f11ebcb8">create\_table\_monitor\_join\_column\_names</a>: A comma-separated list of columns or expressions to include from the joined tables. Column references can use table names or aliases defined in 'join\_table\_names'. Each column can optionally be aliased using 'as'. The selected columns will also appear in the notification output. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a681bf238163c72f640502cb191abba50">create\_table\_monitor\_join\_expressions</a>: Filter or join expressions to apply when combining the tables. Expressions are standard SQL-style conditions and can reference any table or alias listed in 'join\_table\_names'. This corresponds to the WHERE clause of the underlying join, and can include conditions to filter the delta rows. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ab8e4dd01b0a783ac97539226d8aca2a4">create\_table\_monitor\_refresh\_method</a>: Method controlling when the table monitor reports changes to the <span>tableName</span>. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a3ead863f17f673afd2488d57db643c25">create\_table\_monitor\_on\_change</a>: Report changes as they occur. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a7ed69c26a0ee0e14af20a34c3b6a6a4b">create\_table\_monitor\_periodic</a>: Report changes periodically at rate specified by <a href="/content/api/cpp/namespacegpudb#aada545fed7ec124f5a431391ae428a3c">refresh\_period</a>. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a3ead863f17f673afd2488d57db643c25">create\_table\_monitor\_on\_change</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#aada545fed7ec124f5a431391ae428a3c">create\_table\_monitor\_refresh\_period</a>: When <a href="/content/api/cpp/namespacegpudb#ab8e4dd01b0a783ac97539226d8aca2a4">refresh\_method</a> is <a href="/content/api/cpp/namespacegpudb#a7ed69c26a0ee0e14af20a34c3b6a6a4b">periodic</a>, specifies the period in seconds at which changes are reported. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a409c9238bc4f2d6b19093b6433984a92">create\_table\_monitor\_refresh\_start\_time</a>: When <a href="/content/api/cpp/namespacegpudb#ab8e4dd01b0a783ac97539226d8aca2a4">refresh\_method</a> is <a href="/content/api/cpp/namespacegpudb#a7ed69c26a0ee0e14af20a34c3b6a6a4b">periodic</a>, specifies the first time at which changes are reported. Value is a datetime string with format 'YYYY-MM-DD HH:MM:SS'. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CreateTableMonitorResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CreateTableMonitorResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a69d7d88cd6f9cdad1145d3ba6a4b575f">◆ </a></span>createTriggerByArea() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CreateTriggerByAreaResponse">CreateTriggerByAreaResponse</a> gpudb::GPUdb::createTriggerByArea </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1CreateTriggerByAreaRequest">CreateTriggerByAreaRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Sets up an area trigger mechanism for two column\_names for one or more tables. </p>
        <p>(This function is essentially the two-dimensional version of <a href="#aa77f37d9c9d2aa51450c6831584aa942">createTriggerByRange</a>.) Once the trigger has been activated, any record added to the listed tables(s) via <a href="#ab6ab327611452cc777c159d202146997">insertRecords</a> with the chosen columns' values falling within the specified region will trip the trigger. All such records will be queued at the trigger port (by default '9001' but able to be retrieved via <a href="#abe9a7d6ea3fe0b154d73b86955db53cb">showSystemStatus</a>) for any listening client to collect. Active triggers can be cancelled by using the <a href="#a158a4cbcafb96ac8832f7caeeb07e4b3">clearTrigger</a> endpoint or by clearing all relevant tables.</p>
        <p>The output returns the trigger handle as well as indicating success or failure of the trigger activation.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CreateTriggerByAreaRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CreateTriggerByAreaResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a357880c27d0836142fb17b2369720716">◆ </a></span>createTriggerByArea() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CreateTriggerByAreaResponse">CreateTriggerByAreaResponse</a> & gpudb::GPUdb::createTriggerByArea </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1CreateTriggerByAreaRequest">CreateTriggerByAreaRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1CreateTriggerByAreaResponse">CreateTriggerByAreaResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Sets up an area trigger mechanism for two column\_names for one or more tables. </p>
        <p>(This function is essentially the two-dimensional version of <a href="#aa77f37d9c9d2aa51450c6831584aa942">createTriggerByRange</a>.) Once the trigger has been activated, any record added to the listed tables(s) via <a href="#ab6ab327611452cc777c159d202146997">insertRecords</a> with the chosen columns' values falling within the specified region will trip the trigger. All such records will be queued at the trigger port (by default '9001' but able to be retrieved via <a href="#abe9a7d6ea3fe0b154d73b86955db53cb">showSystemStatus</a>) for any listening client to collect. Active triggers can be cancelled by using the <a href="#a158a4cbcafb96ac8832f7caeeb07e4b3">clearTrigger</a> endpoint or by clearing all relevant tables.</p>
        <p>The output returns the trigger handle as well as indicating success or failure of the trigger activation.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CreateTriggerByAreaRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CreateTriggerByAreaResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CreateTriggerByAreaResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a3d85ea830f5909e01b6888e53167bbc7">◆ </a></span>createTriggerByArea() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CreateTriggerByAreaResponse">CreateTriggerByAreaResponse</a> gpudb::GPUdb::createTriggerByArea </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>requestId</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< std::string > &</td>
            <td><span><span>tableNames</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>xColumnName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< double > &</td>
            <td><span><span>xVector</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>yColumnName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< double > &</td>
            <td><span><span>yVector</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Sets up an area trigger mechanism for two column\_names for one or more tables. </p>
        <p>(This function is essentially the two-dimensional version of <a href="#aa331f41ea50603fee702f9606cffebb4">createTriggerByRange</a>.) Once the trigger has been activated, any record added to the listed tables(s) via <a href="#a1cbbfefa7a3d6b4570f1be6734a8d849">insertRecords</a> with the chosen columns' values falling within the specified region will trip the trigger. All such records will be queued at the trigger port (by default '9001' but able to be retrieved via <a href="#a2cc190f96524c44227af5731319ad4e1">showSystemStatus</a>) for any listening client to collect. Active triggers can be cancelled by using the <a href="#a582553240e7015f44ae86078ec533a85">clearTrigger</a> endpoint or by clearing all relevant tables.</p>
        <p>The output returns the trigger handle as well as indicating success or failure of the trigger activation.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>requestId</td>
                <td>User-created ID for the trigger. The ID can be alphanumeric, contain symbols, and must contain at least one character. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>tableNames</td>
                <td>Names of the tables on which the trigger will be activated and maintained, each in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>xColumnName</td>
                <td>Name of a numeric column on which the trigger is activated. Usually 'x' for geospatial data points. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>xVector</td>
                <td>The respective coordinate values for the region on which the trigger is activated. This usually translates to the x-coordinates of a geospatial region. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>yColumnName</td>
                <td>Name of a second numeric column on which the trigger is activated. Usually 'y' for geospatial data points. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>yVector</td>
                <td>The respective coordinate values for the region on which the trigger is activated. This usually translates to the y-coordinates of a geospatial region. Must be the same length as xvals. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CreateTriggerByAreaResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a31add72aae86cd249dfdd622c161bb37">◆ </a></span>createTriggerByArea() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CreateTriggerByAreaResponse">CreateTriggerByAreaResponse</a> & gpudb::GPUdb::createTriggerByArea </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>requestId</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< std::string > &</td>
            <td><span><span>tableNames</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>xColumnName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< double > &</td>
            <td><span><span>xVector</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>yColumnName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< double > &</td>
            <td><span><span>yVector</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1CreateTriggerByAreaResponse">CreateTriggerByAreaResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Sets up an area trigger mechanism for two column\_names for one or more tables. </p>
        <p>(This function is essentially the two-dimensional version of <a href="#aa331f41ea50603fee702f9606cffebb4">createTriggerByRange</a>.) Once the trigger has been activated, any record added to the listed tables(s) via <a href="#a1cbbfefa7a3d6b4570f1be6734a8d849">insertRecords</a> with the chosen columns' values falling within the specified region will trip the trigger. All such records will be queued at the trigger port (by default '9001' but able to be retrieved via <a href="#a2cc190f96524c44227af5731319ad4e1">showSystemStatus</a>) for any listening client to collect. Active triggers can be cancelled by using the <a href="#a582553240e7015f44ae86078ec533a85">clearTrigger</a> endpoint or by clearing all relevant tables.</p>
        <p>The output returns the trigger handle as well as indicating success or failure of the trigger activation.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>requestId</td>
                <td>User-created ID for the trigger. The ID can be alphanumeric, contain symbols, and must contain at least one character. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>tableNames</td>
                <td>Names of the tables on which the trigger will be activated and maintained, each in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>xColumnName</td>
                <td>Name of a numeric column on which the trigger is activated. Usually 'x' for geospatial data points. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>xVector</td>
                <td>The respective coordinate values for the region on which the trigger is activated. This usually translates to the x-coordinates of a geospatial region. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>yColumnName</td>
                <td>Name of a second numeric column on which the trigger is activated. Usually 'y' for geospatial data points. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>yVector</td>
                <td>The respective coordinate values for the region on which the trigger is activated. This usually translates to the y-coordinates of a geospatial region. Must be the same length as xvals. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CreateTriggerByAreaResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CreateTriggerByAreaResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#aa77f37d9c9d2aa51450c6831584aa942">◆ </a></span>createTriggerByRange() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CreateTriggerByRangeResponse">CreateTriggerByRangeResponse</a> gpudb::GPUdb::createTriggerByRange </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1CreateTriggerByRangeRequest">CreateTriggerByRangeRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Sets up a simple range trigger for a column\_name for one or more tables. </p>
        <p>Once the trigger has been activated, any record added to the listed tables(s) via <a href="#ab6ab327611452cc777c159d202146997">insertRecords</a> with the chosen column\_name's value falling within the specified range will trip the trigger. All such records will be queued at the trigger port (by default '9001' but able to be retrieved via <a href="#abe9a7d6ea3fe0b154d73b86955db53cb">showSystemStatus</a>) for any listening client to collect. Active triggers can be cancelled by using the <a href="#a158a4cbcafb96ac8832f7caeeb07e4b3">clearTrigger</a> endpoint or by clearing all relevant tables.</p>
        <p>The output returns the trigger handle as well as indicating success or failure of the trigger activation.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CreateTriggerByRangeRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CreateTriggerByRangeResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a48e03f5bf1ad6d725a68f9f8d172b5d5">◆ </a></span>createTriggerByRange() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CreateTriggerByRangeResponse">CreateTriggerByRangeResponse</a> & gpudb::GPUdb::createTriggerByRange </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1CreateTriggerByRangeRequest">CreateTriggerByRangeRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1CreateTriggerByRangeResponse">CreateTriggerByRangeResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Sets up a simple range trigger for a column\_name for one or more tables. </p>
        <p>Once the trigger has been activated, any record added to the listed tables(s) via <a href="#ab6ab327611452cc777c159d202146997">insertRecords</a> with the chosen column\_name's value falling within the specified range will trip the trigger. All such records will be queued at the trigger port (by default '9001' but able to be retrieved via <a href="#abe9a7d6ea3fe0b154d73b86955db53cb">showSystemStatus</a>) for any listening client to collect. Active triggers can be cancelled by using the <a href="#a158a4cbcafb96ac8832f7caeeb07e4b3">clearTrigger</a> endpoint or by clearing all relevant tables.</p>
        <p>The output returns the trigger handle as well as indicating success or failure of the trigger activation.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CreateTriggerByRangeRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CreateTriggerByRangeResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CreateTriggerByRangeResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#aa331f41ea50603fee702f9606cffebb4">◆ </a></span>createTriggerByRange() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CreateTriggerByRangeResponse">CreateTriggerByRangeResponse</a> gpudb::GPUdb::createTriggerByRange </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>requestId</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< std::string > &</td>
            <td><span><span>tableNames</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>columnName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const double</td>
            <td><span><span>min</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const double</td>
            <td><span><span>max</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Sets up a simple range trigger for a column\_name for one or more tables. </p>
        <p>Once the trigger has been activated, any record added to the listed tables(s) via <a href="#a1cbbfefa7a3d6b4570f1be6734a8d849">insertRecords</a> with the chosen column\_name's value falling within the specified range will trip the trigger. All such records will be queued at the trigger port (by default '9001' but able to be retrieved via <a href="#a2cc190f96524c44227af5731319ad4e1">showSystemStatus</a>) for any listening client to collect. Active triggers can be cancelled by using the <a href="#a582553240e7015f44ae86078ec533a85">clearTrigger</a> endpoint or by clearing all relevant tables.</p>
        <p>The output returns the trigger handle as well as indicating success or failure of the trigger activation.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>requestId</td>
                <td>User-created ID for the trigger. The ID can be alphanumeric, contain symbols, and must contain at least one character. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>tableNames</td>
                <td>Tables on which the trigger will be active, each in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>columnName</td>
                <td>Name of a numeric column\_name on which the trigger is activated. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>min</td>
                <td>The lower bound (inclusive) for the trigger range. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>max</td>
                <td>The upper bound (inclusive) for the trigger range. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CreateTriggerByRangeResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a2b7b40a138abfaf1072e3c009cb8869a">◆ </a></span>createTriggerByRange() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CreateTriggerByRangeResponse">CreateTriggerByRangeResponse</a> & gpudb::GPUdb::createTriggerByRange </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>requestId</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< std::string > &</td>
            <td><span><span>tableNames</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>columnName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const double</td>
            <td><span><span>min</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const double</td>
            <td><span><span>max</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1CreateTriggerByRangeResponse">CreateTriggerByRangeResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Sets up a simple range trigger for a column\_name for one or more tables. </p>
        <p>Once the trigger has been activated, any record added to the listed tables(s) via <a href="#a1cbbfefa7a3d6b4570f1be6734a8d849">insertRecords</a> with the chosen column\_name's value falling within the specified range will trip the trigger. All such records will be queued at the trigger port (by default '9001' but able to be retrieved via <a href="#a2cc190f96524c44227af5731319ad4e1">showSystemStatus</a>) for any listening client to collect. Active triggers can be cancelled by using the <a href="#a582553240e7015f44ae86078ec533a85">clearTrigger</a> endpoint or by clearing all relevant tables.</p>
        <p>The output returns the trigger handle as well as indicating success or failure of the trigger activation.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>requestId</td>
                <td>User-created ID for the trigger. The ID can be alphanumeric, contain symbols, and must contain at least one character. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>tableNames</td>
                <td>Tables on which the trigger will be active, each in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>columnName</td>
                <td>Name of a numeric column\_name on which the trigger is activated. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>min</td>
                <td>The lower bound (inclusive) for the trigger range. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>max</td>
                <td>The upper bound (inclusive) for the trigger range. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CreateTriggerByRangeResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CreateTriggerByRangeResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#abaf7eca0d3c131b8fede4850d51f1a1a">◆ </a></span>createType() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CreateTypeResponse">CreateTypeResponse</a> gpudb::GPUdb::createType </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1CreateTypeRequest">CreateTypeRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Creates a new type describing the columns of a table. </p>
        <p>The type definition is specified as a list of columns, each specified as a list of the column name, data type, and any column attributes.</p>
        <p>Example of a type definition with some parameters: </p>

        <div>
          <div>\[</div>
          <div> \[<span>"id"</span>, <span>"int8"</span>, <span>"primary\_key"</span>],</div>
          <div> \[<span>"dept\_id"</span>, <span>"int8"</span>, <span>"primary\_key"</span>, <span>"shard\_key"</span>],</div>
          <div> \[<span>"manager\_id"</span>, <span>"int8"</span>, <span>"nullable"</span>],</div>
          <div> \[<span>"first\_name"</span>, <span>"char32"</span>],</div>
          <div> \[<span>"last\_name"</span>, <span>"char64"</span>],</div>
          <div> \[<span>"salary"</span>, <span>"decimal"</span>],</div>
          <div> \[<span>"hire\_date"</span>, <span>"date"</span>]</div>
          <div>]</div>
        </div>

        <p> Each column definition consists of the column name (which should meet the standard <a href="/content/concepts/tables/#table-naming-criteria">column naming criteria</a>), the column's <a href="/content/concepts/types/#types-chart">specific type</a> (int, long, float, double, string, bytes, or any of the possible values for <a href="/content/api/cpp/structgpudb_1_1CreateTypeRequest#a51d65ae072fd0bbb9991dc83d7e0a7c6">properties</a>), and any <a href="/content/concepts/types/#types-data-handling">data handling</a>, <a href="/content/concepts/types/#types-data-keys">data key</a>, or <a href="/content/concepts/types/#types-data-replace">data replacement</a> properties.</p>
        <p>Note that some properties are mutually exclusive–i.e. they cannot be specified for any given column simultaneously. One example of mutually exclusive properties are <a href="/content/api/cpp/namespacegpudb#a8bf3bb8e3db95397e8b3992f78ebf740">primary\_key</a> and <a href="/content/api/cpp/namespacegpudb#a89eab971915fdca45d8d31771b2c291a">nullable</a>.</p>
        <p>A single <a href="/content/concepts/tables/#primary-keys">primary key</a> and/or single <a href="/content/concepts/tables/#shard-keys">shard key</a> can be set across one or more columns. If a primary key is specified, then a uniqueness constraint is enforced, in that only a single object can exist with a given primary key column value (or set of values for the key columns, if using a composite primary key). When <a href="#ab6ab327611452cc777c159d202146997">inserting</a> data into a table with a primary key, depending on the parameters in the request, incoming objects with primary key values that match existing objects will either overwrite (i.e. update) the existing object or will be skipped and not added into the set.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CreateTypeRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CreateTypeResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ae8b6df8ac9858f30d8bc46c35010af18">◆ </a></span>createType() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CreateTypeResponse">CreateTypeResponse</a> & gpudb::GPUdb::createType </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1CreateTypeRequest">CreateTypeRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1CreateTypeResponse">CreateTypeResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Creates a new type describing the columns of a table. </p>
        <p>The type definition is specified as a list of columns, each specified as a list of the column name, data type, and any column attributes.</p>
        <p>Example of a type definition with some parameters: </p>

        <div>
          <div>\[</div>
          <div> \[<span>"id"</span>, <span>"int8"</span>, <span>"primary\_key"</span>],</div>
          <div> \[<span>"dept\_id"</span>, <span>"int8"</span>, <span>"primary\_key"</span>, <span>"shard\_key"</span>],</div>
          <div> \[<span>"manager\_id"</span>, <span>"int8"</span>, <span>"nullable"</span>],</div>
          <div> \[<span>"first\_name"</span>, <span>"char32"</span>],</div>
          <div> \[<span>"last\_name"</span>, <span>"char64"</span>],</div>
          <div> \[<span>"salary"</span>, <span>"decimal"</span>],</div>
          <div> \[<span>"hire\_date"</span>, <span>"date"</span>]</div>
          <div>]</div>
        </div>

        <p> Each column definition consists of the column name (which should meet the standard <a href="/content/concepts/tables/#table-naming-criteria">column naming criteria</a>), the column's <a href="/content/concepts/types/#types-chart">specific type</a> (int, long, float, double, string, bytes, or any of the possible values for <a href="/content/api/cpp/structgpudb_1_1CreateTypeRequest#a51d65ae072fd0bbb9991dc83d7e0a7c6">properties</a>), and any <a href="/content/concepts/types/#types-data-handling">data handling</a>, <a href="/content/concepts/types/#types-data-keys">data key</a>, or <a href="/content/concepts/types/#types-data-replace">data replacement</a> properties.</p>
        <p>Note that some properties are mutually exclusive–i.e. they cannot be specified for any given column simultaneously. One example of mutually exclusive properties are <a href="/content/api/cpp/namespacegpudb#a8bf3bb8e3db95397e8b3992f78ebf740">primary\_key</a> and <a href="/content/api/cpp/namespacegpudb#a89eab971915fdca45d8d31771b2c291a">nullable</a>.</p>
        <p>A single <a href="/content/concepts/tables/#primary-keys">primary key</a> and/or single <a href="/content/concepts/tables/#shard-keys">shard key</a> can be set across one or more columns. If a primary key is specified, then a uniqueness constraint is enforced, in that only a single object can exist with a given primary key column value (or set of values for the key columns, if using a composite primary key). When <a href="#ab6ab327611452cc777c159d202146997">inserting</a> data into a table with a primary key, depending on the parameters in the request, incoming objects with primary key values that match existing objects will either overwrite (i.e. update) the existing object or will be skipped and not added into the set.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CreateTypeRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CreateTypeResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CreateTypeResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a1698840c08d7212878c9c1dac3f94cfc">◆ </a></span>createType() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CreateTypeResponse">CreateTypeResponse</a> gpudb::GPUdb::createType </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>typeDefinition</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>label</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::vector\< std::string > > &</td>
            <td><span><span>properties</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Creates a new type describing the columns of a table. </p>
        <p>The type definition is specified as a list of columns, each specified as a list of the column name, data type, and any column attributes.</p>
        <p>Example of a type definition with some parameters: </p>

        <div>
          <div>\[</div>
          <div> \[<span>"id"</span>, <span>"int8"</span>, <span>"primary\_key"</span>],</div>
          <div> \[<span>"dept\_id"</span>, <span>"int8"</span>, <span>"primary\_key"</span>, <span>"shard\_key"</span>],</div>
          <div> \[<span>"manager\_id"</span>, <span>"int8"</span>, <span>"nullable"</span>],</div>
          <div> \[<span>"first\_name"</span>, <span>"char32"</span>],</div>
          <div> \[<span>"last\_name"</span>, <span>"char64"</span>],</div>
          <div> \[<span>"salary"</span>, <span>"decimal"</span>],</div>
          <div> \[<span>"hire\_date"</span>, <span>"date"</span>]</div>
          <div>]</div>
        </div>

        <p> Each column definition consists of the column name (which should meet the standard <a href="/content/concepts/tables/#table-naming-criteria">column naming criteria</a>), the column's <a href="/content/concepts/types/#types-chart">specific type</a> (int, long, float, double, string, bytes, or any of the possible values for <span>properties</span>), and any <a href="/content/concepts/types/#types-data-handling">data handling</a>, <a href="/content/concepts/types/#types-data-keys">data key</a>, or <a href="/content/concepts/types/#types-data-replace">data replacement</a> properties.</p>
        <p>Note that some properties are mutually exclusive–i.e. they cannot be specified for any given column simultaneously. One example of mutually exclusive properties are <a href="/content/api/cpp/namespacegpudb#a8bf3bb8e3db95397e8b3992f78ebf740">primary\_key</a> and <a href="/content/api/cpp/namespacegpudb#a89eab971915fdca45d8d31771b2c291a">nullable</a>.</p>
        <p>A single <a href="/content/concepts/tables/#primary-keys">primary key</a> and/or single <a href="/content/concepts/tables/#shard-keys">shard key</a> can be set across one or more columns. If a primary key is specified, then a uniqueness constraint is enforced, in that only a single object can exist with a given primary key column value (or set of values for the key columns, if using a composite primary key). When <a href="#a1cbbfefa7a3d6b4570f1be6734a8d849">inserting</a> data into a table with a primary key, depending on the parameters in the request, incoming objects with primary key values that match existing objects will either overwrite (i.e. update) the existing object or will be skipped and not added into the set.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>typeDefinition</td>
                <td>JSON string defining the columns of the type to be registered, as described above. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>label</td>
                <td>A user-defined description string which can be used to differentiate between tables and types with otherwise identical schemas. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>properties</td>

                <td>
                  \[DEPRECATED–please use these property values in the <span>typeDefinition</span> directly, as described at the top, instead] Each key-value pair specifies the properties to use for a given column where the key is the column name. All keys used must be relevant column names for the given table. Specifying any property overrides the default properties for that column (which is based on the column's data type). Valid values are:

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a04cb277a0201af0d5490b4a528081999">create\_type\_data</a>: Default property for all numeric and string type columns; makes the column available for GPU queries. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a0f04e77598e6abb371d644342d7d94f0">create\_type\_text\_search</a>: Valid only for select 'string' columns. Enables full text search–see <a href="/content/concepts/full_text_search/">Full Text Search</a> for details and applicable string column types. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aa9c46af7359cf743dcab760312326141">create\_type\_timestamp</a>: Valid only for 'long' columns. Indicates that this field represents a timestamp and will be provided in milliseconds since the Unix epoch: 00:00:00 Jan 1 1970. Dates represented by a timestamp must fall between the year 1000 and the year 2900. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a37f1a55dffd6d745c44864fe8583fbcb">create\_type\_ulong</a>: Valid only for 'string' columns. It represents an unsigned long integer data type. The string can only be interpreted as an unsigned long data type with minimum value of zero, and maximum value of 18446744073709551615. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#abc17fadc609647d841b0e2bd81b48d9b">create\_type\_uuid</a>: Valid only for 'string' columns. It represents an uuid data type. Internally, it is stored as a 128-bit integer. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a37649ad5e1a0f350378fd779024c74aa">create\_type\_decimal</a>: Valid only for 'string' columns. It represents a SQL type NUMERIC(19, 4) data type. There can be up to 15 digits before the decimal point and up to four digits in the fractional part. The value can be positive or negative (indicated by a minus sign at the beginning). This property is mutually exclusive with the <a href="/content/api/cpp/namespacegpudb#a0f04e77598e6abb371d644342d7d94f0">text\_search</a> property. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aa18fe79d0fb060b9896a216048fa8ba6">create\_type\_date</a>: Valid only for 'string' columns. Indicates that this field represents a date and will be provided in the format 'YYYY-MM-DD'. The allowable range is 1000-01-01 through 2900-01-01. This property is mutually exclusive with the <a href="/content/api/cpp/namespacegpudb#a0f04e77598e6abb371d644342d7d94f0">text\_search</a> property. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aed7d5335cb361906f59a73e5e61a53f3">create\_type\_time</a>: Valid only for 'string' columns. Indicates that this field represents a time-of-day and will be provided in the format 'HH:MM:SS.mmm'. The allowable range is 00:00:00.000 through 23:59:59.999. This property is mutually exclusive with the <a href="/content/api/cpp/namespacegpudb#a0f04e77598e6abb371d644342d7d94f0">text\_search</a> property. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#af3cd7c4dbe711ac21b9679e59a666fdc">create\_type\_datetime</a>: Valid only for 'string' columns. Indicates that this field represents a datetime and will be provided in the format 'YYYY-MM-DD HH:MM:SS.mmm'. The allowable range is 1000-01-01 00:00:00.000 through 2900-01-01 23:59:59.999. This property is mutually exclusive with the <a href="/content/api/cpp/namespacegpudb#a0f04e77598e6abb371d644342d7d94f0">text\_search</a> property. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a56948cca24616ad008c805eb8109930b">create\_type\_char1</a>: This property provides optimized memory, disk and query performance for string columns. Strings with this property must be no longer than 1 character. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a45b5b71236ff8ea7261dc232045671d0">create\_type\_char2</a>: This property provides optimized memory, disk and query performance for string columns. Strings with this property must be no longer than 2 characters. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ac8a93c9929ace10fa0e9e83fa5d967d5">create\_type\_char4</a>: This property provides optimized memory, disk and query performance for string columns. Strings with this property must be no longer than 4 characters. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aaa57c9e16461a9e72b4513ddfc0a2125">create\_type\_char8</a>: This property provides optimized memory, disk and query performance for string columns. Strings with this property must be no longer than 8 characters. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a230f37d7702705d4420e55d3e9fc779b">create\_type\_char16</a>: This property provides optimized memory, disk and query performance for string columns. Strings with this property must be no longer than 16 characters. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aeb6cce9faca0416e7255222d56937ba9">create\_type\_char32</a>: This property provides optimized memory, disk and query performance for string columns. Strings with this property must be no longer than 32 characters. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aae2f6dfaf6490ccb451d3cb9c3500ea8">create\_type\_char64</a>: This property provides optimized memory, disk and query performance for string columns. Strings with this property must be no longer than 64 characters. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a266d1c9272fc64248a1f827c84cfca8a">create\_type\_char128</a>: This property provides optimized memory, disk and query performance for string columns. Strings with this property must be no longer than 128 characters. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aefee5d0b9b677b885143c861b7f7d2ba">create\_type\_char256</a>: This property provides optimized memory, disk and query performance for string columns. Strings with this property must be no longer than 256 characters. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a4f4bc5c8a77c9d24638f152651d9168e">create\_type\_boolean</a>: This property provides optimized memory and query performance for int columns. Ints with this property must be between 0 and 1(inclusive) </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aa026590c4ee4f5591d1e58f03b7bf9dd">create\_type\_int8</a>: This property provides optimized memory and query performance for int columns. Ints with this property must be between -128 and +127 (inclusive) </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a93689a1a9e05abf842a7d779de7ce509">create\_type\_int16</a>: This property provides optimized memory and query performance for int columns. Ints with this property must be between -32768 and +32767 (inclusive) </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a6c50bf6e6a54f543b0f0c3d2f4e0204e">create\_type\_ipv4</a>: This property provides optimized memory, disk and query performance for string columns representing IPv4 addresses (i.e. 192.168.1.1). Strings with this property must be of the form: A.B.C.D where A, B, C and D are in the range of 0-255. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ac8dc500407bb9ddc34c909060e19c91e">create\_type\_array</a>: Valid only for 'string' columns. Indicates that this field contains an array. The value type and (optionally) the item count should be specified in parenthesis; e.g., 'array(int, 10)' for a 10-integer array. Both 'array(int)' and 'array(int, -1)' will designate an unlimited-length integer array, though no bounds checking is performed on arrays of any length. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a567a2f6727033c6e5523743ab4d3f5cc">create\_type\_json</a>: Valid only for 'string' columns. Indicates that this field contains values in JSON format. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ae8c36b107f4b735e1729c04ef5ac99c1">create\_type\_vector</a>: Valid only for 'bytes' columns. Indicates that this field contains a vector of floats. The length should be specified in parenthesis, e.g., 'vector(1000)'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a59a0289a4acdb1be3433089c2fcf1be5">create\_type\_wkt</a>: Valid only for 'string' and 'bytes' columns. Indicates that this field contains geospatial geometry objects in Well-Known Text (WKT) or Well-Known Binary (WKB) format. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a8bf3bb8e3db95397e8b3992f78ebf740">create\_type\_primary\_key</a>: This property indicates that this column will be part of (or the entire) <a href="/content/concepts/tables/#primary-keys">primary key</a>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a2fbba58f5f2fe8ff1d8e85bc05033c48">create\_type\_soft\_primary\_key</a>: This property indicates that this column will be part of (or the entire) <a href="/content/concepts/tables/#soft-primary-keys">soft primary key</a>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a495a8e0f611f9de584a908c0a8c7a23b">create\_type\_shard\_key</a>: This property indicates that this column will be part of (or the entire) <a href="/content/concepts/tables/#shard-keys">shard key</a>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a89eab971915fdca45d8d31771b2c291a">create\_type\_nullable</a>: This property indicates that this column is nullable. However, setting this property is insufficient for making the column nullable. The user must declare the type of the column as a union between its regular type and 'null' in the Avro schema for the record type in <span>typeDefinition</span>. For example, if a column is of type integer and is nullable, then the entry for the column in the Avro schema must be: \['int', 'null']. The C++, C#, Java, and Python APIs have built-in convenience for bypassing setting the Avro schema by hand. For those languages, one can use this property as usual and not have to worry about the Avro schema for the record. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aa63a261a94b8555cd1180570db34d914">create\_type\_compress</a>: This property indicates that this column should be <a href="/content/concepts/column_compression/">compressed</a> with the given codec and optional level; e.g., 'compress(snappy)' for Snappy compression and 'compress(zstd(7))' for zstd level 7 compression. This property is primarily used in order to save disk space. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#afe3e43c0d01f64db9d8a7ba07f1a07ef">create\_type\_dict</a>: This property indicates that this column should be <a href="/content/concepts/dictionary_encoding/">dictionary encoded</a>. It can only be used in conjunction with restricted string (charN), int, long or date columns. Dictionary encoding is best for columns where the cardinality (the number of unique values) is expected to be low. This property can save a large amount of memory. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#adea216f7a013cd66c47b7b584392d18e">create\_type\_init\_with\_now</a>: For 'date', 'time', 'datetime', or 'timestamp' column types, replace empty strings and invalid timestamps with 'NOW()' upon insert. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ada47adce7d81dfdb62b5d480215d8b4c">create\_type\_init\_with\_uuid</a>: For 'uuid' type, replace empty strings and invalid UUID values with randomly-generated UUIDs upon insert. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a854c8f1c3cb94910a6280d3128465460">create\_type\_update\_with\_now</a>: For 'date', 'time', 'datetime', or 'timestamp' column types, update the field with 'NOW()' upon any update. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a668706a4cfbf35e68e85738f4ffee0b4">create\_type\_update\_with\_user</a>: For 'charN' or 'string' column types, update the field with the current user's name upon any update. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a74d6404a3c4f6d9df8336b0be7080ae9">create\_type\_default</a>: Sets a default value expression for this column, e.g. 'default(0)', 'default(''pending'')', or 'default(NOW())'. When the column is omitted from an insert via request\_schema\_str, the expression is evaluated and the result is used as the column value. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a9a2cf926e995d53a98776fa2425197af">create\_type\_default\_sql</a>: Sets a default value expression for this column with SQL syntax, e.g. 'default(0)', 'default(''pending'')', or 'default(NOW())'. Only used for showing the expression when generating SQL DDL. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a14b4435a2c1d8468bd2a52096b358753">create\_type\_compression\_codec</a>: The default <a href="/content/concepts/column_compression/">compression codec</a> for this type's columns. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CreateTypeResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a5d88689120cf75e0c9f90d58d260926b">◆ </a></span>createType() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CreateTypeResponse">CreateTypeResponse</a> & gpudb::GPUdb::createType </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>typeDefinition</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>label</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::vector\< std::string > > &</td>
            <td><span><span>properties</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1CreateTypeResponse">CreateTypeResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Creates a new type describing the columns of a table. </p>
        <p>The type definition is specified as a list of columns, each specified as a list of the column name, data type, and any column attributes.</p>
        <p>Example of a type definition with some parameters: </p>

        <div>
          <div>\[</div>
          <div> \[<span>"id"</span>, <span>"int8"</span>, <span>"primary\_key"</span>],</div>
          <div> \[<span>"dept\_id"</span>, <span>"int8"</span>, <span>"primary\_key"</span>, <span>"shard\_key"</span>],</div>
          <div> \[<span>"manager\_id"</span>, <span>"int8"</span>, <span>"nullable"</span>],</div>
          <div> \[<span>"first\_name"</span>, <span>"char32"</span>],</div>
          <div> \[<span>"last\_name"</span>, <span>"char64"</span>],</div>
          <div> \[<span>"salary"</span>, <span>"decimal"</span>],</div>
          <div> \[<span>"hire\_date"</span>, <span>"date"</span>]</div>
          <div>]</div>
        </div>

        <p> Each column definition consists of the column name (which should meet the standard <a href="/content/concepts/tables/#table-naming-criteria">column naming criteria</a>), the column's <a href="/content/concepts/types/#types-chart">specific type</a> (int, long, float, double, string, bytes, or any of the possible values for <span>properties</span>), and any <a href="/content/concepts/types/#types-data-handling">data handling</a>, <a href="/content/concepts/types/#types-data-keys">data key</a>, or <a href="/content/concepts/types/#types-data-replace">data replacement</a> properties.</p>
        <p>Note that some properties are mutually exclusive–i.e. they cannot be specified for any given column simultaneously. One example of mutually exclusive properties are <a href="/content/api/cpp/namespacegpudb#a8bf3bb8e3db95397e8b3992f78ebf740">primary\_key</a> and <a href="/content/api/cpp/namespacegpudb#a89eab971915fdca45d8d31771b2c291a">nullable</a>.</p>
        <p>A single <a href="/content/concepts/tables/#primary-keys">primary key</a> and/or single <a href="/content/concepts/tables/#shard-keys">shard key</a> can be set across one or more columns. If a primary key is specified, then a uniqueness constraint is enforced, in that only a single object can exist with a given primary key column value (or set of values for the key columns, if using a composite primary key). When <a href="#a1cbbfefa7a3d6b4570f1be6734a8d849">inserting</a> data into a table with a primary key, depending on the parameters in the request, incoming objects with primary key values that match existing objects will either overwrite (i.e. update) the existing object or will be skipped and not added into the set.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>typeDefinition</td>
                <td>JSON string defining the columns of the type to be registered, as described above. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>label</td>
                <td>A user-defined description string which can be used to differentiate between tables and types with otherwise identical schemas. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>properties</td>

                <td>
                  \[DEPRECATED–please use these property values in the <span>typeDefinition</span> directly, as described at the top, instead] Each key-value pair specifies the properties to use for a given column where the key is the column name. All keys used must be relevant column names for the given table. Specifying any property overrides the default properties for that column (which is based on the column's data type). Valid values are:

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a04cb277a0201af0d5490b4a528081999">create\_type\_data</a>: Default property for all numeric and string type columns; makes the column available for GPU queries. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a0f04e77598e6abb371d644342d7d94f0">create\_type\_text\_search</a>: Valid only for select 'string' columns. Enables full text search–see <a href="/content/concepts/full_text_search/">Full Text Search</a> for details and applicable string column types. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aa9c46af7359cf743dcab760312326141">create\_type\_timestamp</a>: Valid only for 'long' columns. Indicates that this field represents a timestamp and will be provided in milliseconds since the Unix epoch: 00:00:00 Jan 1 1970. Dates represented by a timestamp must fall between the year 1000 and the year 2900. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a37f1a55dffd6d745c44864fe8583fbcb">create\_type\_ulong</a>: Valid only for 'string' columns. It represents an unsigned long integer data type. The string can only be interpreted as an unsigned long data type with minimum value of zero, and maximum value of 18446744073709551615. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#abc17fadc609647d841b0e2bd81b48d9b">create\_type\_uuid</a>: Valid only for 'string' columns. It represents an uuid data type. Internally, it is stored as a 128-bit integer. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a37649ad5e1a0f350378fd779024c74aa">create\_type\_decimal</a>: Valid only for 'string' columns. It represents a SQL type NUMERIC(19, 4) data type. There can be up to 15 digits before the decimal point and up to four digits in the fractional part. The value can be positive or negative (indicated by a minus sign at the beginning). This property is mutually exclusive with the <a href="/content/api/cpp/namespacegpudb#a0f04e77598e6abb371d644342d7d94f0">text\_search</a> property. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aa18fe79d0fb060b9896a216048fa8ba6">create\_type\_date</a>: Valid only for 'string' columns. Indicates that this field represents a date and will be provided in the format 'YYYY-MM-DD'. The allowable range is 1000-01-01 through 2900-01-01. This property is mutually exclusive with the <a href="/content/api/cpp/namespacegpudb#a0f04e77598e6abb371d644342d7d94f0">text\_search</a> property. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aed7d5335cb361906f59a73e5e61a53f3">create\_type\_time</a>: Valid only for 'string' columns. Indicates that this field represents a time-of-day and will be provided in the format 'HH:MM:SS.mmm'. The allowable range is 00:00:00.000 through 23:59:59.999. This property is mutually exclusive with the <a href="/content/api/cpp/namespacegpudb#a0f04e77598e6abb371d644342d7d94f0">text\_search</a> property. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#af3cd7c4dbe711ac21b9679e59a666fdc">create\_type\_datetime</a>: Valid only for 'string' columns. Indicates that this field represents a datetime and will be provided in the format 'YYYY-MM-DD HH:MM:SS.mmm'. The allowable range is 1000-01-01 00:00:00.000 through 2900-01-01 23:59:59.999. This property is mutually exclusive with the <a href="/content/api/cpp/namespacegpudb#a0f04e77598e6abb371d644342d7d94f0">text\_search</a> property. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a56948cca24616ad008c805eb8109930b">create\_type\_char1</a>: This property provides optimized memory, disk and query performance for string columns. Strings with this property must be no longer than 1 character. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a45b5b71236ff8ea7261dc232045671d0">create\_type\_char2</a>: This property provides optimized memory, disk and query performance for string columns. Strings with this property must be no longer than 2 characters. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ac8a93c9929ace10fa0e9e83fa5d967d5">create\_type\_char4</a>: This property provides optimized memory, disk and query performance for string columns. Strings with this property must be no longer than 4 characters. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aaa57c9e16461a9e72b4513ddfc0a2125">create\_type\_char8</a>: This property provides optimized memory, disk and query performance for string columns. Strings with this property must be no longer than 8 characters. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a230f37d7702705d4420e55d3e9fc779b">create\_type\_char16</a>: This property provides optimized memory, disk and query performance for string columns. Strings with this property must be no longer than 16 characters. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aeb6cce9faca0416e7255222d56937ba9">create\_type\_char32</a>: This property provides optimized memory, disk and query performance for string columns. Strings with this property must be no longer than 32 characters. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aae2f6dfaf6490ccb451d3cb9c3500ea8">create\_type\_char64</a>: This property provides optimized memory, disk and query performance for string columns. Strings with this property must be no longer than 64 characters. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a266d1c9272fc64248a1f827c84cfca8a">create\_type\_char128</a>: This property provides optimized memory, disk and query performance for string columns. Strings with this property must be no longer than 128 characters. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aefee5d0b9b677b885143c861b7f7d2ba">create\_type\_char256</a>: This property provides optimized memory, disk and query performance for string columns. Strings with this property must be no longer than 256 characters. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a4f4bc5c8a77c9d24638f152651d9168e">create\_type\_boolean</a>: This property provides optimized memory and query performance for int columns. Ints with this property must be between 0 and 1(inclusive) </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aa026590c4ee4f5591d1e58f03b7bf9dd">create\_type\_int8</a>: This property provides optimized memory and query performance for int columns. Ints with this property must be between -128 and +127 (inclusive) </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a93689a1a9e05abf842a7d779de7ce509">create\_type\_int16</a>: This property provides optimized memory and query performance for int columns. Ints with this property must be between -32768 and +32767 (inclusive) </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a6c50bf6e6a54f543b0f0c3d2f4e0204e">create\_type\_ipv4</a>: This property provides optimized memory, disk and query performance for string columns representing IPv4 addresses (i.e. 192.168.1.1). Strings with this property must be of the form: A.B.C.D where A, B, C and D are in the range of 0-255. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ac8dc500407bb9ddc34c909060e19c91e">create\_type\_array</a>: Valid only for 'string' columns. Indicates that this field contains an array. The value type and (optionally) the item count should be specified in parenthesis; e.g., 'array(int, 10)' for a 10-integer array. Both 'array(int)' and 'array(int, -1)' will designate an unlimited-length integer array, though no bounds checking is performed on arrays of any length. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a567a2f6727033c6e5523743ab4d3f5cc">create\_type\_json</a>: Valid only for 'string' columns. Indicates that this field contains values in JSON format. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ae8c36b107f4b735e1729c04ef5ac99c1">create\_type\_vector</a>: Valid only for 'bytes' columns. Indicates that this field contains a vector of floats. The length should be specified in parenthesis, e.g., 'vector(1000)'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a59a0289a4acdb1be3433089c2fcf1be5">create\_type\_wkt</a>: Valid only for 'string' and 'bytes' columns. Indicates that this field contains geospatial geometry objects in Well-Known Text (WKT) or Well-Known Binary (WKB) format. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a8bf3bb8e3db95397e8b3992f78ebf740">create\_type\_primary\_key</a>: This property indicates that this column will be part of (or the entire) <a href="/content/concepts/tables/#primary-keys">primary key</a>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a2fbba58f5f2fe8ff1d8e85bc05033c48">create\_type\_soft\_primary\_key</a>: This property indicates that this column will be part of (or the entire) <a href="/content/concepts/tables/#soft-primary-keys">soft primary key</a>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a495a8e0f611f9de584a908c0a8c7a23b">create\_type\_shard\_key</a>: This property indicates that this column will be part of (or the entire) <a href="/content/concepts/tables/#shard-keys">shard key</a>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a89eab971915fdca45d8d31771b2c291a">create\_type\_nullable</a>: This property indicates that this column is nullable. However, setting this property is insufficient for making the column nullable. The user must declare the type of the column as a union between its regular type and 'null' in the Avro schema for the record type in <span>typeDefinition</span>. For example, if a column is of type integer and is nullable, then the entry for the column in the Avro schema must be: \['int', 'null']. The C++, C#, Java, and Python APIs have built-in convenience for bypassing setting the Avro schema by hand. For those languages, one can use this property as usual and not have to worry about the Avro schema for the record. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aa63a261a94b8555cd1180570db34d914">create\_type\_compress</a>: This property indicates that this column should be <a href="/content/concepts/column_compression/">compressed</a> with the given codec and optional level; e.g., 'compress(snappy)' for Snappy compression and 'compress(zstd(7))' for zstd level 7 compression. This property is primarily used in order to save disk space. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#afe3e43c0d01f64db9d8a7ba07f1a07ef">create\_type\_dict</a>: This property indicates that this column should be <a href="/content/concepts/dictionary_encoding/">dictionary encoded</a>. It can only be used in conjunction with restricted string (charN), int, long or date columns. Dictionary encoding is best for columns where the cardinality (the number of unique values) is expected to be low. This property can save a large amount of memory. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#adea216f7a013cd66c47b7b584392d18e">create\_type\_init\_with\_now</a>: For 'date', 'time', 'datetime', or 'timestamp' column types, replace empty strings and invalid timestamps with 'NOW()' upon insert. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ada47adce7d81dfdb62b5d480215d8b4c">create\_type\_init\_with\_uuid</a>: For 'uuid' type, replace empty strings and invalid UUID values with randomly-generated UUIDs upon insert. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a854c8f1c3cb94910a6280d3128465460">create\_type\_update\_with\_now</a>: For 'date', 'time', 'datetime', or 'timestamp' column types, update the field with 'NOW()' upon any update. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a668706a4cfbf35e68e85738f4ffee0b4">create\_type\_update\_with\_user</a>: For 'charN' or 'string' column types, update the field with the current user's name upon any update. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a74d6404a3c4f6d9df8336b0be7080ae9">create\_type\_default</a>: Sets a default value expression for this column, e.g. 'default(0)', 'default(''pending'')', or 'default(NOW())'. When the column is omitted from an insert via request\_schema\_str, the expression is evaluated and the result is used as the column value. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a9a2cf926e995d53a98776fa2425197af">create\_type\_default\_sql</a>: Sets a default value expression for this column with SQL syntax, e.g. 'default(0)', 'default(''pending'')', or 'default(NOW())'. Only used for showing the expression when generating SQL DDL. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a14b4435a2c1d8468bd2a52096b358753">create\_type\_compression\_codec</a>: The default <a href="/content/concepts/column_compression/">compression codec</a> for this type's columns. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CreateTypeResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CreateTypeResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#af715d41bccfba570e4e335da030f8576">◆ </a></span>createUnion() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CreateUnionResponse">CreateUnionResponse</a> gpudb::GPUdb::createUnion </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1CreateUnionRequest">CreateUnionRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Merges data from one or more tables with comparable data types into a new table. </p>
        <p>The following merges are supported:</p>
        <p>UNION (DISTINCT/ALL) - For data set union details and examples, see <a href="/content/concepts/unions/">Union</a>. For limitations, see <a href="/content/concepts/unions/#limitations-and-cautions">Union Limitations and Cautions</a>.</p>
        <p>INTERSECT (DISTINCT/ALL) - For data set intersection details and examples, see <a href="/content/concepts/intersect/">Intersect</a>. For limitations, see <a href="/content/concepts/intersect/#limitations">Intersect Limitations</a>.</p>
        <p>EXCEPT (DISTINCT/ALL) - For data set subtraction details and examples, see <a href="/content/concepts/except/">Except</a>. For limitations, see <a href="/content/concepts/except/#limitations">Except Limitations</a>.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CreateUnionRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CreateUnionResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ab65629316eb66dee1c6b8998423c46e6">◆ </a></span>createUnion() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CreateUnionResponse">CreateUnionResponse</a> & gpudb::GPUdb::createUnion </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1CreateUnionRequest">CreateUnionRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1CreateUnionResponse">CreateUnionResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Merges data from one or more tables with comparable data types into a new table. </p>
        <p>The following merges are supported:</p>
        <p>UNION (DISTINCT/ALL) - For data set union details and examples, see <a href="/content/concepts/unions/">Union</a>. For limitations, see <a href="/content/concepts/unions/#limitations-and-cautions">Union Limitations and Cautions</a>.</p>
        <p>INTERSECT (DISTINCT/ALL) - For data set intersection details and examples, see <a href="/content/concepts/intersect/">Intersect</a>. For limitations, see <a href="/content/concepts/intersect/#limitations">Intersect Limitations</a>.</p>
        <p>EXCEPT (DISTINCT/ALL) - For data set subtraction details and examples, see <a href="/content/concepts/except/">Except</a>. For limitations, see <a href="/content/concepts/except/#limitations">Except Limitations</a>.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CreateUnionRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CreateUnionResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CreateUnionResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ad46a1ca661db2c102c37940364563143">◆ </a></span>createUnion() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CreateUnionResponse">CreateUnionResponse</a> gpudb::GPUdb::createUnion </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< std::string > &</td>
            <td><span><span>tableNames</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< std::vector\< std::string > > &</td>
            <td><span><span>inputColumnNames</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< std::string > &</td>
            <td><span><span>outputColumnNames</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Merges data from one or more tables with comparable data types into a new table. </p>
        <p>The following merges are supported:</p>
        <p>UNION (DISTINCT/ALL) - For data set union details and examples, see <a href="/content/concepts/unions/">Union</a>. For limitations, see <a href="/content/concepts/unions/#limitations-and-cautions">Union Limitations and Cautions</a>.</p>
        <p>INTERSECT (DISTINCT/ALL) - For data set intersection details and examples, see <a href="/content/concepts/intersect/">Intersect</a>. For limitations, see <a href="/content/concepts/intersect/#limitations">Intersect Limitations</a>.</p>
        <p>EXCEPT (DISTINCT/ALL) - For data set subtraction details and examples, see <a href="/content/concepts/except/">Except</a>. For limitations, see <a href="/content/concepts/except/#limitations">Except Limitations</a>.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of the table to be created, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a> and meeting <a href="/content/concepts/tables/#table-naming-criteria">table naming criteria</a>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>tableNames</td>
                <td>The list of table names to merge, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. Must contain the names of one or more existing tables. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>inputColumnNames</td>
                <td>The list of columns from each of the corresponding input tables. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>outputColumnNames</td>
                <td>The list of names of the columns to be stored in the output table. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ae7a132ec4d309fafdc6282b5b988c630">create\_union\_create\_temp\_table</a>: If <a href="/content/api/cpp/namespacegpudb#a4c679573328605dc89476ea85fbe6e87">true</a>, a unique temporary table name will be generated in the sys\_temp schema and used in place of <span>tableName</span>. If <a href="/content/api/cpp/namespacegpudb#a9773f20de01667f4a54a013287125d6d">persist</a> is <a href="/content/api/cpp/namespacegpudb#a3196fd11fabb927d36a20e258903b566">false</a> (or unspecified), then this is always allowed even if the caller does not have permission to create tables. The generated name is returned in <a href="/content/api/cpp/namespacegpudb#a584f96f298fb8560e416d7aa5d12696f">qualified\_table\_name</a>. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a4c679573328605dc89476ea85fbe6e87">create\_union\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a3196fd11fabb927d36a20e258903b566">create\_union\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a3196fd11fabb927d36a20e258903b566">create\_union\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a51ad8919e170db36635d44e753ffb3ca">create\_union\_collection\_name</a>: \[DEPRECATED–please specify the containing schema for the projection as part of <span>tableName</span> and use <a href="#a33d9a0a8e738d14b688f9f869f9640ad">createSchema</a> to create the schema if non-existent] Name of the schema for the output table. If the schema provided is non-existent, it will be automatically created. The default value is ''. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#adeb5407c9e89bd6fbbb6aca40b39d544">create\_union\_mode</a>: The mode describes what rows of the tables being unioned will be retained. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a4d30935577318d7b1b764224cabca31b">create\_union\_union\_all</a>: Retains all rows from the specified tables. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a15a6fc2ec7a782dc2d6192a08cb6a4a9">create\_union\_union</a>: Retains all unique rows from the specified tables (synonym for <a href="/content/api/cpp/namespacegpudb#a7a186e3a270e41a99cf4d3517e892257">union\_distinct</a>). </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a7a186e3a270e41a99cf4d3517e892257">create\_union\_union\_distinct</a>: Retains all unique rows from the specified tables. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a2ef70a26679f465ecdb580dfc326910e">create\_union\_except</a>: Retains all unique rows from the first table that do not appear in the second table (only works on 2 tables). </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a06baad96a6f886c6843b9ab4f18ab297">create\_union\_except\_all</a>: Retains all rows(including duplicates) from the first table that do not appear in the second table (only works on 2 tables). </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a9faa32e71c7c836805f660cd15c439f3">create\_union\_intersect</a>: Retains all unique rows that appear in both of the specified tables (only works on 2 tables). </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a98f20f503e4401f9d21db59fca19d05f">create\_union\_intersect\_all</a>: Retains all rows(including duplicates) that appear in both of the specified tables (only works on 2 tables). </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a4d30935577318d7b1b764224cabca31b">create\_union\_union\_all</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a4e4b51e85582c38d91def6f4980f659d">create\_union\_chunk\_size</a>: Indicates the number of records per chunk to be used for this output table. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a6e878bfd26260961c6ca97993a840b90">create\_union\_chunk\_column\_max\_memory</a>: Indicates the target maximum data size for each column in a chunk to be used for this output table. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ab0f79cbd7c82bf7b2066402d9678720d">create\_union\_chunk\_max\_memory</a>: Indicates the target maximum data size for all columns in a chunk to be used for this output table. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a62165dc74b434196fdc35f7687d53323">create\_union\_create\_indexes</a>: Comma-separated list of columns on which to create indexes on the output table. The columns specified must be present in <span>outputColumnNames</span>. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a81ea337287743114191da31177f0ae8c">create\_union\_partition\_type</a>: <a href="/content/concepts/tables/#partitioning">Partitioning</a> scheme to use for the output table. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a2f9f59cda9f30cd52196fb1af2070d11">create\_union\_RANGE</a>: Use <a href="/content/concepts/tables/#partitioning-by-range">range partitioning</a>. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ac5b5c374e1e5921ca5dbd9d329bba044">create\_union\_INTERVAL</a>: Use <a href="/content/concepts/tables/#partitioning-by-interval">interval partitioning</a>. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a9a5c2ca46cef489d66e37ed151f6b082">create\_union\_LIST</a>: Use <a href="/content/concepts/tables/#partitioning-by-list">list partitioning</a>. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad27f73eb5bd1b39f9987ab3f3be24991">create\_union\_HASH</a>: Use <a href="/content/concepts/tables/#partitioning-by-hash">hash partitioning</a>. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a71df92ff17c7d81957523718355bda22">create\_union\_SERIES</a>: Use <a href="/content/concepts/tables/#partitioning-by-series">series partitioning</a>. </li>
                      </ul>
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a60fe727d9f5a7c2e143f45f352ad1552">create\_union\_partition\_keys</a>: Comma-separated list of partition keys, which are the columns or column expressions by which records will be assigned to partitions defined by <a href="/content/api/cpp/namespacegpudb#a145a5a32a5fea1df0e4ff29eddcdb299">partition\_definitions</a>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a145a5a32a5fea1df0e4ff29eddcdb299">create\_union\_partition\_definitions</a>: Comma-separated list of partition definitions, whose format depends on the choice of <a href="/content/api/cpp/namespacegpudb#a81ea337287743114191da31177f0ae8c">partition\_type</a>. See <a href="/content/concepts/tables/#partitioning-by-range">range partitioning</a>, <a href="/content/concepts/tables/#partitioning-by-interval">interval partitioning</a>, <a href="/content/concepts/tables/#partitioning-by-list">list partitioning</a>, <a href="/content/concepts/tables/#partitioning-by-hash">hash partitioning</a>, or <a href="/content/concepts/tables/#partitioning-by-series">series partitioning</a> for example formats. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a864937e3c3accf3db0196678e5d43d82">create\_union\_is\_automatic\_partition</a>: If <a href="/content/api/cpp/namespacegpudb#a4c679573328605dc89476ea85fbe6e87">true</a>, a new partition will be created for values which don't fall into an existing partition. Currently only supported for <a href="/content/concepts/tables/#partitioning-by-list">list partitions</a>. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a4c679573328605dc89476ea85fbe6e87">create\_union\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a3196fd11fabb927d36a20e258903b566">create\_union\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a3196fd11fabb927d36a20e258903b566">create\_union\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#ae26c0d26d90ab3efc46df04a3b6f5d82">create\_union\_ttl</a>: Sets the <a href="/content/concepts/ttl/">TTL</a> of the output table specified in <span>tableName</span>. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a9773f20de01667f4a54a013287125d6d">create\_union\_persist</a>: If <a href="/content/api/cpp/namespacegpudb#a4c679573328605dc89476ea85fbe6e87">true</a>, then the output table specified in <span>tableName</span> will be persisted and will not expire unless a <a href="/content/api/cpp/namespacegpudb#ae26c0d26d90ab3efc46df04a3b6f5d82">ttl</a> is specified. If <a href="/content/api/cpp/namespacegpudb#a3196fd11fabb927d36a20e258903b566">false</a>, then the output table will be an in-memory table and will expire unless a <a href="/content/api/cpp/namespacegpudb#ae26c0d26d90ab3efc46df04a3b6f5d82">ttl</a> is specified otherwise. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a4c679573328605dc89476ea85fbe6e87">create\_union\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a3196fd11fabb927d36a20e258903b566">create\_union\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a3196fd11fabb927d36a20e258903b566">create\_union\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a121d9344dd13b32115aae87091b60719">create\_union\_view\_id</a>: ID of view of which this output table is a member. The default value is ''. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a44773403e73d309d0a9ce8584d7f8ed0">create\_union\_force\_replicated</a>: If <a href="/content/api/cpp/namespacegpudb#a4c679573328605dc89476ea85fbe6e87">true</a>, then the output table specified in <span>tableName</span> will be replicated even if the source tables are not. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a4c679573328605dc89476ea85fbe6e87">create\_union\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a3196fd11fabb927d36a20e258903b566">create\_union\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a3196fd11fabb927d36a20e258903b566">create\_union\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#ac00533b09c4716e5648374f898a6d14f">create\_union\_strategy\_definition</a>: The <a href="/content/rm/concepts/#tier-strategies">tier strategy</a> for the table and its columns. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aeeae3d1a145f68adb1aca9d363af98ae">create\_union\_compression\_codec</a>: The default <a href="/content/concepts/column_compression/">compression codec</a> for this table's columns. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#add05709137466e254cb09aa39e9655bd">create\_union\_no\_count</a>: Return a count of 0 for the union table response to avoid the cost of counting; optimization needed for many chunk virtual unions. The default value is 'false'. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CreateUnionResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a77e0ada501f72a9c0bde63922fdcf77d">◆ </a></span>createUnion() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CreateUnionResponse">CreateUnionResponse</a> & gpudb::GPUdb::createUnion </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< std::string > &</td>
            <td><span><span>tableNames</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< std::vector\< std::string > > &</td>
            <td><span><span>inputColumnNames</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< std::string > &</td>
            <td><span><span>outputColumnNames</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1CreateUnionResponse">CreateUnionResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Merges data from one or more tables with comparable data types into a new table. </p>
        <p>The following merges are supported:</p>
        <p>UNION (DISTINCT/ALL) - For data set union details and examples, see <a href="/content/concepts/unions/">Union</a>. For limitations, see <a href="/content/concepts/unions/#limitations-and-cautions">Union Limitations and Cautions</a>.</p>
        <p>INTERSECT (DISTINCT/ALL) - For data set intersection details and examples, see <a href="/content/concepts/intersect/">Intersect</a>. For limitations, see <a href="/content/concepts/intersect/#limitations">Intersect Limitations</a>.</p>
        <p>EXCEPT (DISTINCT/ALL) - For data set subtraction details and examples, see <a href="/content/concepts/except/">Except</a>. For limitations, see <a href="/content/concepts/except/#limitations">Except Limitations</a>.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of the table to be created, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a> and meeting <a href="/content/concepts/tables/#table-naming-criteria">table naming criteria</a>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>tableNames</td>
                <td>The list of table names to merge, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. Must contain the names of one or more existing tables. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>inputColumnNames</td>
                <td>The list of columns from each of the corresponding input tables. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>outputColumnNames</td>
                <td>The list of names of the columns to be stored in the output table. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ae7a132ec4d309fafdc6282b5b988c630">create\_union\_create\_temp\_table</a>: If <a href="/content/api/cpp/namespacegpudb#a4c679573328605dc89476ea85fbe6e87">true</a>, a unique temporary table name will be generated in the sys\_temp schema and used in place of <span>tableName</span>. If <a href="/content/api/cpp/namespacegpudb#a9773f20de01667f4a54a013287125d6d">persist</a> is <a href="/content/api/cpp/namespacegpudb#a3196fd11fabb927d36a20e258903b566">false</a> (or unspecified), then this is always allowed even if the caller does not have permission to create tables. The generated name is returned in <a href="/content/api/cpp/namespacegpudb#a584f96f298fb8560e416d7aa5d12696f">qualified\_table\_name</a>. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a4c679573328605dc89476ea85fbe6e87">create\_union\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a3196fd11fabb927d36a20e258903b566">create\_union\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a3196fd11fabb927d36a20e258903b566">create\_union\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a51ad8919e170db36635d44e753ffb3ca">create\_union\_collection\_name</a>: \[DEPRECATED–please specify the containing schema for the projection as part of <span>tableName</span> and use <a href="#a33d9a0a8e738d14b688f9f869f9640ad">createSchema</a> to create the schema if non-existent] Name of the schema for the output table. If the schema provided is non-existent, it will be automatically created. The default value is ''. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#adeb5407c9e89bd6fbbb6aca40b39d544">create\_union\_mode</a>: The mode describes what rows of the tables being unioned will be retained. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a4d30935577318d7b1b764224cabca31b">create\_union\_union\_all</a>: Retains all rows from the specified tables. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a15a6fc2ec7a782dc2d6192a08cb6a4a9">create\_union\_union</a>: Retains all unique rows from the specified tables (synonym for <a href="/content/api/cpp/namespacegpudb#a7a186e3a270e41a99cf4d3517e892257">union\_distinct</a>). </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a7a186e3a270e41a99cf4d3517e892257">create\_union\_union\_distinct</a>: Retains all unique rows from the specified tables. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a2ef70a26679f465ecdb580dfc326910e">create\_union\_except</a>: Retains all unique rows from the first table that do not appear in the second table (only works on 2 tables). </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a06baad96a6f886c6843b9ab4f18ab297">create\_union\_except\_all</a>: Retains all rows(including duplicates) from the first table that do not appear in the second table (only works on 2 tables). </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a9faa32e71c7c836805f660cd15c439f3">create\_union\_intersect</a>: Retains all unique rows that appear in both of the specified tables (only works on 2 tables). </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a98f20f503e4401f9d21db59fca19d05f">create\_union\_intersect\_all</a>: Retains all rows(including duplicates) that appear in both of the specified tables (only works on 2 tables). </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a4d30935577318d7b1b764224cabca31b">create\_union\_union\_all</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a4e4b51e85582c38d91def6f4980f659d">create\_union\_chunk\_size</a>: Indicates the number of records per chunk to be used for this output table. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a6e878bfd26260961c6ca97993a840b90">create\_union\_chunk\_column\_max\_memory</a>: Indicates the target maximum data size for each column in a chunk to be used for this output table. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ab0f79cbd7c82bf7b2066402d9678720d">create\_union\_chunk\_max\_memory</a>: Indicates the target maximum data size for all columns in a chunk to be used for this output table. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a62165dc74b434196fdc35f7687d53323">create\_union\_create\_indexes</a>: Comma-separated list of columns on which to create indexes on the output table. The columns specified must be present in <span>outputColumnNames</span>. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a81ea337287743114191da31177f0ae8c">create\_union\_partition\_type</a>: <a href="/content/concepts/tables/#partitioning">Partitioning</a> scheme to use for the output table. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a2f9f59cda9f30cd52196fb1af2070d11">create\_union\_RANGE</a>: Use <a href="/content/concepts/tables/#partitioning-by-range">range partitioning</a>. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ac5b5c374e1e5921ca5dbd9d329bba044">create\_union\_INTERVAL</a>: Use <a href="/content/concepts/tables/#partitioning-by-interval">interval partitioning</a>. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a9a5c2ca46cef489d66e37ed151f6b082">create\_union\_LIST</a>: Use <a href="/content/concepts/tables/#partitioning-by-list">list partitioning</a>. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad27f73eb5bd1b39f9987ab3f3be24991">create\_union\_HASH</a>: Use <a href="/content/concepts/tables/#partitioning-by-hash">hash partitioning</a>. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a71df92ff17c7d81957523718355bda22">create\_union\_SERIES</a>: Use <a href="/content/concepts/tables/#partitioning-by-series">series partitioning</a>. </li>
                      </ul>
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a60fe727d9f5a7c2e143f45f352ad1552">create\_union\_partition\_keys</a>: Comma-separated list of partition keys, which are the columns or column expressions by which records will be assigned to partitions defined by <a href="/content/api/cpp/namespacegpudb#a145a5a32a5fea1df0e4ff29eddcdb299">partition\_definitions</a>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a145a5a32a5fea1df0e4ff29eddcdb299">create\_union\_partition\_definitions</a>: Comma-separated list of partition definitions, whose format depends on the choice of <a href="/content/api/cpp/namespacegpudb#a81ea337287743114191da31177f0ae8c">partition\_type</a>. See <a href="/content/concepts/tables/#partitioning-by-range">range partitioning</a>, <a href="/content/concepts/tables/#partitioning-by-interval">interval partitioning</a>, <a href="/content/concepts/tables/#partitioning-by-list">list partitioning</a>, <a href="/content/concepts/tables/#partitioning-by-hash">hash partitioning</a>, or <a href="/content/concepts/tables/#partitioning-by-series">series partitioning</a> for example formats. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a864937e3c3accf3db0196678e5d43d82">create\_union\_is\_automatic\_partition</a>: If <a href="/content/api/cpp/namespacegpudb#a4c679573328605dc89476ea85fbe6e87">true</a>, a new partition will be created for values which don't fall into an existing partition. Currently only supported for <a href="/content/concepts/tables/#partitioning-by-list">list partitions</a>. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a4c679573328605dc89476ea85fbe6e87">create\_union\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a3196fd11fabb927d36a20e258903b566">create\_union\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a3196fd11fabb927d36a20e258903b566">create\_union\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#ae26c0d26d90ab3efc46df04a3b6f5d82">create\_union\_ttl</a>: Sets the <a href="/content/concepts/ttl/">TTL</a> of the output table specified in <span>tableName</span>. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a9773f20de01667f4a54a013287125d6d">create\_union\_persist</a>: If <a href="/content/api/cpp/namespacegpudb#a4c679573328605dc89476ea85fbe6e87">true</a>, then the output table specified in <span>tableName</span> will be persisted and will not expire unless a <a href="/content/api/cpp/namespacegpudb#ae26c0d26d90ab3efc46df04a3b6f5d82">ttl</a> is specified. If <a href="/content/api/cpp/namespacegpudb#a3196fd11fabb927d36a20e258903b566">false</a>, then the output table will be an in-memory table and will expire unless a <a href="/content/api/cpp/namespacegpudb#ae26c0d26d90ab3efc46df04a3b6f5d82">ttl</a> is specified otherwise. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a4c679573328605dc89476ea85fbe6e87">create\_union\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a3196fd11fabb927d36a20e258903b566">create\_union\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a3196fd11fabb927d36a20e258903b566">create\_union\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a121d9344dd13b32115aae87091b60719">create\_union\_view\_id</a>: ID of view of which this output table is a member. The default value is ''. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a44773403e73d309d0a9ce8584d7f8ed0">create\_union\_force\_replicated</a>: If <a href="/content/api/cpp/namespacegpudb#a4c679573328605dc89476ea85fbe6e87">true</a>, then the output table specified in <span>tableName</span> will be replicated even if the source tables are not. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a4c679573328605dc89476ea85fbe6e87">create\_union\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a3196fd11fabb927d36a20e258903b566">create\_union\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a3196fd11fabb927d36a20e258903b566">create\_union\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#ac00533b09c4716e5648374f898a6d14f">create\_union\_strategy\_definition</a>: The <a href="/content/rm/concepts/#tier-strategies">tier strategy</a> for the table and its columns. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aeeae3d1a145f68adb1aca9d363af98ae">create\_union\_compression\_codec</a>: The default <a href="/content/concepts/column_compression/">compression codec</a> for this table's columns. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#add05709137466e254cb09aa39e9655bd">create\_union\_no\_count</a>: Return a count of 0 for the union table response to avoid the cost of counting; optimization needed for many chunk virtual unions. The default value is 'false'. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CreateUnionResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CreateUnionResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a0b63a9b008db5b7c78b098877286af3c">◆ </a></span>createUserExternal() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CreateUserExternalResponse">CreateUserExternalResponse</a> gpudb::GPUdb::createUserExternal </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1CreateUserExternalRequest">CreateUserExternalRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Creates a new external user (a user whose credentials are managed by an external LDAP). </p>

        <div>
          <div>Attention</div>
          <div>This method should be used for on-premise deployments only.</div>
        </div>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CreateUserExternalRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CreateUserExternalResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a536d649e7acb6a0e2c0a138c8c8d7dda">◆ </a></span>createUserExternal() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CreateUserExternalResponse">CreateUserExternalResponse</a> & gpudb::GPUdb::createUserExternal </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1CreateUserExternalRequest">CreateUserExternalRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1CreateUserExternalResponse">CreateUserExternalResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Creates a new external user (a user whose credentials are managed by an external LDAP). </p>

        <div>
          <div>Attention</div>
          <div>This method should be used for on-premise deployments only.</div>
        </div>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CreateUserExternalRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CreateUserExternalResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CreateUserExternalResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#abf75994b026f56c55ebc0abef27b0227">◆ </a></span>createUserExternal() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CreateUserExternalResponse">CreateUserExternalResponse</a> gpudb::GPUdb::createUserExternal </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Creates a new external user (a user whose credentials are managed by an external LDAP). </p>

        <div>
          <div>Attention</div>
          <div>This method should be used for on-premise deployments only.</div>
        </div>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>name</td>
                <td>Name of the user to be created. Must exactly match the user's name in the external LDAP, prefixed with a . Must not be the same name as an existing user. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#afe69532ac3f347e6009504014b13cc41">create\_user\_external\_activated</a>: Is the user allowed to login. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a88e333db994619b41748d4cd19ff079a">create\_user\_external\_true</a>: User may login. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a6c95688cb1239a45335e23a9cbe26f7e">create\_user\_external\_false</a>: User may not login. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a88e333db994619b41748d4cd19ff079a">create\_user\_external\_true</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a5c63f45103dd2638a7a16ea13b809849">create\_user\_external\_create\_home\_directory</a>: When <a href="/content/api/cpp/namespacegpudb#a88e333db994619b41748d4cd19ff079a">true</a>, a home directory in KiFS is created for this user. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a88e333db994619b41748d4cd19ff079a">create\_user\_external\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a6c95688cb1239a45335e23a9cbe26f7e">create\_user\_external\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a88e333db994619b41748d4cd19ff079a">create\_user\_external\_true</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a8749c1a123ba224bcdee3254c65e5946">create\_user\_external\_default\_schema</a>: Default schema to associate with this user. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a50b8802403b5539d54ef4ee854f28da7">create\_user\_external\_directory\_data\_limit</a>: The maximum capacity to apply to the created directory if <a href="/content/api/cpp/namespacegpudb#a5c63f45103dd2638a7a16ea13b809849">create\_home\_directory</a> is <a href="/content/api/cpp/namespacegpudb#a88e333db994619b41748d4cd19ff079a">true</a>. Set to -1 to indicate no upper limit. If empty, the system default limit is applied. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a424a974b660910e857807f8bf5c6da58">create\_user\_external\_resource\_group</a>: Name of an existing resource group to associate with this user. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CreateUserExternalResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#abbcbb0ef0e7787d413ae18f5e9f3cfd7">◆ </a></span>createUserExternal() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CreateUserExternalResponse">CreateUserExternalResponse</a> & gpudb::GPUdb::createUserExternal </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1CreateUserExternalResponse">CreateUserExternalResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Creates a new external user (a user whose credentials are managed by an external LDAP). </p>

        <div>
          <div>Attention</div>
          <div>This method should be used for on-premise deployments only.</div>
        </div>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>name</td>
                <td>Name of the user to be created. Must exactly match the user's name in the external LDAP, prefixed with a . Must not be the same name as an existing user. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#afe69532ac3f347e6009504014b13cc41">create\_user\_external\_activated</a>: Is the user allowed to login. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a88e333db994619b41748d4cd19ff079a">create\_user\_external\_true</a>: User may login. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a6c95688cb1239a45335e23a9cbe26f7e">create\_user\_external\_false</a>: User may not login. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a88e333db994619b41748d4cd19ff079a">create\_user\_external\_true</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a5c63f45103dd2638a7a16ea13b809849">create\_user\_external\_create\_home\_directory</a>: When <a href="/content/api/cpp/namespacegpudb#a88e333db994619b41748d4cd19ff079a">true</a>, a home directory in KiFS is created for this user. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a88e333db994619b41748d4cd19ff079a">create\_user\_external\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a6c95688cb1239a45335e23a9cbe26f7e">create\_user\_external\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a88e333db994619b41748d4cd19ff079a">create\_user\_external\_true</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a8749c1a123ba224bcdee3254c65e5946">create\_user\_external\_default\_schema</a>: Default schema to associate with this user. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a50b8802403b5539d54ef4ee854f28da7">create\_user\_external\_directory\_data\_limit</a>: The maximum capacity to apply to the created directory if <a href="/content/api/cpp/namespacegpudb#a5c63f45103dd2638a7a16ea13b809849">create\_home\_directory</a> is <a href="/content/api/cpp/namespacegpudb#a88e333db994619b41748d4cd19ff079a">true</a>. Set to -1 to indicate no upper limit. If empty, the system default limit is applied. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a424a974b660910e857807f8bf5c6da58">create\_user\_external\_resource\_group</a>: Name of an existing resource group to associate with this user. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CreateUserExternalResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CreateUserExternalResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a00da63ad9e89859132ae0b44226d9015">◆ </a></span>createUserInternal() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CreateUserInternalResponse">CreateUserInternalResponse</a> gpudb::GPUdb::createUserInternal </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1CreateUserInternalRequest">CreateUserInternalRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Creates a new internal user (a user whose credentials are managed by the database system). </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CreateUserInternalRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CreateUserInternalResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#adefdfd170305aab9d2c49023c4122f46">◆ </a></span>createUserInternal() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CreateUserInternalResponse">CreateUserInternalResponse</a> & gpudb::GPUdb::createUserInternal </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1CreateUserInternalRequest">CreateUserInternalRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1CreateUserInternalResponse">CreateUserInternalResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Creates a new internal user (a user whose credentials are managed by the database system). </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CreateUserInternalRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CreateUserInternalResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CreateUserInternalResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#afac3f442800a21affe448aac71d6c10b">◆ </a></span>createUserInternal() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CreateUserInternalResponse">CreateUserInternalResponse</a> gpudb::GPUdb::createUserInternal </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>password</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Creates a new internal user (a user whose credentials are managed by the database system). </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>name</td>
                <td>Name of the user to be created. Must contain only lowercase letters, digits, and underscores, and cannot begin with a digit. Must not be the same name as an existing user or role. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>password</td>
                <td>Initial password of the user to be created. May be an empty string for no password. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a7eb777a1a597f5a1e3970afa452494b0">create\_user\_internal\_activated</a>: Is the user allowed to login. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ab60cb39a81e1a932dc819dc2ddb478a5">create\_user\_internal\_true</a>: User may login. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#af9ea71b4289809dc994bab3c99680750">create\_user\_internal\_false</a>: User may not login. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ab60cb39a81e1a932dc819dc2ddb478a5">create\_user\_internal\_true</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ab45a5d4f3fda1f3cd4e374ef812d0df7">create\_user\_internal\_create\_home\_directory</a>: When <a href="/content/api/cpp/namespacegpudb#ab60cb39a81e1a932dc819dc2ddb478a5">true</a>, a home directory in KiFS is created for this user. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ab60cb39a81e1a932dc819dc2ddb478a5">create\_user\_internal\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#af9ea71b4289809dc994bab3c99680750">create\_user\_internal\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ab60cb39a81e1a932dc819dc2ddb478a5">create\_user\_internal\_true</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a1ef594329600bc9f2b2598d0e6d70e1b">create\_user\_internal\_default\_schema</a>: Default schema to associate with this user. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a53d2f5c597c8b760067cc00d91f47d1d">create\_user\_internal\_directory\_data\_limit</a>: The maximum capacity to apply to the created directory if <a href="/content/api/cpp/namespacegpudb#ab45a5d4f3fda1f3cd4e374ef812d0df7">create\_home\_directory</a> is <a href="/content/api/cpp/namespacegpudb#ab60cb39a81e1a932dc819dc2ddb478a5">true</a>. Set to -1 to indicate no upper limit. If empty, the system default limit is applied. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ad0269eedd215ae86df0e34bff1b78b53">create\_user\_internal\_resource\_group</a>: Name of an existing resource group to associate with this user. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CreateUserInternalResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ae94b0a8211f45f2a1be1c00a6c226cbf">◆ </a></span>createUserInternal() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CreateUserInternalResponse">CreateUserInternalResponse</a> & gpudb::GPUdb::createUserInternal </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>password</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1CreateUserInternalResponse">CreateUserInternalResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Creates a new internal user (a user whose credentials are managed by the database system). </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>name</td>
                <td>Name of the user to be created. Must contain only lowercase letters, digits, and underscores, and cannot begin with a digit. Must not be the same name as an existing user or role. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>password</td>
                <td>Initial password of the user to be created. May be an empty string for no password. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a7eb777a1a597f5a1e3970afa452494b0">create\_user\_internal\_activated</a>: Is the user allowed to login. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ab60cb39a81e1a932dc819dc2ddb478a5">create\_user\_internal\_true</a>: User may login. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#af9ea71b4289809dc994bab3c99680750">create\_user\_internal\_false</a>: User may not login. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ab60cb39a81e1a932dc819dc2ddb478a5">create\_user\_internal\_true</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ab45a5d4f3fda1f3cd4e374ef812d0df7">create\_user\_internal\_create\_home\_directory</a>: When <a href="/content/api/cpp/namespacegpudb#ab60cb39a81e1a932dc819dc2ddb478a5">true</a>, a home directory in KiFS is created for this user. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ab60cb39a81e1a932dc819dc2ddb478a5">create\_user\_internal\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#af9ea71b4289809dc994bab3c99680750">create\_user\_internal\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ab60cb39a81e1a932dc819dc2ddb478a5">create\_user\_internal\_true</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a1ef594329600bc9f2b2598d0e6d70e1b">create\_user\_internal\_default\_schema</a>: Default schema to associate with this user. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a53d2f5c597c8b760067cc00d91f47d1d">create\_user\_internal\_directory\_data\_limit</a>: The maximum capacity to apply to the created directory if <a href="/content/api/cpp/namespacegpudb#ab45a5d4f3fda1f3cd4e374ef812d0df7">create\_home\_directory</a> is <a href="/content/api/cpp/namespacegpudb#ab60cb39a81e1a932dc819dc2ddb478a5">true</a>. Set to -1 to indicate no upper limit. If empty, the system default limit is applied. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ad0269eedd215ae86df0e34bff1b78b53">create\_user\_internal\_resource\_group</a>: Name of an existing resource group to associate with this user. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CreateUserInternalResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CreateUserInternalResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ae81d077f831f4e98c69ea0a58be83c32">◆ </a></span>createVideo() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CreateVideoResponse">CreateVideoResponse</a> gpudb::GPUdb::createVideo </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1CreateVideoRequest">CreateVideoRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Creates a job to generate a sequence of raster images that visualize data over a specified time. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CreateVideoRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CreateVideoResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ab496488e5c4fe83f0974f79c0f222fe8">◆ </a></span>createVideo() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CreateVideoResponse">CreateVideoResponse</a> & gpudb::GPUdb::createVideo </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1CreateVideoRequest">CreateVideoRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1CreateVideoResponse">CreateVideoResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Creates a job to generate a sequence of raster images that visualize data over a specified time. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CreateVideoRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CreateVideoResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CreateVideoResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#af14dc5b767384075f16aa02a1ede6f0d">◆ </a></span>createVideo() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CreateVideoResponse">CreateVideoResponse</a> gpudb::GPUdb::createVideo </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>attribute</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>begin</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const double</td>
            <td><span><span>durationSeconds</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>end</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const double</td>
            <td><span><span>framesPerSecond</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>style</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>path</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>styleParameters</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Creates a job to generate a sequence of raster images that visualize data over a specified time. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>attribute</td>
                <td>The animated attribute to map to the video's frames. Must be present in the LAYERS specified for the visualization. This is often a time-related field but may be any numeric type. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>begin</td>
                <td>The start point for the video. Accepts an expression evaluable over the <span>attribute</span>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>durationSeconds</td>
                <td>Seconds of video to produce. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>end</td>
                <td>The end point for the video. Accepts an expression evaluable over the <span>attribute</span>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>framesPerSecond</td>
                <td>The presentation frame rate of the encoded video in frames per second. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>style</td>

                <td>
                  The name of the visualize mode; should correspond to the schema used for the <span>styleParameters</span> field. Supported values:

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#afe152a971e8d3f8e5418c6502636c284">create\_video\_chart</a> </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a100965ab532f8518724480de468d89e5">create\_video\_raster</a> </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a3a76afa5f92387e7c724911d767856d6">create\_video\_classbreak</a> </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a4d22d6c9e12c770a3a04d54917a8fa09">create\_video\_contour</a> </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a35721de038587daf4a395a07a5a658b5">create\_video\_heatmap</a> </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aa5e3bd88a0e45f33c240e3e42286fe77">create\_video\_labels</a> </li>
                  </ul>
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>path</td>
                <td>Fully-qualified <a href="/content/tools/kifs/">KiFS</a> path. Write access is required. A file must not exist at that path, unless <a href="/content/api/cpp/namespacegpudb#a6bf126d03476b8e410bd863be494b799">replace\_if\_exists</a> is <a href="/content/api/cpp/namespacegpudb#a101a81ee5c9040cdc1f899fee4a2575b">true</a>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>styleParameters</td>
                <td>A string containing the JSON-encoded visualize request. Must correspond to the visualize mode specified in the <span>style</span> field. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a78f0c862fbe5ec9838929877d26abf0a">create\_video\_ttl</a>: Sets the <a href="/content/concepts/ttl">TTL</a> of the video. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aa50ce6b5c3a5889a951aba21195e770f">create\_video\_window</a>: Specified using the data-type corresponding to the <span>attribute</span>. For a window of size W, a video frame rendered for time t will visualize data in the interval \[t-W,t]. The minimum window size is the interval between successive frames. The minimum value is the default. If a value less than the minimum value is specified, it is replaced with the minimum window size. Larger values will make changes throughout the video appear more smooth while smaller values will capture fast variations in the data. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a6be638b7a0100fa3a132dd8ea971cec1">create\_video\_no\_error\_if\_exists</a>: If <a href="/content/api/cpp/namespacegpudb#a101a81ee5c9040cdc1f899fee4a2575b">true</a>, does not return an error if the video already exists. Ignored if <a href="/content/api/cpp/namespacegpudb#a6bf126d03476b8e410bd863be494b799">replace\_if\_exists</a> is <a href="/content/api/cpp/namespacegpudb#a101a81ee5c9040cdc1f899fee4a2575b">true</a>. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a80a3fba66a887d5d9512580e0fd8be68">create\_video\_false</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a101a81ee5c9040cdc1f899fee4a2575b">create\_video\_true</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a80a3fba66a887d5d9512580e0fd8be68">create\_video\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a6bf126d03476b8e410bd863be494b799">create\_video\_replace\_if\_exists</a>: If <a href="/content/api/cpp/namespacegpudb#a101a81ee5c9040cdc1f899fee4a2575b">true</a>, deletes any existing video with the same path before creating a new video. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a80a3fba66a887d5d9512580e0fd8be68">create\_video\_false</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a101a81ee5c9040cdc1f899fee4a2575b">create\_video\_true</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a80a3fba66a887d5d9512580e0fd8be68">create\_video\_false</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CreateVideoResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a7fdf6087dc9b6b89564696f7e7a2a8b0">◆ </a></span>createVideo() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1CreateVideoResponse">CreateVideoResponse</a> & gpudb::GPUdb::createVideo </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>attribute</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>begin</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const double</td>
            <td><span><span>durationSeconds</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>end</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const double</td>
            <td><span><span>framesPerSecond</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>style</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>path</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>styleParameters</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1CreateVideoResponse">CreateVideoResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Creates a job to generate a sequence of raster images that visualize data over a specified time. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>attribute</td>
                <td>The animated attribute to map to the video's frames. Must be present in the LAYERS specified for the visualization. This is often a time-related field but may be any numeric type. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>begin</td>
                <td>The start point for the video. Accepts an expression evaluable over the <span>attribute</span>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>durationSeconds</td>
                <td>Seconds of video to produce. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>end</td>
                <td>The end point for the video. Accepts an expression evaluable over the <span>attribute</span>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>framesPerSecond</td>
                <td>The presentation frame rate of the encoded video in frames per second. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>style</td>

                <td>
                  The name of the visualize mode; should correspond to the schema used for the <span>styleParameters</span> field. Supported values:

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#afe152a971e8d3f8e5418c6502636c284">create\_video\_chart</a> </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a100965ab532f8518724480de468d89e5">create\_video\_raster</a> </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a3a76afa5f92387e7c724911d767856d6">create\_video\_classbreak</a> </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a4d22d6c9e12c770a3a04d54917a8fa09">create\_video\_contour</a> </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a35721de038587daf4a395a07a5a658b5">create\_video\_heatmap</a> </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aa5e3bd88a0e45f33c240e3e42286fe77">create\_video\_labels</a> </li>
                  </ul>
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>path</td>
                <td>Fully-qualified <a href="/content/tools/kifs/">KiFS</a> path. Write access is required. A file must not exist at that path, unless <a href="/content/api/cpp/namespacegpudb#a6bf126d03476b8e410bd863be494b799">replace\_if\_exists</a> is <a href="/content/api/cpp/namespacegpudb#a101a81ee5c9040cdc1f899fee4a2575b">true</a>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>styleParameters</td>
                <td>A string containing the JSON-encoded visualize request. Must correspond to the visualize mode specified in the <span>style</span> field. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a78f0c862fbe5ec9838929877d26abf0a">create\_video\_ttl</a>: Sets the <a href="/content/concepts/ttl">TTL</a> of the video. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aa50ce6b5c3a5889a951aba21195e770f">create\_video\_window</a>: Specified using the data-type corresponding to the <span>attribute</span>. For a window of size W, a video frame rendered for time t will visualize data in the interval \[t-W,t]. The minimum window size is the interval between successive frames. The minimum value is the default. If a value less than the minimum value is specified, it is replaced with the minimum window size. Larger values will make changes throughout the video appear more smooth while smaller values will capture fast variations in the data. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a6be638b7a0100fa3a132dd8ea971cec1">create\_video\_no\_error\_if\_exists</a>: If <a href="/content/api/cpp/namespacegpudb#a101a81ee5c9040cdc1f899fee4a2575b">true</a>, does not return an error if the video already exists. Ignored if <a href="/content/api/cpp/namespacegpudb#a6bf126d03476b8e410bd863be494b799">replace\_if\_exists</a> is <a href="/content/api/cpp/namespacegpudb#a101a81ee5c9040cdc1f899fee4a2575b">true</a>. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a80a3fba66a887d5d9512580e0fd8be68">create\_video\_false</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a101a81ee5c9040cdc1f899fee4a2575b">create\_video\_true</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a80a3fba66a887d5d9512580e0fd8be68">create\_video\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a6bf126d03476b8e410bd863be494b799">create\_video\_replace\_if\_exists</a>: If <a href="/content/api/cpp/namespacegpudb#a101a81ee5c9040cdc1f899fee4a2575b">true</a>, deletes any existing video with the same path before creating a new video. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a80a3fba66a887d5d9512580e0fd8be68">create\_video\_false</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a101a81ee5c9040cdc1f899fee4a2575b">create\_video\_true</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a80a3fba66a887d5d9512580e0fd8be68">create\_video\_false</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1CreateVideoResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1CreateVideoResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#afe45987d438414b862ff310e0232e83e">◆ </a></span>deleteDirectory() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1DeleteDirectoryResponse">DeleteDirectoryResponse</a> gpudb::GPUdb::deleteDirectory </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1DeleteDirectoryRequest">DeleteDirectoryRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Deletes a directory from <a href="/content/tools/kifs/">KiFS</a>. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1DeleteDirectoryRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1DeleteDirectoryResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ad4386f3a6f03bc6a845ea8296303d10a">◆ </a></span>deleteDirectory() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1DeleteDirectoryResponse">DeleteDirectoryResponse</a> & gpudb::GPUdb::deleteDirectory </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1DeleteDirectoryRequest">DeleteDirectoryRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1DeleteDirectoryResponse">DeleteDirectoryResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Deletes a directory from <a href="/content/tools/kifs/">KiFS</a>. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1DeleteDirectoryRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1DeleteDirectoryResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1DeleteDirectoryResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a95029975ac7617f02a217e6a1303a743">◆ </a></span>deleteDirectory() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1DeleteDirectoryResponse">DeleteDirectoryResponse</a> gpudb::GPUdb::deleteDirectory </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>directoryName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Deletes a directory from <a href="/content/tools/kifs/">KiFS</a>. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>directoryName</td>
                <td>Name of the directory in KiFS to be deleted. The directory must contain no files, unless <a href="/content/api/cpp/namespacegpudb#ac25d5650f68f2b9b33931f966c49555f">recursive</a> is <a href="/content/api/cpp/namespacegpudb#a620d2b4ef97df73c6d9e31e219f1ed42">true</a>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ac25d5650f68f2b9b33931f966c49555f">delete\_directory\_recursive</a>: If <a href="/content/api/cpp/namespacegpudb#a620d2b4ef97df73c6d9e31e219f1ed42">true</a>, will delete directory and all files residing in it. If false, directory must be empty for deletion. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a620d2b4ef97df73c6d9e31e219f1ed42">delete\_directory\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#af326a5e14f6a21cfa77425ee79127247">delete\_directory\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#af326a5e14f6a21cfa77425ee79127247">delete\_directory\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ac97ecd16041fcdea66f3e53f12c6553c">delete\_directory\_no\_error\_if\_not\_exists</a>: If <a href="/content/api/cpp/namespacegpudb#a620d2b4ef97df73c6d9e31e219f1ed42">true</a>, no error is returned if specified directory does not exist. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a620d2b4ef97df73c6d9e31e219f1ed42">delete\_directory\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#af326a5e14f6a21cfa77425ee79127247">delete\_directory\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#af326a5e14f6a21cfa77425ee79127247">delete\_directory\_false</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1DeleteDirectoryResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a8f2c1ddfb5625eedbee937a15e8041af">◆ </a></span>deleteDirectory() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1DeleteDirectoryResponse">DeleteDirectoryResponse</a> & gpudb::GPUdb::deleteDirectory </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>directoryName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1DeleteDirectoryResponse">DeleteDirectoryResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Deletes a directory from <a href="/content/tools/kifs/">KiFS</a>. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>directoryName</td>
                <td>Name of the directory in KiFS to be deleted. The directory must contain no files, unless <a href="/content/api/cpp/namespacegpudb#ac25d5650f68f2b9b33931f966c49555f">recursive</a> is <a href="/content/api/cpp/namespacegpudb#a620d2b4ef97df73c6d9e31e219f1ed42">true</a>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ac25d5650f68f2b9b33931f966c49555f">delete\_directory\_recursive</a>: If <a href="/content/api/cpp/namespacegpudb#a620d2b4ef97df73c6d9e31e219f1ed42">true</a>, will delete directory and all files residing in it. If false, directory must be empty for deletion. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a620d2b4ef97df73c6d9e31e219f1ed42">delete\_directory\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#af326a5e14f6a21cfa77425ee79127247">delete\_directory\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#af326a5e14f6a21cfa77425ee79127247">delete\_directory\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ac97ecd16041fcdea66f3e53f12c6553c">delete\_directory\_no\_error\_if\_not\_exists</a>: If <a href="/content/api/cpp/namespacegpudb#a620d2b4ef97df73c6d9e31e219f1ed42">true</a>, no error is returned if specified directory does not exist. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a620d2b4ef97df73c6d9e31e219f1ed42">delete\_directory\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#af326a5e14f6a21cfa77425ee79127247">delete\_directory\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#af326a5e14f6a21cfa77425ee79127247">delete\_directory\_false</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1DeleteDirectoryResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1DeleteDirectoryResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a75e4fd348dc250cbb2a1c21fb893ec4f">◆ </a></span>deleteFiles() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1DeleteFilesResponse">DeleteFilesResponse</a> gpudb::GPUdb::deleteFiles </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1DeleteFilesRequest">DeleteFilesRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Deletes one or more files from <a href="/content/tools/kifs/">KiFS</a>. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1DeleteFilesRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1DeleteFilesResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ae3198839ed8dfbd5be8a9177fca50925">◆ </a></span>deleteFiles() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1DeleteFilesResponse">DeleteFilesResponse</a> & gpudb::GPUdb::deleteFiles </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1DeleteFilesRequest">DeleteFilesRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1DeleteFilesResponse">DeleteFilesResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Deletes one or more files from <a href="/content/tools/kifs/">KiFS</a>. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1DeleteFilesRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1DeleteFilesResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1DeleteFilesResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#afb117f49f083747753d3f0c8c0f3c09c">◆ </a></span>deleteFiles() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1DeleteFilesResponse">DeleteFilesResponse</a> gpudb::GPUdb::deleteFiles </td>
            <td>(</td>
            <td>const std::vector\< std::string > &</td>
            <td><span><span>fileNames</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Deletes one or more files from <a href="/content/tools/kifs/">KiFS</a>. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>fileNames</td>
                <td>An array of names of files to be deleted. File paths may contain wildcard characters after the KiFS directory delimiter. Accepted wildcard characters are asterisk (\*) to represent any string of zero or more characters, and question mark (?) to indicate a single character. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a1c101684fd2a7bf9938d723a89a0d299">delete\_files\_no\_error\_if\_not\_exists</a>: If <a href="/content/api/cpp/namespacegpudb#ac44710b49d35f16376c3119744109d27">true</a>, no error is returned if a specified file does not exist. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ac44710b49d35f16376c3119744109d27">delete\_files\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a55cd46bb5246b387ab60a2fe1c1225b7">delete\_files\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a55cd46bb5246b387ab60a2fe1c1225b7">delete\_files\_false</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1DeleteFilesResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a1599c4b1573a494c833d7c683f3b68ed">◆ </a></span>deleteFiles() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1DeleteFilesResponse">DeleteFilesResponse</a> & gpudb::GPUdb::deleteFiles </td>
            <td>(</td>
            <td>const std::vector\< std::string > &</td>
            <td><span><span>fileNames</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1DeleteFilesResponse">DeleteFilesResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Deletes one or more files from <a href="/content/tools/kifs/">KiFS</a>. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>fileNames</td>
                <td>An array of names of files to be deleted. File paths may contain wildcard characters after the KiFS directory delimiter. Accepted wildcard characters are asterisk (\*) to represent any string of zero or more characters, and question mark (?) to indicate a single character. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a1c101684fd2a7bf9938d723a89a0d299">delete\_files\_no\_error\_if\_not\_exists</a>: If <a href="/content/api/cpp/namespacegpudb#ac44710b49d35f16376c3119744109d27">true</a>, no error is returned if a specified file does not exist. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ac44710b49d35f16376c3119744109d27">delete\_files\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a55cd46bb5246b387ab60a2fe1c1225b7">delete\_files\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a55cd46bb5246b387ab60a2fe1c1225b7">delete\_files\_false</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1DeleteFilesResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1DeleteFilesResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a856b5855b4b4179036949947353ffa11">◆ </a></span>deleteGraph() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1DeleteGraphResponse">DeleteGraphResponse</a> gpudb::GPUdb::deleteGraph </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1DeleteGraphRequest">DeleteGraphRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Deletes an existing graph from the graph server and/or persist. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1DeleteGraphRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1DeleteGraphResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a7c348316ef92aa6211508d943e40453a">◆ </a></span>deleteGraph() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1DeleteGraphResponse">DeleteGraphResponse</a> & gpudb::GPUdb::deleteGraph </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1DeleteGraphRequest">DeleteGraphRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1DeleteGraphResponse">DeleteGraphResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Deletes an existing graph from the graph server and/or persist. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1DeleteGraphRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1DeleteGraphResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1DeleteGraphResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#aaa544a93e287b733c600682cbf3dfb4b">◆ </a></span>deleteGraph() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1DeleteGraphResponse">DeleteGraphResponse</a> gpudb::GPUdb::deleteGraph </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>graphName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Deletes an existing graph from the graph server and/or persist. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>graphName</td>
                <td>Name of the graph to be deleted. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ac82e804e5c35146e4250b6c534fe2e77">delete\_graph\_delete\_persist</a>: If set to <a href="/content/api/cpp/namespacegpudb#a7fb67ac0b9037b36415175d7f9b84817">true</a>, the graph is removed from the server and persist. If set to <a href="/content/api/cpp/namespacegpudb#ab5c23bbbbf2a13cab6527928fe53d5aa">false</a>, the graph is removed from the server but is left in persist. The graph can be reloaded from persist if it is recreated with the same 'graph\_name'. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a7fb67ac0b9037b36415175d7f9b84817">delete\_graph\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ab5c23bbbbf2a13cab6527928fe53d5aa">delete\_graph\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a7fb67ac0b9037b36415175d7f9b84817">delete\_graph\_true</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#abbaaabc2f0131ca554e84fe928157fd1">delete\_graph\_server\_id</a>: Indicates which graph server(s) to send the request to. Default is to send to get information about all the servers. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1DeleteGraphResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a6b0dd83e8aec362c8812868088ca4ce1">◆ </a></span>deleteGraph() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1DeleteGraphResponse">DeleteGraphResponse</a> & gpudb::GPUdb::deleteGraph </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>graphName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1DeleteGraphResponse">DeleteGraphResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Deletes an existing graph from the graph server and/or persist. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>graphName</td>
                <td>Name of the graph to be deleted. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ac82e804e5c35146e4250b6c534fe2e77">delete\_graph\_delete\_persist</a>: If set to <a href="/content/api/cpp/namespacegpudb#a7fb67ac0b9037b36415175d7f9b84817">true</a>, the graph is removed from the server and persist. If set to <a href="/content/api/cpp/namespacegpudb#ab5c23bbbbf2a13cab6527928fe53d5aa">false</a>, the graph is removed from the server but is left in persist. The graph can be reloaded from persist if it is recreated with the same 'graph\_name'. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a7fb67ac0b9037b36415175d7f9b84817">delete\_graph\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ab5c23bbbbf2a13cab6527928fe53d5aa">delete\_graph\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a7fb67ac0b9037b36415175d7f9b84817">delete\_graph\_true</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#abbaaabc2f0131ca554e84fe928157fd1">delete\_graph\_server\_id</a>: Indicates which graph server(s) to send the request to. Default is to send to get information about all the servers. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1DeleteGraphResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1DeleteGraphResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a031d477fc8efd8fff4c0dbddec79a061">◆ </a></span>deleteProc() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1DeleteProcResponse">DeleteProcResponse</a> gpudb::GPUdb::deleteProc </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1DeleteProcRequest">DeleteProcRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Deletes a proc. </p>
        <p>Any currently running instances of the proc will be killed.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1DeleteProcRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1DeleteProcResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#aa1eadd0fc6cd3e3a57cece7d4bccec2b">◆ </a></span>deleteProc() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1DeleteProcResponse">DeleteProcResponse</a> & gpudb::GPUdb::deleteProc </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1DeleteProcRequest">DeleteProcRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1DeleteProcResponse">DeleteProcResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Deletes a proc. </p>
        <p>Any currently running instances of the proc will be killed.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1DeleteProcRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1DeleteProcResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1DeleteProcResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#adcbac7a4a4f00e9d259bfd223cbe0965">◆ </a></span>deleteProc() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1DeleteProcResponse">DeleteProcResponse</a> gpudb::GPUdb::deleteProc </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>procName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Deletes a proc. </p>
        <p>Any currently running instances of the proc will be killed.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>procName</td>
                <td>Name of the proc to be deleted. Must be the name of a currently existing proc. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1DeleteProcResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#abacf44b2b918a5701dc13b321ea2aaeb">◆ </a></span>deleteProc() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1DeleteProcResponse">DeleteProcResponse</a> & gpudb::GPUdb::deleteProc </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>procName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1DeleteProcResponse">DeleteProcResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Deletes a proc. </p>
        <p>Any currently running instances of the proc will be killed.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>procName</td>
                <td>Name of the proc to be deleted. Must be the name of a currently existing proc. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1DeleteProcResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1DeleteProcResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a737a76b0c9fdd8d091dc6d02e9fcac78">◆ </a></span>deleteRecords() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1DeleteRecordsResponse">DeleteRecordsResponse</a> gpudb::GPUdb::deleteRecords </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1DeleteRecordsRequest">DeleteRecordsRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Deletes record(s) matching the provided criteria from the given table. </p>
        <p>The record selection criteria can either be one or more <a href="/content/api/cpp/structgpudb_1_1DeleteRecordsRequest#a337a4aedda81f8ff2ceb4080cde1ea07">expressions</a> (matching multiple records), a single record identified by <a href="/content/api/cpp/namespacegpudb#ad42fcb5679c9c0432a46547e529eef7b">record\_id</a> options, or all records when using <a href="/content/api/cpp/namespacegpudb#a038cecdc7ab035a6642a3790f9ffa1a6">delete\_all\_records</a>. Note that the three selection criteria are mutually exclusive. This operation cannot be run on a view. The operation is synchronous meaning that a response will not be available until the request is completely processed and all the matching records are deleted.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1DeleteRecordsRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1DeleteRecordsResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#af182254f80a9af09535b294c1ec135bb">◆ </a></span>deleteRecords() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1DeleteRecordsResponse">DeleteRecordsResponse</a> & gpudb::GPUdb::deleteRecords </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1DeleteRecordsRequest">DeleteRecordsRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1DeleteRecordsResponse">DeleteRecordsResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Deletes record(s) matching the provided criteria from the given table. </p>
        <p>The record selection criteria can either be one or more <a href="/content/api/cpp/structgpudb_1_1DeleteRecordsRequest#a337a4aedda81f8ff2ceb4080cde1ea07">expressions</a> (matching multiple records), a single record identified by <a href="/content/api/cpp/namespacegpudb#ad42fcb5679c9c0432a46547e529eef7b">record\_id</a> options, or all records when using <a href="/content/api/cpp/namespacegpudb#a038cecdc7ab035a6642a3790f9ffa1a6">delete\_all\_records</a>. Note that the three selection criteria are mutually exclusive. This operation cannot be run on a view. The operation is synchronous meaning that a response will not be available until the request is completely processed and all the matching records are deleted.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1DeleteRecordsRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1DeleteRecordsResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1DeleteRecordsResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a8f916f1513778ef51cfb294659f452ae">◆ </a></span>deleteRecords() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1DeleteRecordsResponse">DeleteRecordsResponse</a> gpudb::GPUdb::deleteRecords </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< std::string > &</td>
            <td><span><span>expressions</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Deletes record(s) matching the provided criteria from the given table. </p>
        <p>The record selection criteria can either be one or more <span>expressions</span> (matching multiple records), a single record identified by <a href="/content/api/cpp/namespacegpudb#ad42fcb5679c9c0432a46547e529eef7b">record\_id</a> options, or all records when using <a href="/content/api/cpp/namespacegpudb#a038cecdc7ab035a6642a3790f9ffa1a6">delete\_all\_records</a>. Note that the three selection criteria are mutually exclusive. This operation cannot be run on a view. The operation is synchronous meaning that a response will not be available until the request is completely processed and all the matching records are deleted.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of the table from which to delete records, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. Must contain the name of an existing table; not applicable to views. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>expressions</td>
                <td>A list of the actual predicates, one for each select; format should follow the guidelines provided <a href="/content/concepts/expressions/">here</a>. Specifying one or more <span>expressions</span> is mutually exclusive to specifying <a href="/content/api/cpp/namespacegpudb#ad42fcb5679c9c0432a46547e529eef7b">record\_id</a> in the <span>options</span>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a3cb9ea12e7c065a082118bbe7bdf07b3">delete\_records\_global\_expression</a>: An optional global expression to reduce the search space of the <span>expressions</span>. The default value is ''. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ad42fcb5679c9c0432a46547e529eef7b">delete\_records\_record\_id</a>: A record ID identifying a single record, obtained at the time of <a href="#a1cbbfefa7a3d6b4570f1be6734a8d849">insertion of the record</a> or by calling <a href="#ad07e8ca5da326049590fc62762c630a1">getRecordsFromCollection</a> with the <span>return\_record\_ids</span> option. This option cannot be used to delete records from <a href="/content/concepts/tables/#replication">replicated</a> tables. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a038cecdc7ab035a6642a3790f9ffa1a6">delete\_records\_delete\_all\_records</a>: If set to <a href="/content/api/cpp/namespacegpudb#a36d198ecdf41447d55b480f6cc34774e">true</a>, all records in the table will be deleted. If set to <a href="/content/api/cpp/namespacegpudb#aad2dc74761b7204b93fe896e7ae0f0fd">false</a>, then the option is effectively ignored. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a36d198ecdf41447d55b480f6cc34774e">delete\_records\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aad2dc74761b7204b93fe896e7ae0f0fd">delete\_records\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#aad2dc74761b7204b93fe896e7ae0f0fd">delete\_records\_false</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1DeleteRecordsResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a1ce474514d4e6ad6396ee5611d5dfebd">◆ </a></span>deleteRecords() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1DeleteRecordsResponse">DeleteRecordsResponse</a> & gpudb::GPUdb::deleteRecords </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< std::string > &</td>
            <td><span><span>expressions</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1DeleteRecordsResponse">DeleteRecordsResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Deletes record(s) matching the provided criteria from the given table. </p>
        <p>The record selection criteria can either be one or more <span>expressions</span> (matching multiple records), a single record identified by <a href="/content/api/cpp/namespacegpudb#ad42fcb5679c9c0432a46547e529eef7b">record\_id</a> options, or all records when using <a href="/content/api/cpp/namespacegpudb#a038cecdc7ab035a6642a3790f9ffa1a6">delete\_all\_records</a>. Note that the three selection criteria are mutually exclusive. This operation cannot be run on a view. The operation is synchronous meaning that a response will not be available until the request is completely processed and all the matching records are deleted.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of the table from which to delete records, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. Must contain the name of an existing table; not applicable to views. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>expressions</td>
                <td>A list of the actual predicates, one for each select; format should follow the guidelines provided <a href="/content/concepts/expressions/">here</a>. Specifying one or more <span>expressions</span> is mutually exclusive to specifying <a href="/content/api/cpp/namespacegpudb#ad42fcb5679c9c0432a46547e529eef7b">record\_id</a> in the <span>options</span>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a3cb9ea12e7c065a082118bbe7bdf07b3">delete\_records\_global\_expression</a>: An optional global expression to reduce the search space of the <span>expressions</span>. The default value is ''. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ad42fcb5679c9c0432a46547e529eef7b">delete\_records\_record\_id</a>: A record ID identifying a single record, obtained at the time of <a href="#a1cbbfefa7a3d6b4570f1be6734a8d849">insertion of the record</a> or by calling <a href="#ad07e8ca5da326049590fc62762c630a1">getRecordsFromCollection</a> with the <span>return\_record\_ids</span> option. This option cannot be used to delete records from <a href="/content/concepts/tables/#replication">replicated</a> tables. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a038cecdc7ab035a6642a3790f9ffa1a6">delete\_records\_delete\_all\_records</a>: If set to <a href="/content/api/cpp/namespacegpudb#a36d198ecdf41447d55b480f6cc34774e">true</a>, all records in the table will be deleted. If set to <a href="/content/api/cpp/namespacegpudb#aad2dc74761b7204b93fe896e7ae0f0fd">false</a>, then the option is effectively ignored. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a36d198ecdf41447d55b480f6cc34774e">delete\_records\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aad2dc74761b7204b93fe896e7ae0f0fd">delete\_records\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#aad2dc74761b7204b93fe896e7ae0f0fd">delete\_records\_false</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1DeleteRecordsResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1DeleteRecordsResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a983a125a43a75d06297c7267db1fd39f">◆ </a></span>deleteResourceGroup() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1DeleteResourceGroupResponse">DeleteResourceGroupResponse</a> gpudb::GPUdb::deleteResourceGroup </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1DeleteResourceGroupRequest">DeleteResourceGroupRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Deletes a resource group. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1DeleteResourceGroupRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1DeleteResourceGroupResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a220b0089ccf5bcec01b61474e9b191eb">◆ </a></span>deleteResourceGroup() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1DeleteResourceGroupResponse">DeleteResourceGroupResponse</a> & gpudb::GPUdb::deleteResourceGroup </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1DeleteResourceGroupRequest">DeleteResourceGroupRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1DeleteResourceGroupResponse">DeleteResourceGroupResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Deletes a resource group. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1DeleteResourceGroupRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1DeleteResourceGroupResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1DeleteResourceGroupResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#aef9d2564d591dcd37d7aa12868ecf89a">◆ </a></span>deleteResourceGroup() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1DeleteResourceGroupResponse">DeleteResourceGroupResponse</a> gpudb::GPUdb::deleteResourceGroup </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Deletes a resource group. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>name</td>
                <td>Name of the resource group to be deleted. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ad4f48ff4737fcef0e8061c381d08d2e3">delete\_resource\_group\_cascade\_delete</a>: If <a href="/content/api/cpp/namespacegpudb#ad7a8fc15c7616aee4a9e02ca19c4657a">true</a>, delete any existing entities owned by this group. Otherwise this request will return an error of any such entities exist. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad7a8fc15c7616aee4a9e02ca19c4657a">delete\_resource\_group\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aef159e28ee2efd5dd26c20fdc27fd8e8">delete\_resource\_group\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#aef159e28ee2efd5dd26c20fdc27fd8e8">delete\_resource\_group\_false</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1DeleteResourceGroupResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#afd36b5f318b6399040e89654dee50a9e">◆ </a></span>deleteResourceGroup() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1DeleteResourceGroupResponse">DeleteResourceGroupResponse</a> & gpudb::GPUdb::deleteResourceGroup </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1DeleteResourceGroupResponse">DeleteResourceGroupResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Deletes a resource group. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>name</td>
                <td>Name of the resource group to be deleted. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ad4f48ff4737fcef0e8061c381d08d2e3">delete\_resource\_group\_cascade\_delete</a>: If <a href="/content/api/cpp/namespacegpudb#ad7a8fc15c7616aee4a9e02ca19c4657a">true</a>, delete any existing entities owned by this group. Otherwise this request will return an error of any such entities exist. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad7a8fc15c7616aee4a9e02ca19c4657a">delete\_resource\_group\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aef159e28ee2efd5dd26c20fdc27fd8e8">delete\_resource\_group\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#aef159e28ee2efd5dd26c20fdc27fd8e8">delete\_resource\_group\_false</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1DeleteResourceGroupResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1DeleteResourceGroupResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#acb8c8e4ff462c0b9cc0e75bc362cf394">◆ </a></span>deleteRole() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1DeleteRoleResponse">DeleteRoleResponse</a> gpudb::GPUdb::deleteRole </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1DeleteRoleRequest">DeleteRoleRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Deletes an existing role. </p>

        <div>
          <div>Attention</div>
          <div>This method should be used for on-premise deployments only.</div>
        </div>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1DeleteRoleRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1DeleteRoleResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a3e39bf2702fb01b28029959a06a1b18f">◆ </a></span>deleteRole() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1DeleteRoleResponse">DeleteRoleResponse</a> & gpudb::GPUdb::deleteRole </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1DeleteRoleRequest">DeleteRoleRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1DeleteRoleResponse">DeleteRoleResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Deletes an existing role. </p>

        <div>
          <div>Attention</div>
          <div>This method should be used for on-premise deployments only.</div>
        </div>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1DeleteRoleRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1DeleteRoleResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1DeleteRoleResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a5c85e8fd1f97fc0d9a2f720665eea844">◆ </a></span>deleteRole() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1DeleteRoleResponse">DeleteRoleResponse</a> gpudb::GPUdb::deleteRole </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Deletes an existing role. </p>

        <div>
          <div>Attention</div>
          <div>This method should be used for on-premise deployments only.</div>
        </div>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>name</td>
                <td>Name of the role to be deleted. Must be an existing role. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1DeleteRoleResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a45c82198eabb33621afe2cb4b13b514b">◆ </a></span>deleteRole() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1DeleteRoleResponse">DeleteRoleResponse</a> & gpudb::GPUdb::deleteRole </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1DeleteRoleResponse">DeleteRoleResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Deletes an existing role. </p>

        <div>
          <div>Attention</div>
          <div>This method should be used for on-premise deployments only.</div>
        </div>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>name</td>
                <td>Name of the role to be deleted. Must be an existing role. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1DeleteRoleResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1DeleteRoleResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a977b2b3d77af5d89bede6fdfae47d65c">◆ </a></span>deleteUser() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1DeleteUserResponse">DeleteUserResponse</a> gpudb::GPUdb::deleteUser </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1DeleteUserRequest">DeleteUserRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Deletes an existing user. </p>

        <div>
          <div>Attention</div>
          <div>This method should be used for on-premise deployments only.</div>
        </div>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1DeleteUserRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1DeleteUserResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a27f5c15ec81e270fdcd98cd96935562a">◆ </a></span>deleteUser() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1DeleteUserResponse">DeleteUserResponse</a> & gpudb::GPUdb::deleteUser </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1DeleteUserRequest">DeleteUserRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1DeleteUserResponse">DeleteUserResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Deletes an existing user. </p>

        <div>
          <div>Attention</div>
          <div>This method should be used for on-premise deployments only.</div>
        </div>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1DeleteUserRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1DeleteUserResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1DeleteUserResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a28aafe4501af2b2641a3b902e3bcec31">◆ </a></span>deleteUser() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1DeleteUserResponse">DeleteUserResponse</a> gpudb::GPUdb::deleteUser </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Deletes an existing user. </p>

        <div>
          <div>Attention</div>
          <div>This method should be used for on-premise deployments only.</div>
        </div>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>name</td>
                <td>Name of the user to be deleted. Must be an existing user. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1DeleteUserResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a1ff04dbda4bae58ffb43ef23643c5d45">◆ </a></span>deleteUser() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1DeleteUserResponse">DeleteUserResponse</a> & gpudb::GPUdb::deleteUser </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1DeleteUserResponse">DeleteUserResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Deletes an existing user. </p>

        <div>
          <div>Attention</div>
          <div>This method should be used for on-premise deployments only.</div>
        </div>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>name</td>
                <td>Name of the user to be deleted. Must be an existing user. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1DeleteUserResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1DeleteUserResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a862c8a95bf7cf33f3b26e9237a57e139">◆ </a></span>downloadFiles() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1DownloadFilesResponse">DownloadFilesResponse</a> gpudb::GPUdb::downloadFiles </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1DownloadFilesRequest">DownloadFilesRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Downloads one or more files from <a href="/content/tools/kifs/">KiFS</a>. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1DownloadFilesRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1DownloadFilesResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a050ab03f2c3744e30373d501b6be605a">◆ </a></span>downloadFiles() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1DownloadFilesResponse">DownloadFilesResponse</a> & gpudb::GPUdb::downloadFiles </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1DownloadFilesRequest">DownloadFilesRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1DownloadFilesResponse">DownloadFilesResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Downloads one or more files from <a href="/content/tools/kifs/">KiFS</a>. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1DownloadFilesRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1DownloadFilesResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1DownloadFilesResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a9ca866bcfa55789da0ae6cacd9c38fa9">◆ </a></span>downloadFiles() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1DownloadFilesResponse">DownloadFilesResponse</a> gpudb::GPUdb::downloadFiles </td>
            <td>(</td>
            <td>const std::vector\< std::string > &</td>
            <td><span><span>fileNames</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< int64\_t > &</td>
            <td><span><span>readOffsets</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< int64\_t > &</td>
            <td><span><span>readLengths</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Downloads one or more files from <a href="/content/tools/kifs/">KiFS</a>. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>fileNames</td>
                <td>An array of the file names to download from KiFS. File paths may contain wildcard characters after the KiFS directory delimiter. Accepted wildcard characters are asterisk (\*) to represent any string of zero or more characters, and question mark (?) to indicate a single character. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>readOffsets</td>
                <td>An array of starting byte offsets from which to read each respective file in <span>fileNames</span>. Must either be empty or the same length as <span>fileNames</span>. If empty, files are downloaded in their entirety. If not empty, <span>readLengths</span> must also not be empty. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>readLengths</td>
                <td>Array of number of bytes to read from each respective file in <span>fileNames</span>. Must either be empty or the same length as <span>fileNames</span>. If empty, files are downloaded in their entirety. If not empty, <span>readOffsets</span> must also not be empty. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ae926208617f119486e700f567d3fb92e">download\_files\_file\_encoding</a>: Encoding to be applied to the output file data. When using JSON serialization it is recommended to specify this as <a href="/content/api/cpp/namespacegpudb#a088ee2c65e387365185601d1d760c80d">base64</a>. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a088ee2c65e387365185601d1d760c80d">download\_files\_base64</a>: Apply base64 encoding to the output file data. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aab04be20c44c701deb41c5c7829c6611">download\_files\_none</a>: Do not apply any encoding to the output file data. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#aab04be20c44c701deb41c5c7829c6611">download\_files\_none</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1DownloadFilesResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a12761bd43c23e964d5e5b1b2b2b4c529">◆ </a></span>downloadFiles() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1DownloadFilesResponse">DownloadFilesResponse</a> & gpudb::GPUdb::downloadFiles </td>
            <td>(</td>
            <td>const std::vector\< std::string > &</td>
            <td><span><span>fileNames</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< int64\_t > &</td>
            <td><span><span>readOffsets</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< int64\_t > &</td>
            <td><span><span>readLengths</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1DownloadFilesResponse">DownloadFilesResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Downloads one or more files from <a href="/content/tools/kifs/">KiFS</a>. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>fileNames</td>
                <td>An array of the file names to download from KiFS. File paths may contain wildcard characters after the KiFS directory delimiter. Accepted wildcard characters are asterisk (\*) to represent any string of zero or more characters, and question mark (?) to indicate a single character. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>readOffsets</td>
                <td>An array of starting byte offsets from which to read each respective file in <span>fileNames</span>. Must either be empty or the same length as <span>fileNames</span>. If empty, files are downloaded in their entirety. If not empty, <span>readLengths</span> must also not be empty. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>readLengths</td>
                <td>Array of number of bytes to read from each respective file in <span>fileNames</span>. Must either be empty or the same length as <span>fileNames</span>. If empty, files are downloaded in their entirety. If not empty, <span>readOffsets</span> must also not be empty. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ae926208617f119486e700f567d3fb92e">download\_files\_file\_encoding</a>: Encoding to be applied to the output file data. When using JSON serialization it is recommended to specify this as <a href="/content/api/cpp/namespacegpudb#a088ee2c65e387365185601d1d760c80d">base64</a>. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a088ee2c65e387365185601d1d760c80d">download\_files\_base64</a>: Apply base64 encoding to the output file data. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aab04be20c44c701deb41c5c7829c6611">download\_files\_none</a>: Do not apply any encoding to the output file data. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#aab04be20c44c701deb41c5c7829c6611">download\_files\_none</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1DownloadFilesResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1DownloadFilesResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#aa6f1b56740a5cc4a68fb18396971e2cb">◆ </a></span>dropBackup() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1DropBackupResponse">DropBackupResponse</a> gpudb::GPUdb::dropBackup </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1DropBackupRequest">DropBackupRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Deletes one or more existing database <a href="/content/admin/backup_restore/#database-backup">backups</a> and contained snapshots, accessible via the <a href="/content/concepts/data_sinks/">data sink</a> specified by <a href="/content/api/cpp/structgpudb_1_1DropBackupRequest#a4b5c92fb561b0e6d2a480f95cf678a6f">datasinkName</a>. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1DropBackupRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1DropBackupResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ade81d264162c890bc255e79fa367a368">◆ </a></span>dropBackup() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1DropBackupResponse">DropBackupResponse</a> & gpudb::GPUdb::dropBackup </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1DropBackupRequest">DropBackupRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1DropBackupResponse">DropBackupResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Deletes one or more existing database <a href="/content/admin/backup_restore/#database-backup">backups</a> and contained snapshots, accessible via the <a href="/content/concepts/data_sinks/">data sink</a> specified by <a href="/content/api/cpp/structgpudb_1_1DropBackupRequest#a4b5c92fb561b0e6d2a480f95cf678a6f">datasinkName</a>. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1DropBackupRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1DropBackupResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1DropBackupResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#abedce955754617f8bded614fe8ac3af9">◆ </a></span>dropBackup() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1DropBackupResponse">DropBackupResponse</a> gpudb::GPUdb::dropBackup </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>backupName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>datasinkName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Deletes one or more existing database <a href="/content/admin/backup_restore/#database-backup">backups</a> and contained snapshots, accessible via the <a href="/content/concepts/data_sinks/">data sink</a> specified by <span>datasinkName</span>. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>backupName</td>
                <td>Name of the backup to be deleted. An empty string or '<span>' will delete all existing backups. Any text followed by a '</span>' will delete backups whose name starts with that text. When deleting multiple backups, <a href="/content/api/cpp/namespacegpudb#a62edbf4aebeff008a12664411f1127db">delete\_all\_backups</a> must be set to <a href="/content/api/cpp/namespacegpudb#a434bbb668605b9bef45e0bb179e2ea39">true</a>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>datasinkName</td>
                <td>Data sink through which the backup is accessible. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a73109498dd431f5e85a083d0a69b18ec">drop\_backup\_dry\_run</a>: Whether or not to perform a dry run of a backup deletion. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a434bbb668605b9bef45e0bb179e2ea39">drop\_backup\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a6fbf54aeb57c2b3de5ce6d2e572725a1">drop\_backup\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a6fbf54aeb57c2b3de5ce6d2e572725a1">drop\_backup\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a62edbf4aebeff008a12664411f1127db">drop\_backup\_delete\_all\_backups</a>: Allow multiple backups to be deleted if <a href="/content/api/cpp/namespacegpudb#a434bbb668605b9bef45e0bb179e2ea39">true</a> and multiple backup names are found matching <span>backupName</span>. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a434bbb668605b9bef45e0bb179e2ea39">drop\_backup\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a6fbf54aeb57c2b3de5ce6d2e572725a1">drop\_backup\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a6fbf54aeb57c2b3de5ce6d2e572725a1">drop\_backup\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a855eb532c369e687541a8b142dff1e82">drop\_backup\_no\_error\_if\_not\_exists</a>: Whether or not to suppress the error if the specified backup does not exist. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a434bbb668605b9bef45e0bb179e2ea39">drop\_backup\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a6fbf54aeb57c2b3de5ce6d2e572725a1">drop\_backup\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a6fbf54aeb57c2b3de5ce6d2e572725a1">drop\_backup\_false</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1DropBackupResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a5a27fbd8c029c24986496744913025d4">◆ </a></span>dropBackup() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1DropBackupResponse">DropBackupResponse</a> & gpudb::GPUdb::dropBackup </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>backupName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>datasinkName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1DropBackupResponse">DropBackupResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Deletes one or more existing database <a href="/content/admin/backup_restore/#database-backup">backups</a> and contained snapshots, accessible via the <a href="/content/concepts/data_sinks/">data sink</a> specified by <span>datasinkName</span>. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>backupName</td>
                <td>Name of the backup to be deleted. An empty string or '<span>' will delete all existing backups. Any text followed by a '</span>' will delete backups whose name starts with that text. When deleting multiple backups, <a href="/content/api/cpp/namespacegpudb#a62edbf4aebeff008a12664411f1127db">delete\_all\_backups</a> must be set to <a href="/content/api/cpp/namespacegpudb#a434bbb668605b9bef45e0bb179e2ea39">true</a>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>datasinkName</td>
                <td>Data sink through which the backup is accessible. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a73109498dd431f5e85a083d0a69b18ec">drop\_backup\_dry\_run</a>: Whether or not to perform a dry run of a backup deletion. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a434bbb668605b9bef45e0bb179e2ea39">drop\_backup\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a6fbf54aeb57c2b3de5ce6d2e572725a1">drop\_backup\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a6fbf54aeb57c2b3de5ce6d2e572725a1">drop\_backup\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a62edbf4aebeff008a12664411f1127db">drop\_backup\_delete\_all\_backups</a>: Allow multiple backups to be deleted if <a href="/content/api/cpp/namespacegpudb#a434bbb668605b9bef45e0bb179e2ea39">true</a> and multiple backup names are found matching <span>backupName</span>. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a434bbb668605b9bef45e0bb179e2ea39">drop\_backup\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a6fbf54aeb57c2b3de5ce6d2e572725a1">drop\_backup\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a6fbf54aeb57c2b3de5ce6d2e572725a1">drop\_backup\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a855eb532c369e687541a8b142dff1e82">drop\_backup\_no\_error\_if\_not\_exists</a>: Whether or not to suppress the error if the specified backup does not exist. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a434bbb668605b9bef45e0bb179e2ea39">drop\_backup\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a6fbf54aeb57c2b3de5ce6d2e572725a1">drop\_backup\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a6fbf54aeb57c2b3de5ce6d2e572725a1">drop\_backup\_false</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1DropBackupResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1DropBackupResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a5938a9ec650a73ebb60a1112d6b2f1ad">◆ </a></span>dropCatalog() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1DropCatalogResponse">DropCatalogResponse</a> gpudb::GPUdb::dropCatalog </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1DropCatalogRequest">DropCatalogRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Drops an existing catalog. </p>
        <p>Any external tables that depend on the catalog must be dropped before it can be dropped.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1DropCatalogRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1DropCatalogResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ac26622d4790f14ee7470f092f4d8872c">◆ </a></span>dropCatalog() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1DropCatalogResponse">DropCatalogResponse</a> & gpudb::GPUdb::dropCatalog </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1DropCatalogRequest">DropCatalogRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1DropCatalogResponse">DropCatalogResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Drops an existing catalog. </p>
        <p>Any external tables that depend on the catalog must be dropped before it can be dropped.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1DropCatalogRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1DropCatalogResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1DropCatalogResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a6f12b30ee6107d9ec3827b365651e003">◆ </a></span>dropCatalog() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1DropCatalogResponse">DropCatalogResponse</a> gpudb::GPUdb::dropCatalog </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Drops an existing catalog. </p>
        <p>Any external tables that depend on the catalog must be dropped before it can be dropped.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>name</td>
                <td>Name of the catalog to be dropped. Must be an existing catalog. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1DropCatalogResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a414d23ccc2112bc4deca4ae5d5810e8f">◆ </a></span>dropCatalog() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1DropCatalogResponse">DropCatalogResponse</a> & gpudb::GPUdb::dropCatalog </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1DropCatalogResponse">DropCatalogResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Drops an existing catalog. </p>
        <p>Any external tables that depend on the catalog must be dropped before it can be dropped.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>name</td>
                <td>Name of the catalog to be dropped. Must be an existing catalog. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1DropCatalogResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1DropCatalogResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a556dd0d37ed777617e2817d296e1d642">◆ </a></span>dropCredential() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1DropCredentialResponse">DropCredentialResponse</a> gpudb::GPUdb::dropCredential </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1DropCredentialRequest">DropCredentialRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Drop an existing <a href="/content/concepts/credentials/">credential</a>. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1DropCredentialRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1DropCredentialResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#aa9b333fad3f81ec65ddb772a5a512b25">◆ </a></span>dropCredential() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1DropCredentialResponse">DropCredentialResponse</a> & gpudb::GPUdb::dropCredential </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1DropCredentialRequest">DropCredentialRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1DropCredentialResponse">DropCredentialResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Drop an existing <a href="/content/concepts/credentials/">credential</a>. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1DropCredentialRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1DropCredentialResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1DropCredentialResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a790500800a3b7f0e2e0504b9a1fbf99f">◆ </a></span>dropCredential() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1DropCredentialResponse">DropCredentialResponse</a> gpudb::GPUdb::dropCredential </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>credentialName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Drop an existing <a href="/content/concepts/credentials/">credential</a>. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>credentialName</td>
                <td>Name of the credential to be dropped. Must be an existing credential. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1DropCredentialResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#aebd9322f7ec6a2873592ced8b23b934b">◆ </a></span>dropCredential() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1DropCredentialResponse">DropCredentialResponse</a> & gpudb::GPUdb::dropCredential </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>credentialName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1DropCredentialResponse">DropCredentialResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Drop an existing <a href="/content/concepts/credentials/">credential</a>. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>credentialName</td>
                <td>Name of the credential to be dropped. Must be an existing credential. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1DropCredentialResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1DropCredentialResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ad3e43fa7e239c990fa449b0ad0e93d0e">◆ </a></span>dropDatasink() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1DropDatasinkResponse">DropDatasinkResponse</a> gpudb::GPUdb::dropDatasink </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1DropDatasinkRequest">DropDatasinkRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Drops an existing <a href="/content/concepts/data_sinks/">data sink</a>. </p>
        <p>By default, if any <a href="/content/concepts/table_monitors">table monitors</a> use this sink as a destination, the request will be blocked unless option <a href="/content/api/cpp/namespacegpudb#a006aaa5a6920d6d800c0b359acbc8186">clear\_table\_monitors</a> is <a href="/content/api/cpp/namespacegpudb#ab3796448d7c9c059f60333507efdb713">true</a>.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1DropDatasinkRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1DropDatasinkResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a5d3a3cafd0ff809135fcd05bb8d9db3d">◆ </a></span>dropDatasink() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1DropDatasinkResponse">DropDatasinkResponse</a> & gpudb::GPUdb::dropDatasink </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1DropDatasinkRequest">DropDatasinkRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1DropDatasinkResponse">DropDatasinkResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Drops an existing <a href="/content/concepts/data_sinks/">data sink</a>. </p>
        <p>By default, if any <a href="/content/concepts/table_monitors">table monitors</a> use this sink as a destination, the request will be blocked unless option <a href="/content/api/cpp/namespacegpudb#a006aaa5a6920d6d800c0b359acbc8186">clear\_table\_monitors</a> is <a href="/content/api/cpp/namespacegpudb#ab3796448d7c9c059f60333507efdb713">true</a>.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1DropDatasinkRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1DropDatasinkResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1DropDatasinkResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a7b33b61ed8cc32ae56f5e5009676c72a">◆ </a></span>dropDatasink() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1DropDatasinkResponse">DropDatasinkResponse</a> gpudb::GPUdb::dropDatasink </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Drops an existing <a href="/content/concepts/data_sinks/">data sink</a>. </p>
        <p>By default, if any <a href="/content/concepts/table_monitors">table monitors</a> use this sink as a destination, the request will be blocked unless option <a href="/content/api/cpp/namespacegpudb#a006aaa5a6920d6d800c0b359acbc8186">clear\_table\_monitors</a> is <a href="/content/api/cpp/namespacegpudb#ab3796448d7c9c059f60333507efdb713">true</a>.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>name</td>
                <td>Name of the data sink to be dropped. Must be an existing data sink. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a006aaa5a6920d6d800c0b359acbc8186">drop\_datasink\_clear\_table\_monitors</a>: If <a href="/content/api/cpp/namespacegpudb#ab3796448d7c9c059f60333507efdb713">true</a>, any <a href="/content/concepts/table_monitors/">table monitors</a> that use this data sink will be cleared. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ab3796448d7c9c059f60333507efdb713">drop\_datasink\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a56149c6b2cbeee7126252eea80d1eec1">drop\_datasink\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a56149c6b2cbeee7126252eea80d1eec1">drop\_datasink\_false</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1DropDatasinkResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a81c7c92ff33688011d71a74610bfb4c0">◆ </a></span>dropDatasink() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1DropDatasinkResponse">DropDatasinkResponse</a> & gpudb::GPUdb::dropDatasink </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1DropDatasinkResponse">DropDatasinkResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Drops an existing <a href="/content/concepts/data_sinks/">data sink</a>. </p>
        <p>By default, if any <a href="/content/concepts/table_monitors">table monitors</a> use this sink as a destination, the request will be blocked unless option <a href="/content/api/cpp/namespacegpudb#a006aaa5a6920d6d800c0b359acbc8186">clear\_table\_monitors</a> is <a href="/content/api/cpp/namespacegpudb#ab3796448d7c9c059f60333507efdb713">true</a>.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>name</td>
                <td>Name of the data sink to be dropped. Must be an existing data sink. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a006aaa5a6920d6d800c0b359acbc8186">drop\_datasink\_clear\_table\_monitors</a>: If <a href="/content/api/cpp/namespacegpudb#ab3796448d7c9c059f60333507efdb713">true</a>, any <a href="/content/concepts/table_monitors/">table monitors</a> that use this data sink will be cleared. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ab3796448d7c9c059f60333507efdb713">drop\_datasink\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a56149c6b2cbeee7126252eea80d1eec1">drop\_datasink\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a56149c6b2cbeee7126252eea80d1eec1">drop\_datasink\_false</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1DropDatasinkResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1DropDatasinkResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a70b16df3e8913595a9f93f37f1e3e27d">◆ </a></span>dropDatasource() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1DropDatasourceResponse">DropDatasourceResponse</a> gpudb::GPUdb::dropDatasource </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1DropDatasourceRequest">DropDatasourceRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Drops an existing <a href="/content/concepts/data_sources/">data source</a>. </p>
        <p>Any external tables that depend on the data source must be dropped before it can be dropped.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1DropDatasourceRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1DropDatasourceResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a73d6e07455d28d4d8b50713fbe9978d4">◆ </a></span>dropDatasource() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1DropDatasourceResponse">DropDatasourceResponse</a> & gpudb::GPUdb::dropDatasource </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1DropDatasourceRequest">DropDatasourceRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1DropDatasourceResponse">DropDatasourceResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Drops an existing <a href="/content/concepts/data_sources/">data source</a>. </p>
        <p>Any external tables that depend on the data source must be dropped before it can be dropped.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1DropDatasourceRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1DropDatasourceResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1DropDatasourceResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a7050dd9f8036e7f2e3f1adb7d7a933e6">◆ </a></span>dropDatasource() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1DropDatasourceResponse">DropDatasourceResponse</a> gpudb::GPUdb::dropDatasource </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Drops an existing <a href="/content/concepts/data_sources/">data source</a>. </p>
        <p>Any external tables that depend on the data source must be dropped before it can be dropped.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>name</td>
                <td>Name of the data source to be dropped. Must be an existing data source. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1DropDatasourceResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#acf576751dde2dc4e5109f8cc856a57e0">◆ </a></span>dropDatasource() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1DropDatasourceResponse">DropDatasourceResponse</a> & gpudb::GPUdb::dropDatasource </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1DropDatasourceResponse">DropDatasourceResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Drops an existing <a href="/content/concepts/data_sources/">data source</a>. </p>
        <p>Any external tables that depend on the data source must be dropped before it can be dropped.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>name</td>
                <td>Name of the data source to be dropped. Must be an existing data source. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1DropDatasourceResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1DropDatasourceResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a14b76ff4dd5ab041e2ccbda35bf3b023">◆ </a></span>dropEnvironment() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1DropEnvironmentResponse">DropEnvironmentResponse</a> gpudb::GPUdb::dropEnvironment </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1DropEnvironmentRequest">DropEnvironmentRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Drop an existing <a href="/content/concepts/udf/">user-defined function</a> (UDF) environment. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1DropEnvironmentRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1DropEnvironmentResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a0f80c4f0b898b5927f320959936a4c8a">◆ </a></span>dropEnvironment() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1DropEnvironmentResponse">DropEnvironmentResponse</a> & gpudb::GPUdb::dropEnvironment </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1DropEnvironmentRequest">DropEnvironmentRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1DropEnvironmentResponse">DropEnvironmentResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Drop an existing <a href="/content/concepts/udf/">user-defined function</a> (UDF) environment. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1DropEnvironmentRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1DropEnvironmentResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1DropEnvironmentResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a4f26b8f86f7ff4ca39a09c24fe641aa2">◆ </a></span>dropEnvironment() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1DropEnvironmentResponse">DropEnvironmentResponse</a> gpudb::GPUdb::dropEnvironment </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>environmentName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Drop an existing <a href="/content/concepts/udf/">user-defined function</a> (UDF) environment. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>environmentName</td>
                <td>Name of the environment to be dropped. Must be an existing environment. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a2521b71b6a75d3eaeb15cfce2000e5ce">drop\_environment\_no\_error\_if\_not\_exists</a>: If <a href="/content/api/cpp/namespacegpudb#affd49e2b4c60317582d7e59170529bc7">true</a> and if the environment specified in <span>environmentName</span> does not exist, no error is returned. If <a href="/content/api/cpp/namespacegpudb#a9fd7868a0d53f7b0bab5bd0ee09f1cfe">false</a> and if the environment specified in <span>environmentName</span> does not exist, then an error is returned. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#affd49e2b4c60317582d7e59170529bc7">drop\_environment\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a9fd7868a0d53f7b0bab5bd0ee09f1cfe">drop\_environment\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a9fd7868a0d53f7b0bab5bd0ee09f1cfe">drop\_environment\_false</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1DropEnvironmentResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ae8f2547ef7a85f8c361af0c5356a487a">◆ </a></span>dropEnvironment() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1DropEnvironmentResponse">DropEnvironmentResponse</a> & gpudb::GPUdb::dropEnvironment </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>environmentName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1DropEnvironmentResponse">DropEnvironmentResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Drop an existing <a href="/content/concepts/udf/">user-defined function</a> (UDF) environment. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>environmentName</td>
                <td>Name of the environment to be dropped. Must be an existing environment. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a2521b71b6a75d3eaeb15cfce2000e5ce">drop\_environment\_no\_error\_if\_not\_exists</a>: If <a href="/content/api/cpp/namespacegpudb#affd49e2b4c60317582d7e59170529bc7">true</a> and if the environment specified in <span>environmentName</span> does not exist, no error is returned. If <a href="/content/api/cpp/namespacegpudb#a9fd7868a0d53f7b0bab5bd0ee09f1cfe">false</a> and if the environment specified in <span>environmentName</span> does not exist, then an error is returned. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#affd49e2b4c60317582d7e59170529bc7">drop\_environment\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a9fd7868a0d53f7b0bab5bd0ee09f1cfe">drop\_environment\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a9fd7868a0d53f7b0bab5bd0ee09f1cfe">drop\_environment\_false</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1DropEnvironmentResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1DropEnvironmentResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ac647bfdc553a47cc69938b7b174dc499">◆ </a></span>dropSchema() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1DropSchemaResponse">DropSchemaResponse</a> gpudb::GPUdb::dropSchema </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1DropSchemaRequest">DropSchemaRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Drops an existing SQL-style <a href="/content/concepts/schemas/">schema</a>, specified in <a href="/content/api/cpp/structgpudb_1_1DropSchemaRequest#a4ef1f491b078fbb00d81ac38593cb57d">schemaName</a>. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1DropSchemaRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1DropSchemaResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a87cbc225b0173798cdbc758079902d98">◆ </a></span>dropSchema() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1DropSchemaResponse">DropSchemaResponse</a> & gpudb::GPUdb::dropSchema </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1DropSchemaRequest">DropSchemaRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1DropSchemaResponse">DropSchemaResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Drops an existing SQL-style <a href="/content/concepts/schemas/">schema</a>, specified in <a href="/content/api/cpp/structgpudb_1_1DropSchemaRequest#a4ef1f491b078fbb00d81ac38593cb57d">schemaName</a>. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1DropSchemaRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1DropSchemaResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1DropSchemaResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a7e22b839836772439bc1acb7215ce084">◆ </a></span>dropSchema() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1DropSchemaResponse">DropSchemaResponse</a> gpudb::GPUdb::dropSchema </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>schemaName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Drops an existing SQL-style <a href="/content/concepts/schemas/">schema</a>, specified in <span>schemaName</span>. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>schemaName</td>
                <td>Name of the schema to be dropped. Must be an existing schema. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#adf5956fd1c22b2e02e460e8e3421f581">drop\_schema\_no\_error\_if\_not\_exists</a>: If <a href="/content/api/cpp/namespacegpudb#afa987d236635a0c5321df7de731f9220">true</a> and if the schema specified in <span>schemaName</span> does not exist, no error is returned. If <a href="/content/api/cpp/namespacegpudb#a107e693285fdcd598dbc2fd9b82d2795">false</a> and if the schema specified in <span>schemaName</span> does not exist, then an error is returned. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#afa987d236635a0c5321df7de731f9220">drop\_schema\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a107e693285fdcd598dbc2fd9b82d2795">drop\_schema\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a107e693285fdcd598dbc2fd9b82d2795">drop\_schema\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a83a9dde3ae0852098ace8df2f28cd728">drop\_schema\_cascade</a>: If <a href="/content/api/cpp/namespacegpudb#afa987d236635a0c5321df7de731f9220">true</a>, all tables within the schema will be dropped. If <a href="/content/api/cpp/namespacegpudb#a107e693285fdcd598dbc2fd9b82d2795">false</a>, the schema will be dropped only if empty. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#afa987d236635a0c5321df7de731f9220">drop\_schema\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a107e693285fdcd598dbc2fd9b82d2795">drop\_schema\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a107e693285fdcd598dbc2fd9b82d2795">drop\_schema\_false</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1DropSchemaResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#aa3247798804eafcb3954e99f32a2b706">◆ </a></span>dropSchema() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1DropSchemaResponse">DropSchemaResponse</a> & gpudb::GPUdb::dropSchema </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>schemaName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1DropSchemaResponse">DropSchemaResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Drops an existing SQL-style <a href="/content/concepts/schemas/">schema</a>, specified in <span>schemaName</span>. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>schemaName</td>
                <td>Name of the schema to be dropped. Must be an existing schema. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#adf5956fd1c22b2e02e460e8e3421f581">drop\_schema\_no\_error\_if\_not\_exists</a>: If <a href="/content/api/cpp/namespacegpudb#afa987d236635a0c5321df7de731f9220">true</a> and if the schema specified in <span>schemaName</span> does not exist, no error is returned. If <a href="/content/api/cpp/namespacegpudb#a107e693285fdcd598dbc2fd9b82d2795">false</a> and if the schema specified in <span>schemaName</span> does not exist, then an error is returned. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#afa987d236635a0c5321df7de731f9220">drop\_schema\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a107e693285fdcd598dbc2fd9b82d2795">drop\_schema\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a107e693285fdcd598dbc2fd9b82d2795">drop\_schema\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a83a9dde3ae0852098ace8df2f28cd728">drop\_schema\_cascade</a>: If <a href="/content/api/cpp/namespacegpudb#afa987d236635a0c5321df7de731f9220">true</a>, all tables within the schema will be dropped. If <a href="/content/api/cpp/namespacegpudb#a107e693285fdcd598dbc2fd9b82d2795">false</a>, the schema will be dropped only if empty. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#afa987d236635a0c5321df7de731f9220">drop\_schema\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a107e693285fdcd598dbc2fd9b82d2795">drop\_schema\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a107e693285fdcd598dbc2fd9b82d2795">drop\_schema\_false</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1DropSchemaResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1DropSchemaResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a961a30f3d43a87a41a07457207f8ff76">◆ </a></span>execute() <span>\[1/5]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>long gpudb::GPUdb::execute </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>sql</span></span></td>
            <td>)</td>

            <td />
          </tr>
        </table>
      </div>

      <div>
        <p>This method is used to execute a SQL statement (e.g., DML, DDL). </p>
        <p>It returns the number of rows affected by the statement.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>sql</td>
                <td>- The SQL query to execute</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div>- number of rows affected by the execution of statement </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a7042004951231af914a4abc3b0035beb">◆ </a></span>execute() <span>\[2/5]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>long gpudb::GPUdb::execute </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>sql</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>parameters</span></span> )</td>
          </tr>
        </table>
      </div>

      <div>
        <p>This method is used to execute a SQL statement (e.g., DML, DDL). </p>
        <p>It returns the number of rows affected by the statement.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>sql</td>
                <td>- The SQL query to execute </td>
              </tr>

              <tr>
                <td>parameters</td>
                <td>- Query parameters for the SQL query. Can be empty.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div>- number of rows affected by the execution of statement </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#af70fe59fbeb702506f92ea8c60f030f4">◆ </a></span>execute() <span>\[3/5]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>long gpudb::GPUdb::execute </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>sql</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>parameters</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> )</td>
          </tr>
        </table>
      </div>

      <div>
        <p>This method is used to execute a SQL statement (e.g., DML, DDL). </p>
        <p>It returns the number of rows affected by the statement.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>sql</td>
                <td>- The SQL query to execute </td>
              </tr>

              <tr>
                <td>parameters</td>
                <td>- Query parameters for the SQL query. Can be empty. </td>
              </tr>

              <tr>
                <td>options</td>
                <td>- Optional parameters for the execute call.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div>- number of rows affected by the execution of statement </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a4b4c16fda3705614a5ea037dff06c7eb">◆ </a></span>execute() <span>\[4/5]</span></h2>

    <div>
      <div>
        <div> template\<typename T> </div>

        <table>
          <tr>
            <td>long gpudb::GPUdb::execute </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>sql</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< T > &</td>
            <td><span><span>parameters</span></span> )</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#a02bfe576a873f7e8d8d9cacc5dae9da0">◆ </a></span>execute() <span>\[5/5]</span></h2>

    <div>
      <div>
        <div> template\<typename T> </div>

        <table>
          <tr>
            <td>long gpudb::GPUdb::execute </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>sql</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< T > &</td>
            <td><span><span>parameters</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> )</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#aec2cf18c6185bf22d4fa351019b9924e">◆ </a></span>executeProc() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ExecuteProcResponse">ExecuteProcResponse</a> gpudb::GPUdb::executeProc </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1ExecuteProcRequest">ExecuteProcRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Executes a proc. </p>
        <p>This endpoint is asynchronous and does not wait for the proc to complete before returning.</p>
        <p>If the proc being executed is distributed, <a href="/content/api/cpp/structgpudb_1_1ExecuteProcRequest#a25c972ab3d77a44d9fb6351f421f2ddf">inputTableNames</a> and <a href="/content/api/cpp/structgpudb_1_1ExecuteProcRequest#a6aa3d53ecdf763b74bf7156977dbd9e2">inputColumnNames</a> may be passed to the proc to use for reading data, and <a href="/content/api/cpp/structgpudb_1_1ExecuteProcRequest#a35ea220760e3f98e614f82775f3188c9">outputTableNames</a> may be passed to the proc to use for writing data.</p>
        <p>If the proc being executed is non-distributed, these table parameters will be ignored.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ExecuteProcRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ExecuteProcResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a2a61a65eada999d993bcb1bae69656ee">◆ </a></span>executeProc() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ExecuteProcResponse">ExecuteProcResponse</a> & gpudb::GPUdb::executeProc </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1ExecuteProcRequest">ExecuteProcRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1ExecuteProcResponse">ExecuteProcResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Executes a proc. </p>
        <p>This endpoint is asynchronous and does not wait for the proc to complete before returning.</p>
        <p>If the proc being executed is distributed, <a href="/content/api/cpp/structgpudb_1_1ExecuteProcRequest#a25c972ab3d77a44d9fb6351f421f2ddf">inputTableNames</a> and <a href="/content/api/cpp/structgpudb_1_1ExecuteProcRequest#a6aa3d53ecdf763b74bf7156977dbd9e2">inputColumnNames</a> may be passed to the proc to use for reading data, and <a href="/content/api/cpp/structgpudb_1_1ExecuteProcRequest#a35ea220760e3f98e614f82775f3188c9">outputTableNames</a> may be passed to the proc to use for writing data.</p>
        <p>If the proc being executed is non-distributed, these table parameters will be ignored.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ExecuteProcRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ExecuteProcResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ExecuteProcResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a19f569cb61a53022021bbfd9e031468d">◆ </a></span>executeProc() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ExecuteProcResponse">ExecuteProcResponse</a> gpudb::GPUdb::executeProc </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>procName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>params</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::vector\< uint8\_t > > &</td>
            <td><span><span>binParams</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< std::string > &</td>
            <td><span><span>inputTableNames</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::vector\< std::string > > &</td>
            <td><span><span>inputColumnNames</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< std::string > &</td>
            <td><span><span>outputTableNames</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Executes a proc. </p>
        <p>This endpoint is asynchronous and does not wait for the proc to complete before returning.</p>
        <p>If the proc being executed is distributed, <span>inputTableNames</span> and <span>inputColumnNames</span> may be passed to the proc to use for reading data, and <span>outputTableNames</span> may be passed to the proc to use for writing data.</p>
        <p>If the proc being executed is non-distributed, these table parameters will be ignored.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>procName</td>
                <td>Name of the proc to execute. Must be the name of a currently existing proc. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>params</td>
                <td>A map containing named parameters to pass to the proc. Each key/value pair specifies the name of a parameter and its value. The default value is an empty map. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>binParams</td>
                <td>A map containing named binary parameters to pass to the proc. Each key/value pair specifies the name of a parameter and its value. The default value is an empty map. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>inputTableNames</td>
                <td>Names of the tables containing data to be passed to the proc. Each name specified must be the name of a currently existing table, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. If no table names are specified, no data will be passed to the proc. This parameter is ignored if the proc has a non-distributed execution mode. The default value is an empty vector. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>inputColumnNames</td>
                <td>Map of table names from <span>inputTableNames</span> to lists of names of columns from those tables that will be passed to the proc. Each column name specified must be the name of an existing column in the corresponding table. If a table name from <span>inputTableNames</span> is not included, all columns from that table will be passed to the proc. This parameter is ignored if the proc has a non-distributed execution mode. The default value is an empty map. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>outputTableNames</td>
                <td>Names of the tables to which output data from the proc will be written, each in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a> and meeting <a href="/content/concepts/tables/#table-naming-criteria">table naming criteria</a>. If a specified table does not exist, it will automatically be created with the same schema as the corresponding table (by order) from <span>inputTableNames</span>, excluding any primary and shard keys. If a specified table is a non-persistent result table, it must not have primary or shard keys. If no table names are specified, no output data can be returned from the proc. This parameter is ignored if the proc has a non-distributed execution mode. The default value is an empty vector. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#aba9eb12afe1503933120b7bf64a7e346">execute\_proc\_cache\_input</a>: No longer supported; option will be ignored. The default value is ''. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ad7211ebc76981c8c72d786d0fd2643dd">execute\_proc\_use\_cached\_input</a>: No longer supported; option will be ignored. The default value is ''. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#acf184a4291134ee67002d73c05e2d52a">execute\_proc\_run\_tag</a>: A string that, if not empty, can be used in subsequent calls to <a href="#a13497a80667b878cad9e5e6db04092d9">showProcStatus</a> or <a href="#a8272ee33e4bfe2ef6c5d225a7f151ada">killProc</a> to identify the proc instance. The default value is ''. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a696f20b78bdb37031a10510c6b99ed1a">execute\_proc\_max\_output\_lines</a>: The maximum number of lines of output from stdout and stderr to return via <a href="#a13497a80667b878cad9e5e6db04092d9">showProcStatus</a>. If the number of lines output exceeds the maximum, earlier lines are discarded. The default value is '100'. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#af73f384cadee446e2a1d258d74bb83bd">execute\_proc\_execute\_at\_startup</a>: If <a href="/content/api/cpp/namespacegpudb#a4da8f3f4e4c507d4ba6bf1d496959b32">true</a>, an instance of the proc will run when the database is started instead of running immediately. The <a href="/content/api/cpp/structgpudb_1_1ExecuteProcResponse#a8b7bda3af69d5ce923ea4d16dfe67e6c">runId</a> can be retrieved using <a href="#a4ff6de0d6b70a356a1995b973c9811dc">showProc</a> and used in <a href="#a13497a80667b878cad9e5e6db04092d9">showProcStatus</a>. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a4da8f3f4e4c507d4ba6bf1d496959b32">execute\_proc\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a492752231307347ef507e4e0680fc967">execute\_proc\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a492752231307347ef507e4e0680fc967">execute\_proc\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#ada77f22449cbf9e230fbb1d250698e1e">execute\_proc\_execute\_at\_startup\_as</a>: Sets the alternate user name to execute this proc instance as when <a href="/content/api/cpp/namespacegpudb#af73f384cadee446e2a1d258d74bb83bd">execute\_at\_startup</a> is <a href="/content/api/cpp/namespacegpudb#a4da8f3f4e4c507d4ba6bf1d496959b32">true</a>. The default value is ''. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ExecuteProcResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a6755a1b383ff5e0fbfb163365bcfa7bc">◆ </a></span>executeProc() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ExecuteProcResponse">ExecuteProcResponse</a> & gpudb::GPUdb::executeProc </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>procName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>params</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::vector\< uint8\_t > > &</td>
            <td><span><span>binParams</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< std::string > &</td>
            <td><span><span>inputTableNames</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::vector\< std::string > > &</td>
            <td><span><span>inputColumnNames</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< std::string > &</td>
            <td><span><span>outputTableNames</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1ExecuteProcResponse">ExecuteProcResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Executes a proc. </p>
        <p>This endpoint is asynchronous and does not wait for the proc to complete before returning.</p>
        <p>If the proc being executed is distributed, <span>inputTableNames</span> and <span>inputColumnNames</span> may be passed to the proc to use for reading data, and <span>outputTableNames</span> may be passed to the proc to use for writing data.</p>
        <p>If the proc being executed is non-distributed, these table parameters will be ignored.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>procName</td>
                <td>Name of the proc to execute. Must be the name of a currently existing proc. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>params</td>
                <td>A map containing named parameters to pass to the proc. Each key/value pair specifies the name of a parameter and its value. The default value is an empty map. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>binParams</td>
                <td>A map containing named binary parameters to pass to the proc. Each key/value pair specifies the name of a parameter and its value. The default value is an empty map. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>inputTableNames</td>
                <td>Names of the tables containing data to be passed to the proc. Each name specified must be the name of a currently existing table, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. If no table names are specified, no data will be passed to the proc. This parameter is ignored if the proc has a non-distributed execution mode. The default value is an empty vector. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>inputColumnNames</td>
                <td>Map of table names from <span>inputTableNames</span> to lists of names of columns from those tables that will be passed to the proc. Each column name specified must be the name of an existing column in the corresponding table. If a table name from <span>inputTableNames</span> is not included, all columns from that table will be passed to the proc. This parameter is ignored if the proc has a non-distributed execution mode. The default value is an empty map. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>outputTableNames</td>
                <td>Names of the tables to which output data from the proc will be written, each in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a> and meeting <a href="/content/concepts/tables/#table-naming-criteria">table naming criteria</a>. If a specified table does not exist, it will automatically be created with the same schema as the corresponding table (by order) from <span>inputTableNames</span>, excluding any primary and shard keys. If a specified table is a non-persistent result table, it must not have primary or shard keys. If no table names are specified, no output data can be returned from the proc. This parameter is ignored if the proc has a non-distributed execution mode. The default value is an empty vector. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#aba9eb12afe1503933120b7bf64a7e346">execute\_proc\_cache\_input</a>: No longer supported; option will be ignored. The default value is ''. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ad7211ebc76981c8c72d786d0fd2643dd">execute\_proc\_use\_cached\_input</a>: No longer supported; option will be ignored. The default value is ''. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#acf184a4291134ee67002d73c05e2d52a">execute\_proc\_run\_tag</a>: A string that, if not empty, can be used in subsequent calls to <a href="#a13497a80667b878cad9e5e6db04092d9">showProcStatus</a> or <a href="#a8272ee33e4bfe2ef6c5d225a7f151ada">killProc</a> to identify the proc instance. The default value is ''. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a696f20b78bdb37031a10510c6b99ed1a">execute\_proc\_max\_output\_lines</a>: The maximum number of lines of output from stdout and stderr to return via <a href="#a13497a80667b878cad9e5e6db04092d9">showProcStatus</a>. If the number of lines output exceeds the maximum, earlier lines are discarded. The default value is '100'. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#af73f384cadee446e2a1d258d74bb83bd">execute\_proc\_execute\_at\_startup</a>: If <a href="/content/api/cpp/namespacegpudb#a4da8f3f4e4c507d4ba6bf1d496959b32">true</a>, an instance of the proc will run when the database is started instead of running immediately. The <a href="/content/api/cpp/structgpudb_1_1ExecuteProcResponse#a8b7bda3af69d5ce923ea4d16dfe67e6c">runId</a> can be retrieved using <a href="#a4ff6de0d6b70a356a1995b973c9811dc">showProc</a> and used in <a href="#a13497a80667b878cad9e5e6db04092d9">showProcStatus</a>. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a4da8f3f4e4c507d4ba6bf1d496959b32">execute\_proc\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a492752231307347ef507e4e0680fc967">execute\_proc\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a492752231307347ef507e4e0680fc967">execute\_proc\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#ada77f22449cbf9e230fbb1d250698e1e">execute\_proc\_execute\_at\_startup\_as</a>: Sets the alternate user name to execute this proc instance as when <a href="/content/api/cpp/namespacegpudb#af73f384cadee446e2a1d258d74bb83bd">execute\_at\_startup</a> is <a href="/content/api/cpp/namespacegpudb#a4da8f3f4e4c507d4ba6bf1d496959b32">true</a>. The default value is ''. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ExecuteProcResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ExecuteProcResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a6b771232d18e050420781df48d656cf1">◆ </a></span>executeSql() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ExecuteSqlResponse">ExecuteSqlResponse</a> gpudb::GPUdb::executeSql </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1ExecuteSqlRequest">ExecuteSqlRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Execute a SQL statement (query, DML, or DDL). </p>
        <p>See <a href="/content/sql/">SQL Support</a> for the complete set of supported SQL commands.</p>
        <p>When a caller wants all the results from a large query (e.g., more than <a href="/content/config/#config-main-general">max\_get\_records\_size</a> records), they can make multiple calls to this endpoint using the <a href="/content/api/cpp/structgpudb_1_1ExecuteSqlRequest#a8028935e70224cefd72f7fa79b0ef7de">offset</a> and <a href="/content/api/cpp/structgpudb_1_1ExecuteSqlRequest#a3613f778b8f80448019e49f740ef09af">limit</a> parameters to page through the results. Normally, this will execute the <a href="/content/api/cpp/structgpudb_1_1ExecuteSqlRequest#ad8b660473874fb465d1c69677edc191c">statement</a> query each time. To avoid re-executing the query each time and to keep the results in the same order, the caller should specify a <a href="/content/api/cpp/namespacegpudb#a1cf02bf6e63569a04fd02f393fc3d8a5">paging\_table</a> name to hold the results of the query between calls and specify the <a href="/content/api/cpp/namespacegpudb#a1cf02bf6e63569a04fd02f393fc3d8a5">paging\_table</a> on subsequent calls. When this is done, the caller should clear the paging table and any other tables in the <a href="/content/api/cpp/namespacegpudb#a25ba4b49d3155936653a0dd22d27ff18">result\_table\_list</a> (both returned in the response) when they are done paging through the results. <a href="/content/api/cpp/structgpudb_1_1RawExecuteSqlResponse#a7513cc3b1e3c45335088094e006cdd32">pagingTable</a> (and <a href="/content/api/cpp/namespacegpudb#a25ba4b49d3155936653a0dd22d27ff18">result\_table\_list</a>) will be empty if no paging table was created (e.g., when all the query results were returned in the first call).</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ExecuteSqlRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ExecuteSqlResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a45e5aeffa656d78105e9138e03fac841">◆ </a></span>executeSql() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ExecuteSqlResponse">ExecuteSqlResponse</a> & gpudb::GPUdb::executeSql </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1ExecuteSqlRequest">ExecuteSqlRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1ExecuteSqlResponse">ExecuteSqlResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Execute a SQL statement (query, DML, or DDL). </p>
        <p>See <a href="/content/sql/">SQL Support</a> for the complete set of supported SQL commands.</p>
        <p>When a caller wants all the results from a large query (e.g., more than <a href="/content/config/#config-main-general">max\_get\_records\_size</a> records), they can make multiple calls to this endpoint using the <a href="/content/api/cpp/structgpudb_1_1ExecuteSqlRequest#a8028935e70224cefd72f7fa79b0ef7de">offset</a> and <a href="/content/api/cpp/structgpudb_1_1ExecuteSqlRequest#a3613f778b8f80448019e49f740ef09af">limit</a> parameters to page through the results. Normally, this will execute the <a href="/content/api/cpp/structgpudb_1_1ExecuteSqlRequest#ad8b660473874fb465d1c69677edc191c">statement</a> query each time. To avoid re-executing the query each time and to keep the results in the same order, the caller should specify a <a href="/content/api/cpp/namespacegpudb#a1cf02bf6e63569a04fd02f393fc3d8a5">paging\_table</a> name to hold the results of the query between calls and specify the <a href="/content/api/cpp/namespacegpudb#a1cf02bf6e63569a04fd02f393fc3d8a5">paging\_table</a> on subsequent calls. When this is done, the caller should clear the paging table and any other tables in the <a href="/content/api/cpp/namespacegpudb#a25ba4b49d3155936653a0dd22d27ff18">result\_table\_list</a> (both returned in the response) when they are done paging through the results. <a href="/content/api/cpp/structgpudb_1_1RawExecuteSqlResponse#a7513cc3b1e3c45335088094e006cdd32">pagingTable</a> (and <a href="/content/api/cpp/namespacegpudb#a25ba4b49d3155936653a0dd22d27ff18">result\_table\_list</a>) will be empty if no paging table was created (e.g., when all the query results were returned in the first call).</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ExecuteSqlRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ExecuteSqlResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ExecuteSqlResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a3aa7bd7abb665f7371b9a23f587c6134">◆ </a></span>executeSql() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ExecuteSqlResponse">ExecuteSqlResponse</a> gpudb::GPUdb::executeSql </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>statement</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const int64\_t</td>
            <td><span><span>offset</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const int64\_t</td>
            <td><span><span>limit</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>requestSchemaStr</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< std::vector\< uint8\_t > > &</td>
            <td><span><span>data</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Execute a SQL statement (query, DML, or DDL). </p>
        <p>See <a href="/content/sql/">SQL Support</a> for the complete set of supported SQL commands.</p>
        <p>When a caller wants all the results from a large query (e.g., more than <a href="/content/config/#config-main-general">max\_get\_records\_size</a> records), they can make multiple calls to this endpoint using the <span>offset</span> and <span>limit</span> parameters to page through the results. Normally, this will execute the <span>statement</span> query each time. To avoid re-executing the query each time and to keep the results in the same order, the caller should specify a <a href="/content/api/cpp/namespacegpudb#a1cf02bf6e63569a04fd02f393fc3d8a5">paging\_table</a> name to hold the results of the query between calls and specify the <a href="/content/api/cpp/namespacegpudb#a1cf02bf6e63569a04fd02f393fc3d8a5">paging\_table</a> on subsequent calls. When this is done, the caller should clear the paging table and any other tables in the <a href="/content/api/cpp/namespacegpudb#a25ba4b49d3155936653a0dd22d27ff18">result\_table\_list</a> (both returned in the response) when they are done paging through the results. <a href="/content/api/cpp/structgpudb_1_1RawExecuteSqlResponse#a7513cc3b1e3c45335088094e006cdd32">pagingTable</a> (and <a href="/content/api/cpp/namespacegpudb#a25ba4b49d3155936653a0dd22d27ff18">result\_table\_list</a>) will be empty if no paging table was created (e.g., when all the query results were returned in the first call).</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>statement</td>
                <td>SQL statement (query, DML, or DDL) to be executed. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>offset</td>
                <td>A positive integer indicating the number of initial results to skip (this can be useful for paging through the results). The default value is 0. The minimum allowed value is 0. The maximum allowed value is MAX\_INT. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>limit</td>
                <td>A positive integer indicating the maximum number of results to be returned, or END\_OF\_SET (-9999) to indicate that the maximum number of results allowed by the server should be returned. The number of records returned will never exceed the server's own limit, defined by the <a href="/content/config/#config-main-general">max\_get\_records\_size</a> parameter in the server configuration. Use <a href="/content/api/cpp/structgpudb_1_1RawExecuteSqlResponse#aa80498dd443e17627061c1a168f6beb5">hasMoreRecords</a> to see if more records exist in the result to be fetched, and <span>offset</span> and <span>limit</span> to request subsequent pages of results. The default value is -9999. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>requestSchemaStr</td>
                <td>Avro schema of <span>data</span>. The default value is ''. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>data</td>
                <td>An array of binary-encoded data for the records to be binded to the SQL query. Or use <a href="/content/api/cpp/namespacegpudb#a6cebddfde5e6b4eae23d7439481cc964">query\_parameters</a> to pass the data in JSON format. The default value is an empty vector. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#add12bc9ed427fb67fa019456bad0362e">execute\_sql\_cost\_based\_optimization</a>: If <a href="/content/api/cpp/namespacegpudb#a56694eafed65a54cf067f2cc44df1017">false</a>, disables the cost-based optimization of the given query. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad0528036a98d995c38e3c55b0cd52d08">execute\_sql\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a56694eafed65a54cf067f2cc44df1017">execute\_sql\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a56694eafed65a54cf067f2cc44df1017">execute\_sql\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ac8b94984d1229e7f667e62ab8fd8ad71">execute\_sql\_distributed\_joins</a>: If <a href="/content/api/cpp/namespacegpudb#ad0528036a98d995c38e3c55b0cd52d08">true</a>, enables the use of distributed joins in servicing the given query. Any query requiring a distributed join will succeed, though hints can be used in the query to change the distribution of the source data to allow the query to succeed. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad0528036a98d995c38e3c55b0cd52d08">execute\_sql\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a56694eafed65a54cf067f2cc44df1017">execute\_sql\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a56694eafed65a54cf067f2cc44df1017">execute\_sql\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a686c3e25bee2b4412d027033e38c81f4">execute\_sql\_distributed\_operations</a>: If <a href="/content/api/cpp/namespacegpudb#ad0528036a98d995c38e3c55b0cd52d08">true</a>, enables the use of distributed operations in servicing the given query. Any query requiring a distributed join will succeed, though hints can be used in the query to change the distribution of the source data to allow the query to succeed. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad0528036a98d995c38e3c55b0cd52d08">execute\_sql\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a56694eafed65a54cf067f2cc44df1017">execute\_sql\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a56694eafed65a54cf067f2cc44df1017">execute\_sql\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ad6546877f9753c4114969b2d94f8dd9a">execute\_sql\_ignore\_existing\_pk</a>: Specifies the record collision error-suppression policy for inserting into or updating a table with a <a href="/content/concepts/tables/#primary-keys">primary key</a>, only used when primary key record collisions are rejected (<a href="/content/api/cpp/namespacegpudb#a30c0b01a1047cb0225f07457e78ca64c">update\_on\_existing\_pk</a> is <a href="/content/api/cpp/namespacegpudb#a56694eafed65a54cf067f2cc44df1017">false</a>). If set to <a href="/content/api/cpp/namespacegpudb#ad0528036a98d995c38e3c55b0cd52d08">true</a>, any record insert/update that is rejected for resulting in a primary key collision with an existing table record will be ignored with no error generated. If <a href="/content/api/cpp/namespacegpudb#a56694eafed65a54cf067f2cc44df1017">false</a>, the rejection of any insert/update for resulting in a primary key collision will cause an error to be reported. If the specified table does not have a primary key or if <a href="/content/api/cpp/namespacegpudb#a30c0b01a1047cb0225f07457e78ca64c">update\_on\_existing\_pk</a> is <a href="/content/api/cpp/namespacegpudb#ad0528036a98d995c38e3c55b0cd52d08">true</a>, then this option has no effect. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad0528036a98d995c38e3c55b0cd52d08">execute\_sql\_true</a>: Ignore inserts/updates that result in primary key collisions with existing records. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a56694eafed65a54cf067f2cc44df1017">execute\_sql\_false</a>: Treat as errors any inserts/updates that result in primary key collisions with existing records. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a56694eafed65a54cf067f2cc44df1017">execute\_sql\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ad57b7d5174c1ddb727c7efae60854bb4">execute\_sql\_late\_materialization</a>: If <a href="/content/api/cpp/namespacegpudb#ad0528036a98d995c38e3c55b0cd52d08">true</a>, Joins/Filters results will always be materialized ( saved to result tables format). Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad0528036a98d995c38e3c55b0cd52d08">execute\_sql\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a56694eafed65a54cf067f2cc44df1017">execute\_sql\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a56694eafed65a54cf067f2cc44df1017">execute\_sql\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a1cf02bf6e63569a04fd02f393fc3d8a5">execute\_sql\_paging\_table</a>: When specified (or <a href="/content/api/cpp/namespacegpudb#aebc695a095422e03e1841710d053b2d6">paging\_table\_ttl</a> is set), the system will create a paging table to hold the results of the query, when the output has more records than are in the response (i.e., when <a href="/content/api/cpp/structgpudb_1_1RawExecuteSqlResponse#aa80498dd443e17627061c1a168f6beb5">hasMoreRecords</a> is <a href="/content/api/cpp/namespacegpudb#ad0528036a98d995c38e3c55b0cd52d08">true</a>). If the specified paging table exists, the records from the paging table are returned without re-evaluating the query. It is the caller's responsibility to clear the <a href="/content/api/cpp/structgpudb_1_1RawExecuteSqlResponse#a7513cc3b1e3c45335088094e006cdd32">pagingTable</a> and other tables in the <a href="/content/api/cpp/namespacegpudb#a25ba4b49d3155936653a0dd22d27ff18">result\_table\_list</a> (both returned in the response) when they are done with this query. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aebc695a095422e03e1841710d053b2d6">execute\_sql\_paging\_table\_ttl</a>: Sets the <a href="/content/concepts/ttl/">TTL</a> of the paging table. -1 indicates no timeout. Setting this option will cause a paging table to be generated when needed. The <a href="/content/api/cpp/structgpudb_1_1RawExecuteSqlResponse#a7513cc3b1e3c45335088094e006cdd32">pagingTable</a> and other tables in the <a href="/content/api/cpp/namespacegpudb#a25ba4b49d3155936653a0dd22d27ff18">result\_table\_list</a> (both returned in the response) will be automatically cleared after the TTL expires, if set to a positive number. However, it is still recommended that the caller clear these tables when they are done with this query. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a623845fe2315e9b3270c3fbc4b80f3f7">execute\_sql\_parallel\_execution</a>: If <a href="/content/api/cpp/namespacegpudb#a56694eafed65a54cf067f2cc44df1017">false</a>, disables the parallel step execution of the given query. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad0528036a98d995c38e3c55b0cd52d08">execute\_sql\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a56694eafed65a54cf067f2cc44df1017">execute\_sql\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ad0528036a98d995c38e3c55b0cd52d08">execute\_sql\_true</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#accf48a72173163513f8408aba8cfb630">execute\_sql\_plan\_cache</a>: If <a href="/content/api/cpp/namespacegpudb#a56694eafed65a54cf067f2cc44df1017">false</a>, disables plan caching for the given query. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad0528036a98d995c38e3c55b0cd52d08">execute\_sql\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a56694eafed65a54cf067f2cc44df1017">execute\_sql\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ad0528036a98d995c38e3c55b0cd52d08">execute\_sql\_true</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a4a4a569be3468701eb3d9b40262ec7d9">execute\_sql\_prepare\_mode</a>: If <a href="/content/api/cpp/namespacegpudb#ad0528036a98d995c38e3c55b0cd52d08">true</a>, compiles a query into an execution plan and saves it in query cache. Query execution is not performed and an empty response will be returned to user. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad0528036a98d995c38e3c55b0cd52d08">execute\_sql\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a56694eafed65a54cf067f2cc44df1017">execute\_sql\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a56694eafed65a54cf067f2cc44df1017">execute\_sql\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a43ab163a68e19752f1338aa455d62e16">execute\_sql\_preserve\_dict\_encoding</a>: If <a href="/content/api/cpp/namespacegpudb#ad0528036a98d995c38e3c55b0cd52d08">true</a>, then columns that were dict encoded in the source table will be dict encoded in the projection table. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad0528036a98d995c38e3c55b0cd52d08">execute\_sql\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a56694eafed65a54cf067f2cc44df1017">execute\_sql\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ad0528036a98d995c38e3c55b0cd52d08">execute\_sql\_true</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a6cebddfde5e6b4eae23d7439481cc964">execute\_sql\_query\_parameters</a>: Query parameters in JSON array or arrays (for inserting multiple rows). This can be used instead of <span>data</span> and <span>requestSchemaStr</span>. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a3cf19d3e30a5269942076228b801c5f8">execute\_sql\_results\_caching</a>: If <a href="/content/api/cpp/namespacegpudb#a56694eafed65a54cf067f2cc44df1017">false</a>, disables caching of the results of the given query. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad0528036a98d995c38e3c55b0cd52d08">execute\_sql\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a56694eafed65a54cf067f2cc44df1017">execute\_sql\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ad0528036a98d995c38e3c55b0cd52d08">execute\_sql\_true</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a810e1cdd3a0cfe3b9617992467d3a770">execute\_sql\_rule\_based\_optimization</a>: If <a href="/content/api/cpp/namespacegpudb#a56694eafed65a54cf067f2cc44df1017">false</a>, disables rule-based rewrite optimizations for the given query. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad0528036a98d995c38e3c55b0cd52d08">execute\_sql\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a56694eafed65a54cf067f2cc44df1017">execute\_sql\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ad0528036a98d995c38e3c55b0cd52d08">execute\_sql\_true</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#abde7073e02def638c2cafea0bab6a864">execute\_sql\_ssq\_optimization</a>: If <a href="/content/api/cpp/namespacegpudb#a56694eafed65a54cf067f2cc44df1017">false</a>, scalar subqueries will be translated into joins. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad0528036a98d995c38e3c55b0cd52d08">execute\_sql\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a56694eafed65a54cf067f2cc44df1017">execute\_sql\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ad0528036a98d995c38e3c55b0cd52d08">execute\_sql\_true</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#ab1f6ae0a2e616537fcee63d866d37f53">execute\_sql\_ttl</a>: Sets the <a href="/content/concepts/ttl/">TTL</a> of the intermediate result tables used in query execution. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a30c0b01a1047cb0225f07457e78ca64c">execute\_sql\_update\_on\_existing\_pk</a>: Specifies the record collision policy for inserting into or updating a table with a <a href="/content/concepts/tables/#primary-keys">primary key</a>. If set to <a href="/content/api/cpp/namespacegpudb#ad0528036a98d995c38e3c55b0cd52d08">true</a>, any existing table record with primary key values that match those of a record being inserted or updated will be replaced by that record. If set to <a href="/content/api/cpp/namespacegpudb#a56694eafed65a54cf067f2cc44df1017">false</a>, any such primary key collision will result in the insert/update being rejected and the error handled as determined by <a href="/content/api/cpp/namespacegpudb#ad6546877f9753c4114969b2d94f8dd9a">ignore\_existing\_pk</a>. If the specified table does not have a primary key, then this option has no effect. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad0528036a98d995c38e3c55b0cd52d08">execute\_sql\_true</a>: Replace the collided-into record with the record inserted or updated when a new/modified record causes a primary key collision with an existing record. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a56694eafed65a54cf067f2cc44df1017">execute\_sql\_false</a>: Reject the insert or update when it results in a primary key collision with an existing record. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a56694eafed65a54cf067f2cc44df1017">execute\_sql\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#acda2b32fea85bcfc9cbf7d6cb8d63a80">execute\_sql\_validate\_change\_column</a>: When changing a column using alter table, validate the change before applying it. If <a href="/content/api/cpp/namespacegpudb#ad0528036a98d995c38e3c55b0cd52d08">true</a>, then validate all values. A value too large (or too long) for the new type will prevent any change. If <a href="/content/api/cpp/namespacegpudb#a56694eafed65a54cf067f2cc44df1017">false</a>, then when a value is too large or long, it will be truncated. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad0528036a98d995c38e3c55b0cd52d08">execute\_sql\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a56694eafed65a54cf067f2cc44df1017">execute\_sql\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ad0528036a98d995c38e3c55b0cd52d08">execute\_sql\_true</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#aedc8372fe393566dbee53f39a912c2ee">execute\_sql\_current\_schema</a>: Use the supplied value as the <a href="/content/concepts/schemas/#default-schema">default schema</a> when processing this SQL command. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ExecuteSqlResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a1e52b8d7a110fe25ed3cf8161a565735">◆ </a></span>executeSql() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ExecuteSqlResponse">ExecuteSqlResponse</a> & gpudb::GPUdb::executeSql </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>statement</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const int64\_t</td>
            <td><span><span>offset</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const int64\_t</td>
            <td><span><span>limit</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>requestSchemaStr</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< std::vector\< uint8\_t > > &</td>
            <td><span><span>data</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1ExecuteSqlResponse">ExecuteSqlResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Execute a SQL statement (query, DML, or DDL). </p>
        <p>See <a href="/content/sql/">SQL Support</a> for the complete set of supported SQL commands.</p>
        <p>When a caller wants all the results from a large query (e.g., more than <a href="/content/config/#config-main-general">max\_get\_records\_size</a> records), they can make multiple calls to this endpoint using the <span>offset</span> and <span>limit</span> parameters to page through the results. Normally, this will execute the <span>statement</span> query each time. To avoid re-executing the query each time and to keep the results in the same order, the caller should specify a <a href="/content/api/cpp/namespacegpudb#a1cf02bf6e63569a04fd02f393fc3d8a5">paging\_table</a> name to hold the results of the query between calls and specify the <a href="/content/api/cpp/namespacegpudb#a1cf02bf6e63569a04fd02f393fc3d8a5">paging\_table</a> on subsequent calls. When this is done, the caller should clear the paging table and any other tables in the <a href="/content/api/cpp/namespacegpudb#a25ba4b49d3155936653a0dd22d27ff18">result\_table\_list</a> (both returned in the response) when they are done paging through the results. <a href="/content/api/cpp/structgpudb_1_1RawExecuteSqlResponse#a7513cc3b1e3c45335088094e006cdd32">pagingTable</a> (and <a href="/content/api/cpp/namespacegpudb#a25ba4b49d3155936653a0dd22d27ff18">result\_table\_list</a>) will be empty if no paging table was created (e.g., when all the query results were returned in the first call).</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>statement</td>
                <td>SQL statement (query, DML, or DDL) to be executed. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>offset</td>
                <td>A positive integer indicating the number of initial results to skip (this can be useful for paging through the results). The default value is 0. The minimum allowed value is 0. The maximum allowed value is MAX\_INT. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>limit</td>
                <td>A positive integer indicating the maximum number of results to be returned, or END\_OF\_SET (-9999) to indicate that the maximum number of results allowed by the server should be returned. The number of records returned will never exceed the server's own limit, defined by the <a href="/content/config/#config-main-general">max\_get\_records\_size</a> parameter in the server configuration. Use <a href="/content/api/cpp/structgpudb_1_1RawExecuteSqlResponse#aa80498dd443e17627061c1a168f6beb5">hasMoreRecords</a> to see if more records exist in the result to be fetched, and <span>offset</span> and <span>limit</span> to request subsequent pages of results. The default value is -9999. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>requestSchemaStr</td>
                <td>Avro schema of <span>data</span>. The default value is ''. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>data</td>
                <td>An array of binary-encoded data for the records to be binded to the SQL query. Or use <a href="/content/api/cpp/namespacegpudb#a6cebddfde5e6b4eae23d7439481cc964">query\_parameters</a> to pass the data in JSON format. The default value is an empty vector. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#add12bc9ed427fb67fa019456bad0362e">execute\_sql\_cost\_based\_optimization</a>: If <a href="/content/api/cpp/namespacegpudb#a56694eafed65a54cf067f2cc44df1017">false</a>, disables the cost-based optimization of the given query. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad0528036a98d995c38e3c55b0cd52d08">execute\_sql\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a56694eafed65a54cf067f2cc44df1017">execute\_sql\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a56694eafed65a54cf067f2cc44df1017">execute\_sql\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ac8b94984d1229e7f667e62ab8fd8ad71">execute\_sql\_distributed\_joins</a>: If <a href="/content/api/cpp/namespacegpudb#ad0528036a98d995c38e3c55b0cd52d08">true</a>, enables the use of distributed joins in servicing the given query. Any query requiring a distributed join will succeed, though hints can be used in the query to change the distribution of the source data to allow the query to succeed. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad0528036a98d995c38e3c55b0cd52d08">execute\_sql\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a56694eafed65a54cf067f2cc44df1017">execute\_sql\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a56694eafed65a54cf067f2cc44df1017">execute\_sql\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a686c3e25bee2b4412d027033e38c81f4">execute\_sql\_distributed\_operations</a>: If <a href="/content/api/cpp/namespacegpudb#ad0528036a98d995c38e3c55b0cd52d08">true</a>, enables the use of distributed operations in servicing the given query. Any query requiring a distributed join will succeed, though hints can be used in the query to change the distribution of the source data to allow the query to succeed. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad0528036a98d995c38e3c55b0cd52d08">execute\_sql\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a56694eafed65a54cf067f2cc44df1017">execute\_sql\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a56694eafed65a54cf067f2cc44df1017">execute\_sql\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ad6546877f9753c4114969b2d94f8dd9a">execute\_sql\_ignore\_existing\_pk</a>: Specifies the record collision error-suppression policy for inserting into or updating a table with a <a href="/content/concepts/tables/#primary-keys">primary key</a>, only used when primary key record collisions are rejected (<a href="/content/api/cpp/namespacegpudb#a30c0b01a1047cb0225f07457e78ca64c">update\_on\_existing\_pk</a> is <a href="/content/api/cpp/namespacegpudb#a56694eafed65a54cf067f2cc44df1017">false</a>). If set to <a href="/content/api/cpp/namespacegpudb#ad0528036a98d995c38e3c55b0cd52d08">true</a>, any record insert/update that is rejected for resulting in a primary key collision with an existing table record will be ignored with no error generated. If <a href="/content/api/cpp/namespacegpudb#a56694eafed65a54cf067f2cc44df1017">false</a>, the rejection of any insert/update for resulting in a primary key collision will cause an error to be reported. If the specified table does not have a primary key or if <a href="/content/api/cpp/namespacegpudb#a30c0b01a1047cb0225f07457e78ca64c">update\_on\_existing\_pk</a> is <a href="/content/api/cpp/namespacegpudb#ad0528036a98d995c38e3c55b0cd52d08">true</a>, then this option has no effect. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad0528036a98d995c38e3c55b0cd52d08">execute\_sql\_true</a>: Ignore inserts/updates that result in primary key collisions with existing records. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a56694eafed65a54cf067f2cc44df1017">execute\_sql\_false</a>: Treat as errors any inserts/updates that result in primary key collisions with existing records. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a56694eafed65a54cf067f2cc44df1017">execute\_sql\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ad57b7d5174c1ddb727c7efae60854bb4">execute\_sql\_late\_materialization</a>: If <a href="/content/api/cpp/namespacegpudb#ad0528036a98d995c38e3c55b0cd52d08">true</a>, Joins/Filters results will always be materialized ( saved to result tables format). Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad0528036a98d995c38e3c55b0cd52d08">execute\_sql\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a56694eafed65a54cf067f2cc44df1017">execute\_sql\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a56694eafed65a54cf067f2cc44df1017">execute\_sql\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a1cf02bf6e63569a04fd02f393fc3d8a5">execute\_sql\_paging\_table</a>: When specified (or <a href="/content/api/cpp/namespacegpudb#aebc695a095422e03e1841710d053b2d6">paging\_table\_ttl</a> is set), the system will create a paging table to hold the results of the query, when the output has more records than are in the response (i.e., when <a href="/content/api/cpp/structgpudb_1_1RawExecuteSqlResponse#aa80498dd443e17627061c1a168f6beb5">hasMoreRecords</a> is <a href="/content/api/cpp/namespacegpudb#ad0528036a98d995c38e3c55b0cd52d08">true</a>). If the specified paging table exists, the records from the paging table are returned without re-evaluating the query. It is the caller's responsibility to clear the <a href="/content/api/cpp/structgpudb_1_1RawExecuteSqlResponse#a7513cc3b1e3c45335088094e006cdd32">pagingTable</a> and other tables in the <a href="/content/api/cpp/namespacegpudb#a25ba4b49d3155936653a0dd22d27ff18">result\_table\_list</a> (both returned in the response) when they are done with this query. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aebc695a095422e03e1841710d053b2d6">execute\_sql\_paging\_table\_ttl</a>: Sets the <a href="/content/concepts/ttl/">TTL</a> of the paging table. -1 indicates no timeout. Setting this option will cause a paging table to be generated when needed. The <a href="/content/api/cpp/structgpudb_1_1RawExecuteSqlResponse#a7513cc3b1e3c45335088094e006cdd32">pagingTable</a> and other tables in the <a href="/content/api/cpp/namespacegpudb#a25ba4b49d3155936653a0dd22d27ff18">result\_table\_list</a> (both returned in the response) will be automatically cleared after the TTL expires, if set to a positive number. However, it is still recommended that the caller clear these tables when they are done with this query. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a623845fe2315e9b3270c3fbc4b80f3f7">execute\_sql\_parallel\_execution</a>: If <a href="/content/api/cpp/namespacegpudb#a56694eafed65a54cf067f2cc44df1017">false</a>, disables the parallel step execution of the given query. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad0528036a98d995c38e3c55b0cd52d08">execute\_sql\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a56694eafed65a54cf067f2cc44df1017">execute\_sql\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ad0528036a98d995c38e3c55b0cd52d08">execute\_sql\_true</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#accf48a72173163513f8408aba8cfb630">execute\_sql\_plan\_cache</a>: If <a href="/content/api/cpp/namespacegpudb#a56694eafed65a54cf067f2cc44df1017">false</a>, disables plan caching for the given query. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad0528036a98d995c38e3c55b0cd52d08">execute\_sql\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a56694eafed65a54cf067f2cc44df1017">execute\_sql\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ad0528036a98d995c38e3c55b0cd52d08">execute\_sql\_true</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a4a4a569be3468701eb3d9b40262ec7d9">execute\_sql\_prepare\_mode</a>: If <a href="/content/api/cpp/namespacegpudb#ad0528036a98d995c38e3c55b0cd52d08">true</a>, compiles a query into an execution plan and saves it in query cache. Query execution is not performed and an empty response will be returned to user. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad0528036a98d995c38e3c55b0cd52d08">execute\_sql\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a56694eafed65a54cf067f2cc44df1017">execute\_sql\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a56694eafed65a54cf067f2cc44df1017">execute\_sql\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a43ab163a68e19752f1338aa455d62e16">execute\_sql\_preserve\_dict\_encoding</a>: If <a href="/content/api/cpp/namespacegpudb#ad0528036a98d995c38e3c55b0cd52d08">true</a>, then columns that were dict encoded in the source table will be dict encoded in the projection table. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad0528036a98d995c38e3c55b0cd52d08">execute\_sql\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a56694eafed65a54cf067f2cc44df1017">execute\_sql\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ad0528036a98d995c38e3c55b0cd52d08">execute\_sql\_true</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a6cebddfde5e6b4eae23d7439481cc964">execute\_sql\_query\_parameters</a>: Query parameters in JSON array or arrays (for inserting multiple rows). This can be used instead of <span>data</span> and <span>requestSchemaStr</span>. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a3cf19d3e30a5269942076228b801c5f8">execute\_sql\_results\_caching</a>: If <a href="/content/api/cpp/namespacegpudb#a56694eafed65a54cf067f2cc44df1017">false</a>, disables caching of the results of the given query. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad0528036a98d995c38e3c55b0cd52d08">execute\_sql\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a56694eafed65a54cf067f2cc44df1017">execute\_sql\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ad0528036a98d995c38e3c55b0cd52d08">execute\_sql\_true</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a810e1cdd3a0cfe3b9617992467d3a770">execute\_sql\_rule\_based\_optimization</a>: If <a href="/content/api/cpp/namespacegpudb#a56694eafed65a54cf067f2cc44df1017">false</a>, disables rule-based rewrite optimizations for the given query. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad0528036a98d995c38e3c55b0cd52d08">execute\_sql\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a56694eafed65a54cf067f2cc44df1017">execute\_sql\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ad0528036a98d995c38e3c55b0cd52d08">execute\_sql\_true</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#abde7073e02def638c2cafea0bab6a864">execute\_sql\_ssq\_optimization</a>: If <a href="/content/api/cpp/namespacegpudb#a56694eafed65a54cf067f2cc44df1017">false</a>, scalar subqueries will be translated into joins. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad0528036a98d995c38e3c55b0cd52d08">execute\_sql\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a56694eafed65a54cf067f2cc44df1017">execute\_sql\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ad0528036a98d995c38e3c55b0cd52d08">execute\_sql\_true</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#ab1f6ae0a2e616537fcee63d866d37f53">execute\_sql\_ttl</a>: Sets the <a href="/content/concepts/ttl/">TTL</a> of the intermediate result tables used in query execution. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a30c0b01a1047cb0225f07457e78ca64c">execute\_sql\_update\_on\_existing\_pk</a>: Specifies the record collision policy for inserting into or updating a table with a <a href="/content/concepts/tables/#primary-keys">primary key</a>. If set to <a href="/content/api/cpp/namespacegpudb#ad0528036a98d995c38e3c55b0cd52d08">true</a>, any existing table record with primary key values that match those of a record being inserted or updated will be replaced by that record. If set to <a href="/content/api/cpp/namespacegpudb#a56694eafed65a54cf067f2cc44df1017">false</a>, any such primary key collision will result in the insert/update being rejected and the error handled as determined by <a href="/content/api/cpp/namespacegpudb#ad6546877f9753c4114969b2d94f8dd9a">ignore\_existing\_pk</a>. If the specified table does not have a primary key, then this option has no effect. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad0528036a98d995c38e3c55b0cd52d08">execute\_sql\_true</a>: Replace the collided-into record with the record inserted or updated when a new/modified record causes a primary key collision with an existing record. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a56694eafed65a54cf067f2cc44df1017">execute\_sql\_false</a>: Reject the insert or update when it results in a primary key collision with an existing record. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a56694eafed65a54cf067f2cc44df1017">execute\_sql\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#acda2b32fea85bcfc9cbf7d6cb8d63a80">execute\_sql\_validate\_change\_column</a>: When changing a column using alter table, validate the change before applying it. If <a href="/content/api/cpp/namespacegpudb#ad0528036a98d995c38e3c55b0cd52d08">true</a>, then validate all values. A value too large (or too long) for the new type will prevent any change. If <a href="/content/api/cpp/namespacegpudb#a56694eafed65a54cf067f2cc44df1017">false</a>, then when a value is too large or long, it will be truncated. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad0528036a98d995c38e3c55b0cd52d08">execute\_sql\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a56694eafed65a54cf067f2cc44df1017">execute\_sql\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ad0528036a98d995c38e3c55b0cd52d08">execute\_sql\_true</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#aedc8372fe393566dbee53f39a912c2ee">execute\_sql\_current\_schema</a>: Use the supplied value as the <a href="/content/concepts/schemas/#default-schema">default schema</a> when processing this SQL command. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ExecuteSqlResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ExecuteSqlResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a0467a00f7a623da381265796b580e7ce">◆ </a></span>executeSqlRaw() <span>\[1/2]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1RawExecuteSqlResponse">RawExecuteSqlResponse</a> gpudb::GPUdb::executeSqlRaw </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1ExecuteSqlRequest">ExecuteSqlRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Execute a SQL statement (query, DML, or DDL). </p>
        <p>See <a href="/content/sql/">SQL Support</a> for the complete set of supported SQL commands.</p>
        <p>When a caller wants all the results from a large query (e.g., more than <a href="/content/config/#config-main-general">max\_get\_records\_size</a> records), they can make multiple calls to this endpoint using the <a href="/content/api/cpp/structgpudb_1_1ExecuteSqlRequest#a8028935e70224cefd72f7fa79b0ef7de">offset</a> and <a href="/content/api/cpp/structgpudb_1_1ExecuteSqlRequest#a3613f778b8f80448019e49f740ef09af">limit</a> parameters to page through the results. Normally, this will execute the <a href="/content/api/cpp/structgpudb_1_1ExecuteSqlRequest#ad8b660473874fb465d1c69677edc191c">statement</a> query each time. To avoid re-executing the query each time and to keep the results in the same order, the caller should specify a <a href="/content/api/cpp/namespacegpudb#a1cf02bf6e63569a04fd02f393fc3d8a5">paging\_table</a> name to hold the results of the query between calls and specify the <a href="/content/api/cpp/namespacegpudb#a1cf02bf6e63569a04fd02f393fc3d8a5">paging\_table</a> on subsequent calls. When this is done, the caller should clear the paging table and any other tables in the <a href="/content/api/cpp/namespacegpudb#a25ba4b49d3155936653a0dd22d27ff18">result\_table\_list</a> (both returned in the response) when they are done paging through the results. <a href="/content/api/cpp/structgpudb_1_1RawExecuteSqlResponse#a7513cc3b1e3c45335088094e006cdd32">pagingTable</a> (and <a href="/content/api/cpp/namespacegpudb#a25ba4b49d3155936653a0dd22d27ff18">result\_table\_list</a>) will be empty if no paging table was created (e.g., when all the query results were returned in the first call).</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ExecuteSqlRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1RawExecuteSqlResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a0b1e04620afea4b5b3b0ce3eea517a55">◆ </a></span>executeSqlRaw() <span>\[2/2]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1RawExecuteSqlResponse">RawExecuteSqlResponse</a> & gpudb::GPUdb::executeSqlRaw </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1ExecuteSqlRequest">ExecuteSqlRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1RawExecuteSqlResponse">RawExecuteSqlResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Execute a SQL statement (query, DML, or DDL). </p>
        <p>See <a href="/content/sql/">SQL Support</a> for the complete set of supported SQL commands.</p>
        <p>When a caller wants all the results from a large query (e.g., more than <a href="/content/config/#config-main-general">max\_get\_records\_size</a> records), they can make multiple calls to this endpoint using the <a href="/content/api/cpp/structgpudb_1_1ExecuteSqlRequest#a8028935e70224cefd72f7fa79b0ef7de">offset</a> and <a href="/content/api/cpp/structgpudb_1_1ExecuteSqlRequest#a3613f778b8f80448019e49f740ef09af">limit</a> parameters to page through the results. Normally, this will execute the <a href="/content/api/cpp/structgpudb_1_1ExecuteSqlRequest#ad8b660473874fb465d1c69677edc191c">statement</a> query each time. To avoid re-executing the query each time and to keep the results in the same order, the caller should specify a <a href="/content/api/cpp/namespacegpudb#a1cf02bf6e63569a04fd02f393fc3d8a5">paging\_table</a> name to hold the results of the query between calls and specify the <a href="/content/api/cpp/namespacegpudb#a1cf02bf6e63569a04fd02f393fc3d8a5">paging\_table</a> on subsequent calls. When this is done, the caller should clear the paging table and any other tables in the <a href="/content/api/cpp/namespacegpudb#a25ba4b49d3155936653a0dd22d27ff18">result\_table\_list</a> (both returned in the response) when they are done paging through the results. <a href="/content/api/cpp/structgpudb_1_1RawExecuteSqlResponse#a7513cc3b1e3c45335088094e006cdd32">pagingTable</a> (and <a href="/content/api/cpp/namespacegpudb#a25ba4b49d3155936653a0dd22d27ff18">result\_table\_list</a>) will be empty if no paging table was created (e.g., when all the query results were returned in the first call).</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ExecuteSqlRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1RawExecuteSqlResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1RawExecuteSqlResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a6df9ad317c7d2a3d64d8ac8458714ee8">◆ </a></span>exportQueryMetrics() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ExportQueryMetricsResponse">ExportQueryMetricsResponse</a> gpudb::GPUdb::exportQueryMetrics </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1ExportQueryMetricsRequest">ExportQueryMetricsRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Export query metrics to a given destination. </p>
        <p>Returns query metrics.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ExportQueryMetricsRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ExportQueryMetricsResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a43c34114c40250de0da0d9d648a17c2b">◆ </a></span>exportQueryMetrics() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ExportQueryMetricsResponse">ExportQueryMetricsResponse</a> & gpudb::GPUdb::exportQueryMetrics </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1ExportQueryMetricsRequest">ExportQueryMetricsRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1ExportQueryMetricsResponse">ExportQueryMetricsResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Export query metrics to a given destination. </p>
        <p>Returns query metrics.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ExportQueryMetricsRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ExportQueryMetricsResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ExportQueryMetricsResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a1fa54ce032273e8e7d62caa01d88af62">◆ </a></span>exportQueryMetrics() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ExportQueryMetricsResponse">ExportQueryMetricsResponse</a> gpudb::GPUdb::exportQueryMetrics </td>
            <td>(</td>
            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Export query metrics to a given destination. </p>
        <p>Returns query metrics.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#aade85b5b230b4d8c4301356d7a962aa7">export\_query\_metrics\_expression</a>: Filter for multi query export. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a9b8dd02a4def79053665f2b16a617070">export\_query\_metrics\_filepath</a>: Path to export target specified as a filename or existing directory. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a2805c8a7d3df4107088cb3c859abb9c1">export\_query\_metrics\_format</a>: Specifies which format to export the metrics. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#abd80d36cace6010a3c6511854ee39b9d">export\_query\_metrics\_json</a>: Generic JSON output. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a5a1d553c5ed97b126c390efa90ee20a5">export\_query\_metrics\_json\_trace\_event</a>: Chromium/Perfetto trace event format. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#abd80d36cace6010a3c6511854ee39b9d">export\_query\_metrics\_json</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#adb56aa483088e107cf88ed2a3fb7f27d">export\_query\_metrics\_job\_id</a>: Export query metrics for the currently running job. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a7467a31b2588b2e852140d0a6d902713">export\_query\_metrics\_limit</a>: Record limit per file for multi query export. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ExportQueryMetricsResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a292947b6dc2f76450057d3cfdf279d3e">◆ </a></span>exportQueryMetrics() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ExportQueryMetricsResponse">ExportQueryMetricsResponse</a> & gpudb::GPUdb::exportQueryMetrics </td>
            <td>(</td>
            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1ExportQueryMetricsResponse">ExportQueryMetricsResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Export query metrics to a given destination. </p>
        <p>Returns query metrics.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#aade85b5b230b4d8c4301356d7a962aa7">export\_query\_metrics\_expression</a>: Filter for multi query export. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a9b8dd02a4def79053665f2b16a617070">export\_query\_metrics\_filepath</a>: Path to export target specified as a filename or existing directory. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a2805c8a7d3df4107088cb3c859abb9c1">export\_query\_metrics\_format</a>: Specifies which format to export the metrics. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#abd80d36cace6010a3c6511854ee39b9d">export\_query\_metrics\_json</a>: Generic JSON output. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a5a1d553c5ed97b126c390efa90ee20a5">export\_query\_metrics\_json\_trace\_event</a>: Chromium/Perfetto trace event format. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#abd80d36cace6010a3c6511854ee39b9d">export\_query\_metrics\_json</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#adb56aa483088e107cf88ed2a3fb7f27d">export\_query\_metrics\_job\_id</a>: Export query metrics for the currently running job. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a7467a31b2588b2e852140d0a6d902713">export\_query\_metrics\_limit</a>: Record limit per file for multi query export. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ExportQueryMetricsResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ExportQueryMetricsResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ac87ebd44dd67211df26b516cd7d3a7a4">◆ </a></span>exportRecordsToFiles() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ExportRecordsToFilesResponse">ExportRecordsToFilesResponse</a> gpudb::GPUdb::exportRecordsToFiles </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1ExportRecordsToFilesRequest">ExportRecordsToFilesRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Export records from a table to files. </p>
        <p>All tables can be exported, in full or partial (see <a href="/content/api/cpp/namespacegpudb#a48c9d896f6b80d3bf338684c4e8c32e1">columns\_to\_export</a> and <a href="/content/api/cpp/namespacegpudb#aefab5f26300d57af56af58aff3718cc5">columns\_to\_skip</a>). Additional filtering can be applied when using export table with expression through SQL. Default destination is KIFS, though other storage types (Azure, S3, GCS, and HDFS) are supported through <a href="/content/api/cpp/namespacegpudb#ac2d99673490df73e884ac28dccaf6bdd">datasink\_name</a>; see <a href="#ad32bfcf63c4db33db0de668a02c2ff8e">createDatasink</a>.</p>
        <p>Server's local file system is not supported. Default file format is delimited text. See options for different file types and different options for each file type. Table is saved to a single file if within max file size limits (may vary depending on datasink type). If not, then table is split into multiple files; these may be smaller than the max size limit.</p>
        <p>All filenames created are returned in the response.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ExportRecordsToFilesRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ExportRecordsToFilesResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a66c79c3143982b18ff2d8e48e99e9100">◆ </a></span>exportRecordsToFiles() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ExportRecordsToFilesResponse">ExportRecordsToFilesResponse</a> & gpudb::GPUdb::exportRecordsToFiles </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1ExportRecordsToFilesRequest">ExportRecordsToFilesRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1ExportRecordsToFilesResponse">ExportRecordsToFilesResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Export records from a table to files. </p>
        <p>All tables can be exported, in full or partial (see <a href="/content/api/cpp/namespacegpudb#a48c9d896f6b80d3bf338684c4e8c32e1">columns\_to\_export</a> and <a href="/content/api/cpp/namespacegpudb#aefab5f26300d57af56af58aff3718cc5">columns\_to\_skip</a>). Additional filtering can be applied when using export table with expression through SQL. Default destination is KIFS, though other storage types (Azure, S3, GCS, and HDFS) are supported through <a href="/content/api/cpp/namespacegpudb#ac2d99673490df73e884ac28dccaf6bdd">datasink\_name</a>; see <a href="#ad32bfcf63c4db33db0de668a02c2ff8e">createDatasink</a>.</p>
        <p>Server's local file system is not supported. Default file format is delimited text. See options for different file types and different options for each file type. Table is saved to a single file if within max file size limits (may vary depending on datasink type). If not, then table is split into multiple files; these may be smaller than the max size limit.</p>
        <p>All filenames created are returned in the response.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ExportRecordsToFilesRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ExportRecordsToFilesResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ExportRecordsToFilesResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a66a1fac770f06727b15cc86643507496">◆ </a></span>exportRecordsToFiles() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ExportRecordsToFilesResponse">ExportRecordsToFilesResponse</a> gpudb::GPUdb::exportRecordsToFiles </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>filepath</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Export records from a table to files. </p>
        <p>All tables can be exported, in full or partial (see <a href="/content/api/cpp/namespacegpudb#a48c9d896f6b80d3bf338684c4e8c32e1">columns\_to\_export</a> and <a href="/content/api/cpp/namespacegpudb#aefab5f26300d57af56af58aff3718cc5">columns\_to\_skip</a>). Additional filtering can be applied when using export table with expression through SQL. Default destination is KIFS, though other storage types (Azure, S3, GCS, and HDFS) are supported through <a href="/content/api/cpp/namespacegpudb#ac2d99673490df73e884ac28dccaf6bdd">datasink\_name</a>; see <a href="#a84ef0210170f53a95829d990695287f0">createDatasink</a>.</p>
        <p>Server's local file system is not supported. Default file format is delimited text. See options for different file types and different options for each file type. Table is saved to a single file if within max file size limits (may vary depending on datasink type). If not, then table is split into multiple files; these may be smaller than the max size limit.</p>
        <p>All filenames created are returned in the response.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>The name of the table whose records are to be exported. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>filepath</td>
                <td>Path to data export target. If <span>filepath</span> has a file extension, it is read as the name of a file. If <span>filepath</span> is a directory, then the source table name with a random UUID appended will be used as the name of each exported file, all written to that directory. If filepath is a filename, then all exported files will have a random UUID appended to the given name. In either case, the target directory specified or implied must exist. The names of all exported files are returned in the response. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#aaeaf64ab2d25ca6d13ad18b7fcbbb16c">export\_records\_to\_files\_batch\_size</a>: Number of records to be exported as a batch. The default value is '1000000'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a80cc5d48102a25704f8b0f0ee2eace2d">export\_records\_to\_files\_column\_formats</a>: For each source column specified, applies the column-property-bound format. Currently supported column properties include date, time, and datetime. The parameter value must be formatted as a JSON string of maps of column names to maps of column properties to their corresponding column formats, e.g., ' "order\_date" :  "date" : "%Y.%m.%d" , "order\_time" :  "time" : "%H:%M:%S"  '. See <a href="/content/api/cpp/namespacegpudb#a65f6d4b30d37cee3f3782c6034f56b8f">default\_column\_formats</a> for valid format syntax. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a48c9d896f6b80d3bf338684c4e8c32e1">export\_records\_to\_files\_columns\_to\_export</a>: Specifies a comma-delimited list of columns from the source table to export, written to the output file in the order they are given. Column names can be provided, in which case the target file will use those names as the column headers as well. Alternatively, column numbers can be specified–discretely or as a range. For example, a value of '5,7,1..3' will write values from the fifth column in the source table into the first column in the target file, from the seventh column in the source table into the second column in the target file, and from the first through third columns in the source table into the third through fifth columns in the target file. Mutually exclusive with <a href="/content/api/cpp/namespacegpudb#aefab5f26300d57af56af58aff3718cc5">columns\_to\_skip</a>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aefab5f26300d57af56af58aff3718cc5">export\_records\_to\_files\_columns\_to\_skip</a>: Comma-separated list of column names or column numbers to not export. All columns in the source table not specified will be written to the target file in the order they appear in the table definition. Mutually exclusive with <a href="/content/api/cpp/namespacegpudb#a48c9d896f6b80d3bf338684c4e8c32e1">columns\_to\_export</a>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ac2d99673490df73e884ac28dccaf6bdd">export\_records\_to\_files\_datasink\_name</a>: Datasink name, created using <a href="#a84ef0210170f53a95829d990695287f0">createDatasink</a>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a65f6d4b30d37cee3f3782c6034f56b8f">export\_records\_to\_files\_default\_column\_formats</a>: Specifies the default format to use to write data. Currently supported column properties include date, time, and datetime. This default column-property-bound format can be overridden by specifying a column property and format for a given source column in <a href="/content/api/cpp/namespacegpudb#a80cc5d48102a25704f8b0f0ee2eace2d">column\_formats</a>. For each specified annotation, the format will apply to all columns with that annotation unless custom <a href="/content/api/cpp/namespacegpudb#a80cc5d48102a25704f8b0f0ee2eace2d">column\_formats</a> for that annotation are specified. The parameter value must be formatted as a JSON string that is a map of column properties to their respective column formats, e.g., ' "date" : "%Y.%m.%d", "time" : "%H:%M:%S" '. Column formats are specified as a string of control characters and plain text. The supported control characters are 'Y', 'm', 'd', 'H', 'M', 'S', and 's', which follow the Linux 'strptime()' specification, as well as 's', which specifies seconds and fractional seconds (though the fractional component will be truncated past milliseconds). Formats for the 'date' annotation must include the 'Y', 'm', and 'd' control characters. Formats for the 'time' annotation must include the 'H', 'M', and either 'S' or 's' (but not both) control characters. Formats for the 'datetime' annotation meet both the 'date' and 'time' control character requirements. For example, '"datetime" : "%m/%d/%Y %H:%M:%S" ' would be used to write text as "05/04/2000 12:12:11" </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a292525e5cc5d55c1d533a8a68ac540aa">export\_records\_to\_files\_export\_ddl</a>: Save DDL to a separate file. The default value is 'false'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a1784384afe271dd876caf4104b3602ad">export\_records\_to\_files\_file\_extension</a>: Extension to give the export file. The default value is '.csv'. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ae343f022827db753ca975bb620a68c72">export\_records\_to\_files\_file\_type</a>: Specifies the file format to use when exporting data. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a7fd9e92cdf7edcedb122eda79d1f13b7">export\_records\_to\_files\_delimited\_text</a>: Delimited text file format; e.g., CSV, TSV, PSV, etc. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a4d03c225ef99286c4719984bb253732a">export\_records\_to\_files\_parquet</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a7fd9e92cdf7edcedb122eda79d1f13b7">export\_records\_to\_files\_delimited\_text</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#af0697cfd2c1577c5ef0616bcbbab65b1">export\_records\_to\_files\_kinetica\_header</a>: Whether to include a Kinetica proprietary header. Will not be written if <a href="/content/api/cpp/namespacegpudb#a3faa58c352fdc4691ca17df1eb7424d5">text\_has\_header</a> is <a href="/content/api/cpp/namespacegpudb#a79702cb212b875d1dbd2436e6fa3fedd">false</a>. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ac3cc4c6bcb1191615d2131282e88a705">export\_records\_to\_files\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a79702cb212b875d1dbd2436e6fa3fedd">export\_records\_to\_files\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a79702cb212b875d1dbd2436e6fa3fedd">export\_records\_to\_files\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a73491168861c16d238e6cf4103694e84">export\_records\_to\_files\_kinetica\_header\_delimiter</a>: If a Kinetica proprietary header is included, then specify a property separator. Different from column delimiter. The default value is '|'. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a0cdb3f69354a8137425d002809e6d55c">export\_records\_to\_files\_compression\_type</a>: File compression type. GZip can be applied to text and Parquet files. Snappy can only be applied to Parquet files, and is the default compression for them. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ae4994eb8f0b7caed6aee40abeba0ed54">export\_records\_to\_files\_uncompressed</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a5841c532b649c5e50185fdcc8a679edd">export\_records\_to\_files\_snappy</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a7220dff01023f4a08062f08a93c6d4c2">export\_records\_to\_files\_gzip</a> </li>
                      </ul>
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a4d18afbe3500ce71d8babb1f95803b8b">export\_records\_to\_files\_single\_file</a>: Save records to a single file. This option may be ignored if file size exceeds internal file size limits (this limit will differ on different targets). Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ac3cc4c6bcb1191615d2131282e88a705">export\_records\_to\_files\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a79702cb212b875d1dbd2436e6fa3fedd">export\_records\_to\_files\_false</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aadaf71f5f5355b13c499f42921e5033d">export\_records\_to\_files\_overwrite</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ac3cc4c6bcb1191615d2131282e88a705">export\_records\_to\_files\_true</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a1c6731f9d8dadde95c9e609f76c13679">export\_records\_to\_files\_single\_file\_max\_size</a>: Max file size (in MB) to allow saving to a single file. May be overridden by target limitations. The default value is ''. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ae9f98ebea697c9efa461d13ef4b5a6f4">export\_records\_to\_files\_text\_delimiter</a>: Specifies the character to write out to delimit field values and field names in the header (if present). For <a href="/content/api/cpp/namespacegpudb#a7fd9e92cdf7edcedb122eda79d1f13b7">delimited\_text</a> <a href="/content/api/cpp/namespacegpudb#ae343f022827db753ca975bb620a68c72">file\_type</a> only. The default value is ','. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a3faa58c352fdc4691ca17df1eb7424d5">export\_records\_to\_files\_text\_has\_header</a>: Indicates whether to write out a header row. For <a href="/content/api/cpp/namespacegpudb#a7fd9e92cdf7edcedb122eda79d1f13b7">delimited\_text</a><a href="/content/api/cpp/namespacegpudb#ae343f022827db753ca975bb620a68c72">file\_type</a> only. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ac3cc4c6bcb1191615d2131282e88a705">export\_records\_to\_files\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a79702cb212b875d1dbd2436e6fa3fedd">export\_records\_to\_files\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ac3cc4c6bcb1191615d2131282e88a705">export\_records\_to\_files\_true</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a0198b4ec45c63cb56d1585e99aa86dfe">export\_records\_to\_files\_text\_null\_string</a>: Specifies the character string that should be written out for the null value in the data. For <a href="/content/api/cpp/namespacegpudb#a7fd9e92cdf7edcedb122eda79d1f13b7">delimited\_text</a> <a href="/content/api/cpp/namespacegpudb#ae343f022827db753ca975bb620a68c72">file\_type</a> only. The default value is '\N'. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ExportRecordsToFilesResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ab374af267e3c6213b782792a76c26411">◆ </a></span>exportRecordsToFiles() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ExportRecordsToFilesResponse">ExportRecordsToFilesResponse</a> & gpudb::GPUdb::exportRecordsToFiles </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>filepath</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1ExportRecordsToFilesResponse">ExportRecordsToFilesResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Export records from a table to files. </p>
        <p>All tables can be exported, in full or partial (see <a href="/content/api/cpp/namespacegpudb#a48c9d896f6b80d3bf338684c4e8c32e1">columns\_to\_export</a> and <a href="/content/api/cpp/namespacegpudb#aefab5f26300d57af56af58aff3718cc5">columns\_to\_skip</a>). Additional filtering can be applied when using export table with expression through SQL. Default destination is KIFS, though other storage types (Azure, S3, GCS, and HDFS) are supported through <a href="/content/api/cpp/namespacegpudb#ac2d99673490df73e884ac28dccaf6bdd">datasink\_name</a>; see <a href="#a84ef0210170f53a95829d990695287f0">createDatasink</a>.</p>
        <p>Server's local file system is not supported. Default file format is delimited text. See options for different file types and different options for each file type. Table is saved to a single file if within max file size limits (may vary depending on datasink type). If not, then table is split into multiple files; these may be smaller than the max size limit.</p>
        <p>All filenames created are returned in the response.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>The name of the table whose records are to be exported. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>filepath</td>
                <td>Path to data export target. If <span>filepath</span> has a file extension, it is read as the name of a file. If <span>filepath</span> is a directory, then the source table name with a random UUID appended will be used as the name of each exported file, all written to that directory. If filepath is a filename, then all exported files will have a random UUID appended to the given name. In either case, the target directory specified or implied must exist. The names of all exported files are returned in the response. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#aaeaf64ab2d25ca6d13ad18b7fcbbb16c">export\_records\_to\_files\_batch\_size</a>: Number of records to be exported as a batch. The default value is '1000000'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a80cc5d48102a25704f8b0f0ee2eace2d">export\_records\_to\_files\_column\_formats</a>: For each source column specified, applies the column-property-bound format. Currently supported column properties include date, time, and datetime. The parameter value must be formatted as a JSON string of maps of column names to maps of column properties to their corresponding column formats, e.g., ' "order\_date" :  "date" : "%Y.%m.%d" , "order\_time" :  "time" : "%H:%M:%S"  '. See <a href="/content/api/cpp/namespacegpudb#a65f6d4b30d37cee3f3782c6034f56b8f">default\_column\_formats</a> for valid format syntax. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a48c9d896f6b80d3bf338684c4e8c32e1">export\_records\_to\_files\_columns\_to\_export</a>: Specifies a comma-delimited list of columns from the source table to export, written to the output file in the order they are given. Column names can be provided, in which case the target file will use those names as the column headers as well. Alternatively, column numbers can be specified–discretely or as a range. For example, a value of '5,7,1..3' will write values from the fifth column in the source table into the first column in the target file, from the seventh column in the source table into the second column in the target file, and from the first through third columns in the source table into the third through fifth columns in the target file. Mutually exclusive with <a href="/content/api/cpp/namespacegpudb#aefab5f26300d57af56af58aff3718cc5">columns\_to\_skip</a>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aefab5f26300d57af56af58aff3718cc5">export\_records\_to\_files\_columns\_to\_skip</a>: Comma-separated list of column names or column numbers to not export. All columns in the source table not specified will be written to the target file in the order they appear in the table definition. Mutually exclusive with <a href="/content/api/cpp/namespacegpudb#a48c9d896f6b80d3bf338684c4e8c32e1">columns\_to\_export</a>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ac2d99673490df73e884ac28dccaf6bdd">export\_records\_to\_files\_datasink\_name</a>: Datasink name, created using <a href="#a84ef0210170f53a95829d990695287f0">createDatasink</a>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a65f6d4b30d37cee3f3782c6034f56b8f">export\_records\_to\_files\_default\_column\_formats</a>: Specifies the default format to use to write data. Currently supported column properties include date, time, and datetime. This default column-property-bound format can be overridden by specifying a column property and format for a given source column in <a href="/content/api/cpp/namespacegpudb#a80cc5d48102a25704f8b0f0ee2eace2d">column\_formats</a>. For each specified annotation, the format will apply to all columns with that annotation unless custom <a href="/content/api/cpp/namespacegpudb#a80cc5d48102a25704f8b0f0ee2eace2d">column\_formats</a> for that annotation are specified. The parameter value must be formatted as a JSON string that is a map of column properties to their respective column formats, e.g., ' "date" : "%Y.%m.%d", "time" : "%H:%M:%S" '. Column formats are specified as a string of control characters and plain text. The supported control characters are 'Y', 'm', 'd', 'H', 'M', 'S', and 's', which follow the Linux 'strptime()' specification, as well as 's', which specifies seconds and fractional seconds (though the fractional component will be truncated past milliseconds). Formats for the 'date' annotation must include the 'Y', 'm', and 'd' control characters. Formats for the 'time' annotation must include the 'H', 'M', and either 'S' or 's' (but not both) control characters. Formats for the 'datetime' annotation meet both the 'date' and 'time' control character requirements. For example, '"datetime" : "%m/%d/%Y %H:%M:%S" ' would be used to write text as "05/04/2000 12:12:11" </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a292525e5cc5d55c1d533a8a68ac540aa">export\_records\_to\_files\_export\_ddl</a>: Save DDL to a separate file. The default value is 'false'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a1784384afe271dd876caf4104b3602ad">export\_records\_to\_files\_file\_extension</a>: Extension to give the export file. The default value is '.csv'. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ae343f022827db753ca975bb620a68c72">export\_records\_to\_files\_file\_type</a>: Specifies the file format to use when exporting data. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a7fd9e92cdf7edcedb122eda79d1f13b7">export\_records\_to\_files\_delimited\_text</a>: Delimited text file format; e.g., CSV, TSV, PSV, etc. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a4d03c225ef99286c4719984bb253732a">export\_records\_to\_files\_parquet</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a7fd9e92cdf7edcedb122eda79d1f13b7">export\_records\_to\_files\_delimited\_text</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#af0697cfd2c1577c5ef0616bcbbab65b1">export\_records\_to\_files\_kinetica\_header</a>: Whether to include a Kinetica proprietary header. Will not be written if <a href="/content/api/cpp/namespacegpudb#a3faa58c352fdc4691ca17df1eb7424d5">text\_has\_header</a> is <a href="/content/api/cpp/namespacegpudb#a79702cb212b875d1dbd2436e6fa3fedd">false</a>. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ac3cc4c6bcb1191615d2131282e88a705">export\_records\_to\_files\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a79702cb212b875d1dbd2436e6fa3fedd">export\_records\_to\_files\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a79702cb212b875d1dbd2436e6fa3fedd">export\_records\_to\_files\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a73491168861c16d238e6cf4103694e84">export\_records\_to\_files\_kinetica\_header\_delimiter</a>: If a Kinetica proprietary header is included, then specify a property separator. Different from column delimiter. The default value is '|'. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a0cdb3f69354a8137425d002809e6d55c">export\_records\_to\_files\_compression\_type</a>: File compression type. GZip can be applied to text and Parquet files. Snappy can only be applied to Parquet files, and is the default compression for them. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ae4994eb8f0b7caed6aee40abeba0ed54">export\_records\_to\_files\_uncompressed</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a5841c532b649c5e50185fdcc8a679edd">export\_records\_to\_files\_snappy</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a7220dff01023f4a08062f08a93c6d4c2">export\_records\_to\_files\_gzip</a> </li>
                      </ul>
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a4d18afbe3500ce71d8babb1f95803b8b">export\_records\_to\_files\_single\_file</a>: Save records to a single file. This option may be ignored if file size exceeds internal file size limits (this limit will differ on different targets). Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ac3cc4c6bcb1191615d2131282e88a705">export\_records\_to\_files\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a79702cb212b875d1dbd2436e6fa3fedd">export\_records\_to\_files\_false</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aadaf71f5f5355b13c499f42921e5033d">export\_records\_to\_files\_overwrite</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ac3cc4c6bcb1191615d2131282e88a705">export\_records\_to\_files\_true</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a1c6731f9d8dadde95c9e609f76c13679">export\_records\_to\_files\_single\_file\_max\_size</a>: Max file size (in MB) to allow saving to a single file. May be overridden by target limitations. The default value is ''. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ae9f98ebea697c9efa461d13ef4b5a6f4">export\_records\_to\_files\_text\_delimiter</a>: Specifies the character to write out to delimit field values and field names in the header (if present). For <a href="/content/api/cpp/namespacegpudb#a7fd9e92cdf7edcedb122eda79d1f13b7">delimited\_text</a> <a href="/content/api/cpp/namespacegpudb#ae343f022827db753ca975bb620a68c72">file\_type</a> only. The default value is ','. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a3faa58c352fdc4691ca17df1eb7424d5">export\_records\_to\_files\_text\_has\_header</a>: Indicates whether to write out a header row. For <a href="/content/api/cpp/namespacegpudb#a7fd9e92cdf7edcedb122eda79d1f13b7">delimited\_text</a><a href="/content/api/cpp/namespacegpudb#ae343f022827db753ca975bb620a68c72">file\_type</a> only. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ac3cc4c6bcb1191615d2131282e88a705">export\_records\_to\_files\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a79702cb212b875d1dbd2436e6fa3fedd">export\_records\_to\_files\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ac3cc4c6bcb1191615d2131282e88a705">export\_records\_to\_files\_true</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a0198b4ec45c63cb56d1585e99aa86dfe">export\_records\_to\_files\_text\_null\_string</a>: Specifies the character string that should be written out for the null value in the data. For <a href="/content/api/cpp/namespacegpudb#a7fd9e92cdf7edcedb122eda79d1f13b7">delimited\_text</a> <a href="/content/api/cpp/namespacegpudb#ae343f022827db753ca975bb620a68c72">file\_type</a> only. The default value is '\N'. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ExportRecordsToFilesResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ExportRecordsToFilesResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a63a3d3e6b0df86ad1a7cab47c9223904">◆ </a></span>exportRecordsToTable() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ExportRecordsToTableResponse">ExportRecordsToTableResponse</a> gpudb::GPUdb::exportRecordsToTable </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1ExportRecordsToTableRequest">ExportRecordsToTableRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Exports records from source table to the specified target table in an external database. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ExportRecordsToTableRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ExportRecordsToTableResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a19cc9e60db0a4e1464ab705dd22f7c4a">◆ </a></span>exportRecordsToTable() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ExportRecordsToTableResponse">ExportRecordsToTableResponse</a> & gpudb::GPUdb::exportRecordsToTable </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1ExportRecordsToTableRequest">ExportRecordsToTableRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1ExportRecordsToTableResponse">ExportRecordsToTableResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Exports records from source table to the specified target table in an external database. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ExportRecordsToTableRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ExportRecordsToTableResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ExportRecordsToTableResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a6e8f99e3e18f0dc268bd05fab42177b4">◆ </a></span>exportRecordsToTable() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ExportRecordsToTableResponse">ExportRecordsToTableResponse</a> gpudb::GPUdb::exportRecordsToTable </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>remoteQuery</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Exports records from source table to the specified target table in an external database. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of the table from which the data will be exported to remote database, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>remoteQuery</td>
                <td>Parameterized insert query to export gpudb table data into remote database. The default value is ''. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a85d205ffa986c9b4939c8cecccdefff9">export\_records\_to\_table\_batch\_size</a>: Batch size, which determines how many rows to export per round trip. The default value is '200000'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aa89ddb9c3c00aef1fc8e62bca0abcc76">export\_records\_to\_table\_datasink\_name</a>: Name of an existing external data sink to which table name specified in <span>tableName</span> will be exported. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ab0e8c4fce245b0147639fdd00d70705a">export\_records\_to\_table\_jdbc\_session\_init\_statement</a>: Executes the statement per each JDBC session before doing actual load. The default value is ''. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a1328bcfcd1e57695d54d30b64a08bd77">export\_records\_to\_table\_jdbc\_connection\_init\_statement</a>: Executes the statement once before doing actual load. The default value is ''. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#adf44285a6525ba4dfe899eb422c124f3">export\_records\_to\_table\_remote\_table</a>: Name of the target table to which source table is exported. When this option is specified remote\_query cannot be specified. The default value is ''. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#aa370c090a9d6859b66aa280d1bdbe448">export\_records\_to\_table\_use\_st\_geomfrom\_casts</a>: Wraps parameterized variables with st\_geomfromtext or st\_geomfromwkb based on source column type. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a2731835102f68fdecea5fc67c6ccb1db">export\_records\_to\_table\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a9e45af6d64023a232bdb904e6b7f5aca">export\_records\_to\_table\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a9e45af6d64023a232bdb904e6b7f5aca">export\_records\_to\_table\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ab9b4df6482422f94af6f70ed35943100">export\_records\_to\_table\_use\_indexed\_parameters</a>: Uses \$n style syntax when generating insert query for remote\_table option. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a2731835102f68fdecea5fc67c6ccb1db">export\_records\_to\_table\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a9e45af6d64023a232bdb904e6b7f5aca">export\_records\_to\_table\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a9e45af6d64023a232bdb904e6b7f5aca">export\_records\_to\_table\_false</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ExportRecordsToTableResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ae4b6afe4a9a67fa6eeba83b2f596afe4">◆ </a></span>exportRecordsToTable() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ExportRecordsToTableResponse">ExportRecordsToTableResponse</a> & gpudb::GPUdb::exportRecordsToTable </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>remoteQuery</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1ExportRecordsToTableResponse">ExportRecordsToTableResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Exports records from source table to the specified target table in an external database. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of the table from which the data will be exported to remote database, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>remoteQuery</td>
                <td>Parameterized insert query to export gpudb table data into remote database. The default value is ''. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a85d205ffa986c9b4939c8cecccdefff9">export\_records\_to\_table\_batch\_size</a>: Batch size, which determines how many rows to export per round trip. The default value is '200000'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aa89ddb9c3c00aef1fc8e62bca0abcc76">export\_records\_to\_table\_datasink\_name</a>: Name of an existing external data sink to which table name specified in <span>tableName</span> will be exported. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ab0e8c4fce245b0147639fdd00d70705a">export\_records\_to\_table\_jdbc\_session\_init\_statement</a>: Executes the statement per each JDBC session before doing actual load. The default value is ''. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a1328bcfcd1e57695d54d30b64a08bd77">export\_records\_to\_table\_jdbc\_connection\_init\_statement</a>: Executes the statement once before doing actual load. The default value is ''. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#adf44285a6525ba4dfe899eb422c124f3">export\_records\_to\_table\_remote\_table</a>: Name of the target table to which source table is exported. When this option is specified remote\_query cannot be specified. The default value is ''. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#aa370c090a9d6859b66aa280d1bdbe448">export\_records\_to\_table\_use\_st\_geomfrom\_casts</a>: Wraps parameterized variables with st\_geomfromtext or st\_geomfromwkb based on source column type. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a2731835102f68fdecea5fc67c6ccb1db">export\_records\_to\_table\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a9e45af6d64023a232bdb904e6b7f5aca">export\_records\_to\_table\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a9e45af6d64023a232bdb904e6b7f5aca">export\_records\_to\_table\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ab9b4df6482422f94af6f70ed35943100">export\_records\_to\_table\_use\_indexed\_parameters</a>: Uses \$n style syntax when generating insert query for remote\_table option. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a2731835102f68fdecea5fc67c6ccb1db">export\_records\_to\_table\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a9e45af6d64023a232bdb904e6b7f5aca">export\_records\_to\_table\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a9e45af6d64023a232bdb904e6b7f5aca">export\_records\_to\_table\_false</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ExportRecordsToTableResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ExportRecordsToTableResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ad975f31cd9d87d805ebb0513f652eca6">◆ </a></span>filter() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1FilterResponse">FilterResponse</a> gpudb::GPUdb::filter </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1FilterRequest">FilterRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Filters data based on the specified expression. </p>
        <p>The results are stored in a <a href="/content/concepts/filtered_views/">result set</a> with the given <a href="/content/api/cpp/structgpudb_1_1FilterRequest#a7a88abd6b2c66418fc3224690efbcd11">viewName</a>.</p>
        <p>For details see <a href="/content/concepts/expressions/">Expressions</a>.</p>
        <p>The response message contains the number of points for which the expression evaluated to be true, which is equivalent to the size of the result view.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1FilterRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1FilterResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a345135f1227d9d1576c3d30a997a258d">◆ </a></span>filter() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1FilterResponse">FilterResponse</a> & gpudb::GPUdb::filter </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1FilterRequest">FilterRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1FilterResponse">FilterResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Filters data based on the specified expression. </p>
        <p>The results are stored in a <a href="/content/concepts/filtered_views/">result set</a> with the given <a href="/content/api/cpp/structgpudb_1_1FilterRequest#a7a88abd6b2c66418fc3224690efbcd11">viewName</a>.</p>
        <p>For details see <a href="/content/concepts/expressions/">Expressions</a>.</p>
        <p>The response message contains the number of points for which the expression evaluated to be true, which is equivalent to the size of the result view.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1FilterRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1FilterResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1FilterResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ac5b65e73c01c331f1fcfb21b0e8d67ce">◆ </a></span>filter() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1FilterResponse">FilterResponse</a> gpudb::GPUdb::filter </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>viewName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>expression</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Filters data based on the specified expression. </p>
        <p>The results are stored in a <a href="/content/concepts/filtered_views/">result set</a> with the given <span>viewName</span>.</p>
        <p>For details see <a href="/content/concepts/expressions/">Expressions</a>.</p>
        <p>The response message contains the number of points for which the expression evaluated to be true, which is equivalent to the size of the result view.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of the table to filter, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. This may be the name of a table or a view (when chaining queries). </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>viewName</td>
                <td>If provided, then this will be the name of the view containing the results, in \[schema\_name.]view\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a> and meeting <a href="/content/concepts/tables/#table-naming-criteria">table naming criteria</a>. Must not be an already existing table or view. The default value is ''. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>expression</td>
                <td>The select expression to filter the specified table. For details see <a href="/content/concepts/expressions/">Expressions</a>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a1971f80bf1fcdb4621d3b041ef370ba5">filter\_create\_temp\_table</a>: If <a href="/content/api/cpp/namespacegpudb#a2a4b400ec6df130a22393344cd0c3320">true</a>, a unique temporary table name will be generated in the sys\_temp schema and used in place of <span>viewName</span>. This is always allowed even if the caller does not have permission to create tables. The generated name is returned in <a href="/content/api/cpp/namespacegpudb#a78930610ce1aebc6008c576a2cc7cc2c">qualified\_view\_name</a>. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a2a4b400ec6df130a22393344cd0c3320">filter\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aaff79a4ddba623ac0d20db43f399e8f4">filter\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#aaff79a4ddba623ac0d20db43f399e8f4">filter\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a9927509352a13c67d949a7f7b1b84422">filter\_collection\_name</a>: \[DEPRECATED–please specify the containing schema for the view as part of <span>viewName</span> and use <a href="#a33d9a0a8e738d14b688f9f869f9640ad">createSchema</a> to create the schema if non-existent] Name of a schema for the newly created view. If the schema is non-existent, it will be automatically created. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a311644db88d1ce29d716715519e4c474">filter\_view\_id</a>: View this filtered-view is part of. The default value is ''. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a92682542e63a9580e5bde8c728398e59">filter\_ttl</a>: Sets the <a href="/content/concepts/ttl/">TTL</a> of the view specified in <span>viewName</span>. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1FilterResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a98d8963830d3286bd2bbee4271a259b0">◆ </a></span>filter() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1FilterResponse">FilterResponse</a> & gpudb::GPUdb::filter </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>viewName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>expression</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1FilterResponse">FilterResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Filters data based on the specified expression. </p>
        <p>The results are stored in a <a href="/content/concepts/filtered_views/">result set</a> with the given <span>viewName</span>.</p>
        <p>For details see <a href="/content/concepts/expressions/">Expressions</a>.</p>
        <p>The response message contains the number of points for which the expression evaluated to be true, which is equivalent to the size of the result view.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of the table to filter, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. This may be the name of a table or a view (when chaining queries). </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>viewName</td>
                <td>If provided, then this will be the name of the view containing the results, in \[schema\_name.]view\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a> and meeting <a href="/content/concepts/tables/#table-naming-criteria">table naming criteria</a>. Must not be an already existing table or view. The default value is ''. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>expression</td>
                <td>The select expression to filter the specified table. For details see <a href="/content/concepts/expressions/">Expressions</a>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a1971f80bf1fcdb4621d3b041ef370ba5">filter\_create\_temp\_table</a>: If <a href="/content/api/cpp/namespacegpudb#a2a4b400ec6df130a22393344cd0c3320">true</a>, a unique temporary table name will be generated in the sys\_temp schema and used in place of <span>viewName</span>. This is always allowed even if the caller does not have permission to create tables. The generated name is returned in <a href="/content/api/cpp/namespacegpudb#a78930610ce1aebc6008c576a2cc7cc2c">qualified\_view\_name</a>. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a2a4b400ec6df130a22393344cd0c3320">filter\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aaff79a4ddba623ac0d20db43f399e8f4">filter\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#aaff79a4ddba623ac0d20db43f399e8f4">filter\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a9927509352a13c67d949a7f7b1b84422">filter\_collection\_name</a>: \[DEPRECATED–please specify the containing schema for the view as part of <span>viewName</span> and use <a href="#a33d9a0a8e738d14b688f9f869f9640ad">createSchema</a> to create the schema if non-existent] Name of a schema for the newly created view. If the schema is non-existent, it will be automatically created. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a311644db88d1ce29d716715519e4c474">filter\_view\_id</a>: View this filtered-view is part of. The default value is ''. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a92682542e63a9580e5bde8c728398e59">filter\_ttl</a>: Sets the <a href="/content/concepts/ttl/">TTL</a> of the view specified in <span>viewName</span>. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1FilterResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1FilterResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a65f7751d7d3b9a971ad0cb4f94a29826">◆ </a></span>filterByArea() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1FilterByAreaResponse">FilterByAreaResponse</a> gpudb::GPUdb::filterByArea </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1FilterByAreaRequest">FilterByAreaRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Calculates which objects from a table are within a named area of interest (NAI/polygon). </p>
        <p>The operation is synchronous, meaning that a response will not be returned until all the matching objects are fully available. The response payload provides the count of the resulting set. A new resultant set (view) which satisfies the input NAI restriction specification is created with the name <a href="/content/api/cpp/structgpudb_1_1FilterByAreaRequest#a93940a9b1516511491e4243b61504122">viewName</a> passed in as part of the input.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1FilterByAreaRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1FilterByAreaResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ab6356f6e151c19b722161d511cc7680b">◆ </a></span>filterByArea() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1FilterByAreaResponse">FilterByAreaResponse</a> & gpudb::GPUdb::filterByArea </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1FilterByAreaRequest">FilterByAreaRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1FilterByAreaResponse">FilterByAreaResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Calculates which objects from a table are within a named area of interest (NAI/polygon). </p>
        <p>The operation is synchronous, meaning that a response will not be returned until all the matching objects are fully available. The response payload provides the count of the resulting set. A new resultant set (view) which satisfies the input NAI restriction specification is created with the name <a href="/content/api/cpp/structgpudb_1_1FilterByAreaRequest#a93940a9b1516511491e4243b61504122">viewName</a> passed in as part of the input.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1FilterByAreaRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1FilterByAreaResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1FilterByAreaResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#aaf78a92abcaa5bfba493cdc0b79ff57e">◆ </a></span>filterByArea() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1FilterByAreaResponse">FilterByAreaResponse</a> gpudb::GPUdb::filterByArea </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>viewName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>xColumnName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< double > &</td>
            <td><span><span>xVector</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>yColumnName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< double > &</td>
            <td><span><span>yVector</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Calculates which objects from a table are within a named area of interest (NAI/polygon). </p>
        <p>The operation is synchronous, meaning that a response will not be returned until all the matching objects are fully available. The response payload provides the count of the resulting set. A new resultant set (view) which satisfies the input NAI restriction specification is created with the name <span>viewName</span> passed in as part of the input.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of the table to filter, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. This may be the name of a table or a view (when chaining queries). </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>viewName</td>
                <td>If provided, then this will be the name of the view containing the results, in \[schema\_name.]view\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a> and meeting <a href="/content/concepts/tables/#table-naming-criteria">table naming criteria</a>. Must not be an already existing table or view. The default value is ''. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>xColumnName</td>
                <td>Name of the column containing the x values to be filtered. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>xVector</td>
                <td>List of x coordinates of the vertices of the polygon representing the area to be filtered. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>yColumnName</td>
                <td>Name of the column containing the y values to be filtered. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>yVector</td>
                <td>List of y coordinates of the vertices of the polygon representing the area to be filtered. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a90557501474547f0e008db3ee4e73a0b">filter\_by\_area\_create\_temp\_table</a>: If <a href="/content/api/cpp/namespacegpudb#a7975d60480c00867e93920a69075e78d">true</a>, a unique temporary table name will be generated in the sys\_temp schema and used in place of <span>viewName</span>. This is always allowed even if the caller does not have permission to create tables. The generated name is returned in <a href="/content/api/cpp/namespacegpudb#a53c54b5f6305b17c432e8a1659f4d1c3">qualified\_view\_name</a>. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a7975d60480c00867e93920a69075e78d">filter\_by\_area\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#abe431c2d0a4a300607add95f6120c069">filter\_by\_area\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#abe431c2d0a4a300607add95f6120c069">filter\_by\_area\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#ab80a16ee54d5e1c028ee99aa6af0caf5">filter\_by\_area\_collection\_name</a>: \[DEPRECATED–please specify the containing schema for the view as part of <span>viewName</span> and use <a href="#a33d9a0a8e738d14b688f9f869f9640ad">createSchema</a> to create the schema if non-existent] Name of a schema for the newly created view. If the schema provided is non-existent, it will be automatically created. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1FilterByAreaResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a44e614f3e78963e8ec9da02bd2c86475">◆ </a></span>filterByArea() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1FilterByAreaResponse">FilterByAreaResponse</a> & gpudb::GPUdb::filterByArea </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>viewName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>xColumnName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< double > &</td>
            <td><span><span>xVector</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>yColumnName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< double > &</td>
            <td><span><span>yVector</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1FilterByAreaResponse">FilterByAreaResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Calculates which objects from a table are within a named area of interest (NAI/polygon). </p>
        <p>The operation is synchronous, meaning that a response will not be returned until all the matching objects are fully available. The response payload provides the count of the resulting set. A new resultant set (view) which satisfies the input NAI restriction specification is created with the name <span>viewName</span> passed in as part of the input.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of the table to filter, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. This may be the name of a table or a view (when chaining queries). </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>viewName</td>
                <td>If provided, then this will be the name of the view containing the results, in \[schema\_name.]view\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a> and meeting <a href="/content/concepts/tables/#table-naming-criteria">table naming criteria</a>. Must not be an already existing table or view. The default value is ''. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>xColumnName</td>
                <td>Name of the column containing the x values to be filtered. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>xVector</td>
                <td>List of x coordinates of the vertices of the polygon representing the area to be filtered. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>yColumnName</td>
                <td>Name of the column containing the y values to be filtered. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>yVector</td>
                <td>List of y coordinates of the vertices of the polygon representing the area to be filtered. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a90557501474547f0e008db3ee4e73a0b">filter\_by\_area\_create\_temp\_table</a>: If <a href="/content/api/cpp/namespacegpudb#a7975d60480c00867e93920a69075e78d">true</a>, a unique temporary table name will be generated in the sys\_temp schema and used in place of <span>viewName</span>. This is always allowed even if the caller does not have permission to create tables. The generated name is returned in <a href="/content/api/cpp/namespacegpudb#a53c54b5f6305b17c432e8a1659f4d1c3">qualified\_view\_name</a>. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a7975d60480c00867e93920a69075e78d">filter\_by\_area\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#abe431c2d0a4a300607add95f6120c069">filter\_by\_area\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#abe431c2d0a4a300607add95f6120c069">filter\_by\_area\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#ab80a16ee54d5e1c028ee99aa6af0caf5">filter\_by\_area\_collection\_name</a>: \[DEPRECATED–please specify the containing schema for the view as part of <span>viewName</span> and use <a href="#a33d9a0a8e738d14b688f9f869f9640ad">createSchema</a> to create the schema if non-existent] Name of a schema for the newly created view. If the schema provided is non-existent, it will be automatically created. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1FilterByAreaResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1FilterByAreaResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#aa47be462dde2c9491093a82f7ace9315">◆ </a></span>filterByAreaGeometry() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1FilterByAreaGeometryResponse">FilterByAreaGeometryResponse</a> gpudb::GPUdb::filterByAreaGeometry </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1FilterByAreaGeometryRequest">FilterByAreaGeometryRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Calculates which geospatial geometry objects from a table intersect a named area of interest (NAI/polygon). </p>
        <p>The operation is synchronous, meaning that a response will not be returned until all the matching objects are fully available. The response payload provides the count of the resulting set. A new resultant set (view) which satisfies the input NAI restriction specification is created with the name <a href="/content/api/cpp/structgpudb_1_1FilterByAreaGeometryRequest#ad88de38a16bc23672a2fceb47c02b20c">viewName</a> passed in as part of the input.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1FilterByAreaGeometryRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1FilterByAreaGeometryResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a06cbbea9c031b7d73dbbe5a25b1ed930">◆ </a></span>filterByAreaGeometry() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1FilterByAreaGeometryResponse">FilterByAreaGeometryResponse</a> & gpudb::GPUdb::filterByAreaGeometry </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1FilterByAreaGeometryRequest">FilterByAreaGeometryRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1FilterByAreaGeometryResponse">FilterByAreaGeometryResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Calculates which geospatial geometry objects from a table intersect a named area of interest (NAI/polygon). </p>
        <p>The operation is synchronous, meaning that a response will not be returned until all the matching objects are fully available. The response payload provides the count of the resulting set. A new resultant set (view) which satisfies the input NAI restriction specification is created with the name <a href="/content/api/cpp/structgpudb_1_1FilterByAreaGeometryRequest#ad88de38a16bc23672a2fceb47c02b20c">viewName</a> passed in as part of the input.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1FilterByAreaGeometryRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1FilterByAreaGeometryResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1FilterByAreaGeometryResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a04e87bd426d13ebca107834c29c420a9">◆ </a></span>filterByAreaGeometry() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1FilterByAreaGeometryResponse">FilterByAreaGeometryResponse</a> gpudb::GPUdb::filterByAreaGeometry </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>viewName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>columnName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< double > &</td>
            <td><span><span>xVector</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< double > &</td>
            <td><span><span>yVector</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Calculates which geospatial geometry objects from a table intersect a named area of interest (NAI/polygon). </p>
        <p>The operation is synchronous, meaning that a response will not be returned until all the matching objects are fully available. The response payload provides the count of the resulting set. A new resultant set (view) which satisfies the input NAI restriction specification is created with the name <span>viewName</span> passed in as part of the input.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of the table to filter, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. This may be the name of a table or a view (when chaining queries). </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>viewName</td>
                <td>If provided, then this will be the name of the view containing the results, in \[schema\_name.]view\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a> and meeting <a href="/content/concepts/tables/#table-naming-criteria">table naming criteria</a>. Must not be an already existing table or view. The default value is ''. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>columnName</td>
                <td>Name of the geospatial geometry column to be filtered. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>xVector</td>
                <td>List of x coordinates of the vertices of the polygon representing the area to be filtered. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>yVector</td>
                <td>List of y coordinates of the vertices of the polygon representing the area to be filtered. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a67c71f0594bf18fd38f271fcaf0e1dc7">filter\_by\_area\_geometry\_create\_temp\_table</a>: If <a href="/content/api/cpp/namespacegpudb#a359d4dfbdf710597f995711e7fb137a6">true</a>, a unique temporary table name will be generated in the sys\_temp schema and used in place of <span>viewName</span>. This is always allowed even if the caller does not have permission to create tables. The generated name is returned in <a href="/content/api/cpp/namespacegpudb#a2c04b9ff03256a37a96e70cc0a7bf5e0">qualified\_view\_name</a>. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a359d4dfbdf710597f995711e7fb137a6">filter\_by\_area\_geometry\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a5837c3f0b4bdc2aff34f43ce5df6a1cb">filter\_by\_area\_geometry\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a5837c3f0b4bdc2aff34f43ce5df6a1cb">filter\_by\_area\_geometry\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a934fd6d1c8e177fa13c71fef657b8381">filter\_by\_area\_geometry\_collection\_name</a>: \[DEPRECATED–please specify the containing schema for the view as part of <span>viewName</span> and use <a href="#a33d9a0a8e738d14b688f9f869f9640ad">createSchema</a> to create the schema if non-existent] The schema for the newly created view. If the schema is non-existent, it will be automatically created. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1FilterByAreaGeometryResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ad2099ed76a05134490875509eed4fa66">◆ </a></span>filterByAreaGeometry() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1FilterByAreaGeometryResponse">FilterByAreaGeometryResponse</a> & gpudb::GPUdb::filterByAreaGeometry </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>viewName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>columnName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< double > &</td>
            <td><span><span>xVector</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< double > &</td>
            <td><span><span>yVector</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1FilterByAreaGeometryResponse">FilterByAreaGeometryResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Calculates which geospatial geometry objects from a table intersect a named area of interest (NAI/polygon). </p>
        <p>The operation is synchronous, meaning that a response will not be returned until all the matching objects are fully available. The response payload provides the count of the resulting set. A new resultant set (view) which satisfies the input NAI restriction specification is created with the name <span>viewName</span> passed in as part of the input.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of the table to filter, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. This may be the name of a table or a view (when chaining queries). </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>viewName</td>
                <td>If provided, then this will be the name of the view containing the results, in \[schema\_name.]view\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a> and meeting <a href="/content/concepts/tables/#table-naming-criteria">table naming criteria</a>. Must not be an already existing table or view. The default value is ''. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>columnName</td>
                <td>Name of the geospatial geometry column to be filtered. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>xVector</td>
                <td>List of x coordinates of the vertices of the polygon representing the area to be filtered. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>yVector</td>
                <td>List of y coordinates of the vertices of the polygon representing the area to be filtered. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a67c71f0594bf18fd38f271fcaf0e1dc7">filter\_by\_area\_geometry\_create\_temp\_table</a>: If <a href="/content/api/cpp/namespacegpudb#a359d4dfbdf710597f995711e7fb137a6">true</a>, a unique temporary table name will be generated in the sys\_temp schema and used in place of <span>viewName</span>. This is always allowed even if the caller does not have permission to create tables. The generated name is returned in <a href="/content/api/cpp/namespacegpudb#a2c04b9ff03256a37a96e70cc0a7bf5e0">qualified\_view\_name</a>. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a359d4dfbdf710597f995711e7fb137a6">filter\_by\_area\_geometry\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a5837c3f0b4bdc2aff34f43ce5df6a1cb">filter\_by\_area\_geometry\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a5837c3f0b4bdc2aff34f43ce5df6a1cb">filter\_by\_area\_geometry\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a934fd6d1c8e177fa13c71fef657b8381">filter\_by\_area\_geometry\_collection\_name</a>: \[DEPRECATED–please specify the containing schema for the view as part of <span>viewName</span> and use <a href="#a33d9a0a8e738d14b688f9f869f9640ad">createSchema</a> to create the schema if non-existent] The schema for the newly created view. If the schema is non-existent, it will be automatically created. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1FilterByAreaGeometryResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1FilterByAreaGeometryResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a7ff600263469d50ac759bc5c458448f5">◆ </a></span>filterByBox() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1FilterByBoxResponse">FilterByBoxResponse</a> gpudb::GPUdb::filterByBox </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1FilterByBoxRequest">FilterByBoxRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Calculates how many objects within the given table lie in a rectangular box. </p>
        <p>The operation is synchronous, meaning that a response will not be returned until all the objects are fully available. The response payload provides the count of the resulting set. A new resultant set which satisfies the input NAI restriction specification is also created when a <a href="/content/api/cpp/structgpudb_1_1FilterByBoxRequest#a62be88463b11f3ff31fe175a76623cbd">viewName</a> is passed in as part of the input payload.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1FilterByBoxRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1FilterByBoxResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a30b08ec7f60291ea463b36f40ff6369e">◆ </a></span>filterByBox() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1FilterByBoxResponse">FilterByBoxResponse</a> & gpudb::GPUdb::filterByBox </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1FilterByBoxRequest">FilterByBoxRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1FilterByBoxResponse">FilterByBoxResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Calculates how many objects within the given table lie in a rectangular box. </p>
        <p>The operation is synchronous, meaning that a response will not be returned until all the objects are fully available. The response payload provides the count of the resulting set. A new resultant set which satisfies the input NAI restriction specification is also created when a <a href="/content/api/cpp/structgpudb_1_1FilterByBoxRequest#a62be88463b11f3ff31fe175a76623cbd">viewName</a> is passed in as part of the input payload.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1FilterByBoxRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1FilterByBoxResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1FilterByBoxResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a3bd9f66e3c922c0e6332cd45d7c788dd">◆ </a></span>filterByBox() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1FilterByBoxResponse">FilterByBoxResponse</a> gpudb::GPUdb::filterByBox </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>viewName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>xColumnName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const double</td>
            <td><span><span>minX</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const double</td>
            <td><span><span>maxX</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>yColumnName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const double</td>
            <td><span><span>minY</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const double</td>
            <td><span><span>maxY</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Calculates how many objects within the given table lie in a rectangular box. </p>
        <p>The operation is synchronous, meaning that a response will not be returned until all the objects are fully available. The response payload provides the count of the resulting set. A new resultant set which satisfies the input NAI restriction specification is also created when a <span>viewName</span> is passed in as part of the input payload.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of the table on which the bounding box operation will be performed, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. Must be an existing table. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>viewName</td>
                <td>If provided, then this will be the name of the view containing the results, in \[schema\_name.]view\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a> and meeting <a href="/content/concepts/tables/#table-naming-criteria">table naming criteria</a>. Must not be an already existing table or view. The default value is ''. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>xColumnName</td>
                <td>Name of the column on which to perform the bounding box query. Must be a valid numeric column. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>minX</td>
                <td>Lower bound for the column chosen by <span>xColumnName</span>. Must be less than or equal to <span>maxX</span>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>maxX</td>
                <td>Upper bound for <span>xColumnName</span>. Must be greater than or equal to <span>minX</span>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>yColumnName</td>
                <td>Name of a column on which to perform the bounding box query. Must be a valid numeric column. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>minY</td>
                <td>Lower bound for <span>yColumnName</span>. Must be less than or equal to <span>maxY</span>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>maxY</td>
                <td>Upper bound for <span>yColumnName</span>. Must be greater than or equal to <span>minY</span>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ae595d73aad1d655a91b33106d3f75d74">filter\_by\_box\_create\_temp\_table</a>: If <a href="/content/api/cpp/namespacegpudb#a63e4b3d687604e8a03429bbc4bfcfe60">true</a>, a unique temporary table name will be generated in the sys\_temp schema and used in place of <span>viewName</span>. This is always allowed even if the caller does not have permission to create tables. The generated name is returned in <a href="/content/api/cpp/namespacegpudb#a482f294702a8be3134d7f42bae29e641">qualified\_view\_name</a>. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a63e4b3d687604e8a03429bbc4bfcfe60">filter\_by\_box\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a301b3dfa60b64268b35fbd415e5943a7">filter\_by\_box\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a301b3dfa60b64268b35fbd415e5943a7">filter\_by\_box\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a3aa1e81a8a2a8d3e0186a915f0d6aec9">filter\_by\_box\_collection\_name</a>: \[DEPRECATED–please specify the containing schema for the view as part of <span>viewName</span> and use <a href="#a33d9a0a8e738d14b688f9f869f9640ad">createSchema</a> to create the schema if non-existent] Name of a schema for the newly created view. If the schema is non-existent, it will be automatically created. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1FilterByBoxResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a989bf054ca50099e75b1cfe306d9a64b">◆ </a></span>filterByBox() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1FilterByBoxResponse">FilterByBoxResponse</a> & gpudb::GPUdb::filterByBox </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>viewName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>xColumnName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const double</td>
            <td><span><span>minX</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const double</td>
            <td><span><span>maxX</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>yColumnName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const double</td>
            <td><span><span>minY</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const double</td>
            <td><span><span>maxY</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1FilterByBoxResponse">FilterByBoxResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Calculates how many objects within the given table lie in a rectangular box. </p>
        <p>The operation is synchronous, meaning that a response will not be returned until all the objects are fully available. The response payload provides the count of the resulting set. A new resultant set which satisfies the input NAI restriction specification is also created when a <span>viewName</span> is passed in as part of the input payload.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of the table on which the bounding box operation will be performed, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. Must be an existing table. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>viewName</td>
                <td>If provided, then this will be the name of the view containing the results, in \[schema\_name.]view\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a> and meeting <a href="/content/concepts/tables/#table-naming-criteria">table naming criteria</a>. Must not be an already existing table or view. The default value is ''. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>xColumnName</td>
                <td>Name of the column on which to perform the bounding box query. Must be a valid numeric column. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>minX</td>
                <td>Lower bound for the column chosen by <span>xColumnName</span>. Must be less than or equal to <span>maxX</span>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>maxX</td>
                <td>Upper bound for <span>xColumnName</span>. Must be greater than or equal to <span>minX</span>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>yColumnName</td>
                <td>Name of a column on which to perform the bounding box query. Must be a valid numeric column. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>minY</td>
                <td>Lower bound for <span>yColumnName</span>. Must be less than or equal to <span>maxY</span>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>maxY</td>
                <td>Upper bound for <span>yColumnName</span>. Must be greater than or equal to <span>minY</span>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ae595d73aad1d655a91b33106d3f75d74">filter\_by\_box\_create\_temp\_table</a>: If <a href="/content/api/cpp/namespacegpudb#a63e4b3d687604e8a03429bbc4bfcfe60">true</a>, a unique temporary table name will be generated in the sys\_temp schema and used in place of <span>viewName</span>. This is always allowed even if the caller does not have permission to create tables. The generated name is returned in <a href="/content/api/cpp/namespacegpudb#a482f294702a8be3134d7f42bae29e641">qualified\_view\_name</a>. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a63e4b3d687604e8a03429bbc4bfcfe60">filter\_by\_box\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a301b3dfa60b64268b35fbd415e5943a7">filter\_by\_box\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a301b3dfa60b64268b35fbd415e5943a7">filter\_by\_box\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a3aa1e81a8a2a8d3e0186a915f0d6aec9">filter\_by\_box\_collection\_name</a>: \[DEPRECATED–please specify the containing schema for the view as part of <span>viewName</span> and use <a href="#a33d9a0a8e738d14b688f9f869f9640ad">createSchema</a> to create the schema if non-existent] Name of a schema for the newly created view. If the schema is non-existent, it will be automatically created. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1FilterByBoxResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1FilterByBoxResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a91e87e0190250bf93d78ae3560a2cd01">◆ </a></span>filterByBoxGeometry() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1FilterByBoxGeometryResponse">FilterByBoxGeometryResponse</a> gpudb::GPUdb::filterByBoxGeometry </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1FilterByBoxGeometryRequest">FilterByBoxGeometryRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Calculates which geospatial geometry objects from a table intersect a rectangular box. </p>
        <p>The operation is synchronous, meaning that a response will not be returned until all the objects are fully available. The response payload provides the count of the resulting set. A new resultant set which satisfies the input NAI restriction specification is also created when a <a href="/content/api/cpp/structgpudb_1_1FilterByBoxGeometryRequest#a17e14a579223c001a6a937564ff17202">viewName</a> is passed in as part of the input payload.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1FilterByBoxGeometryRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1FilterByBoxGeometryResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ac9b5f5edd838415599ee4c013ca6ac38">◆ </a></span>filterByBoxGeometry() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1FilterByBoxGeometryResponse">FilterByBoxGeometryResponse</a> & gpudb::GPUdb::filterByBoxGeometry </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1FilterByBoxGeometryRequest">FilterByBoxGeometryRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1FilterByBoxGeometryResponse">FilterByBoxGeometryResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Calculates which geospatial geometry objects from a table intersect a rectangular box. </p>
        <p>The operation is synchronous, meaning that a response will not be returned until all the objects are fully available. The response payload provides the count of the resulting set. A new resultant set which satisfies the input NAI restriction specification is also created when a <a href="/content/api/cpp/structgpudb_1_1FilterByBoxGeometryRequest#a17e14a579223c001a6a937564ff17202">viewName</a> is passed in as part of the input payload.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1FilterByBoxGeometryRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1FilterByBoxGeometryResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1FilterByBoxGeometryResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a9d0f8bc3e06532e682f2db0189a35e7f">◆ </a></span>filterByBoxGeometry() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1FilterByBoxGeometryResponse">FilterByBoxGeometryResponse</a> gpudb::GPUdb::filterByBoxGeometry </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>viewName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>columnName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const double</td>
            <td><span><span>minX</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const double</td>
            <td><span><span>maxX</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const double</td>
            <td><span><span>minY</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const double</td>
            <td><span><span>maxY</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Calculates which geospatial geometry objects from a table intersect a rectangular box. </p>
        <p>The operation is synchronous, meaning that a response will not be returned until all the objects are fully available. The response payload provides the count of the resulting set. A new resultant set which satisfies the input NAI restriction specification is also created when a <span>viewName</span> is passed in as part of the input payload.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of the table on which the bounding box operation will be performed, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. Must be an existing table. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>viewName</td>
                <td>If provided, then this will be the name of the view containing the results, in \[schema\_name.]view\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a> and meeting <a href="/content/concepts/tables/#table-naming-criteria">table naming criteria</a>. Must not be an already existing table or view. The default value is ''. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>columnName</td>
                <td>Name of the geospatial geometry column to be filtered. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>minX</td>
                <td>Lower bound for the x-coordinate of the rectangular box. Must be less than or equal to <span>maxX</span>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>maxX</td>
                <td>Upper bound for the x-coordinate of the rectangular box. Must be greater than or equal to <span>minX</span>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>minY</td>
                <td>Lower bound for the y-coordinate of the rectangular box. Must be less than or equal to <span>maxY</span>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>maxY</td>
                <td>Upper bound for the y-coordinate of the rectangular box. Must be greater than or equal to <span>minY</span>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ade69e2147199c97a8271aeeb33779a6b">filter\_by\_box\_geometry\_create\_temp\_table</a>: If <a href="/content/api/cpp/namespacegpudb#a61c808fe40db3b19410125144bdc5185">true</a>, a unique temporary table name will be generated in the sys\_temp schema and used in place of <span>viewName</span>. This is always allowed even if the caller does not have permission to create tables. The generated name is returned in <a href="/content/api/cpp/namespacegpudb#afba26004068e9fe4c453ac989e3b7c8c">qualified\_view\_name</a>. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a61c808fe40db3b19410125144bdc5185">filter\_by\_box\_geometry\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a7c911783f3572fd6eb93f72f2523f86c">filter\_by\_box\_geometry\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a7c911783f3572fd6eb93f72f2523f86c">filter\_by\_box\_geometry\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a86aca3a0fd58864c8b5c790e55e60275">filter\_by\_box\_geometry\_collection\_name</a>: \[DEPRECATED–please specify the containing schema for the view as part of <span>viewName</span> and use <a href="#a33d9a0a8e738d14b688f9f869f9640ad">createSchema</a> to create the schema if non-existent] Name of a schema for the newly created view. If the schema provided is non-existent, it will be automatically created. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1FilterByBoxGeometryResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a758e0f01ae576cd1fac86557617d8d7d">◆ </a></span>filterByBoxGeometry() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1FilterByBoxGeometryResponse">FilterByBoxGeometryResponse</a> & gpudb::GPUdb::filterByBoxGeometry </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>viewName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>columnName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const double</td>
            <td><span><span>minX</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const double</td>
            <td><span><span>maxX</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const double</td>
            <td><span><span>minY</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const double</td>
            <td><span><span>maxY</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1FilterByBoxGeometryResponse">FilterByBoxGeometryResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Calculates which geospatial geometry objects from a table intersect a rectangular box. </p>
        <p>The operation is synchronous, meaning that a response will not be returned until all the objects are fully available. The response payload provides the count of the resulting set. A new resultant set which satisfies the input NAI restriction specification is also created when a <span>viewName</span> is passed in as part of the input payload.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of the table on which the bounding box operation will be performed, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. Must be an existing table. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>viewName</td>
                <td>If provided, then this will be the name of the view containing the results, in \[schema\_name.]view\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a> and meeting <a href="/content/concepts/tables/#table-naming-criteria">table naming criteria</a>. Must not be an already existing table or view. The default value is ''. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>columnName</td>
                <td>Name of the geospatial geometry column to be filtered. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>minX</td>
                <td>Lower bound for the x-coordinate of the rectangular box. Must be less than or equal to <span>maxX</span>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>maxX</td>
                <td>Upper bound for the x-coordinate of the rectangular box. Must be greater than or equal to <span>minX</span>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>minY</td>
                <td>Lower bound for the y-coordinate of the rectangular box. Must be less than or equal to <span>maxY</span>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>maxY</td>
                <td>Upper bound for the y-coordinate of the rectangular box. Must be greater than or equal to <span>minY</span>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ade69e2147199c97a8271aeeb33779a6b">filter\_by\_box\_geometry\_create\_temp\_table</a>: If <a href="/content/api/cpp/namespacegpudb#a61c808fe40db3b19410125144bdc5185">true</a>, a unique temporary table name will be generated in the sys\_temp schema and used in place of <span>viewName</span>. This is always allowed even if the caller does not have permission to create tables. The generated name is returned in <a href="/content/api/cpp/namespacegpudb#afba26004068e9fe4c453ac989e3b7c8c">qualified\_view\_name</a>. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a61c808fe40db3b19410125144bdc5185">filter\_by\_box\_geometry\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a7c911783f3572fd6eb93f72f2523f86c">filter\_by\_box\_geometry\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a7c911783f3572fd6eb93f72f2523f86c">filter\_by\_box\_geometry\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a86aca3a0fd58864c8b5c790e55e60275">filter\_by\_box\_geometry\_collection\_name</a>: \[DEPRECATED–please specify the containing schema for the view as part of <span>viewName</span> and use <a href="#a33d9a0a8e738d14b688f9f869f9640ad">createSchema</a> to create the schema if non-existent] Name of a schema for the newly created view. If the schema provided is non-existent, it will be automatically created. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1FilterByBoxGeometryResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1FilterByBoxGeometryResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a1bebed28c75d07732fb9ad15f64c58ff">◆ </a></span>filterByGeometry() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1FilterByGeometryResponse">FilterByGeometryResponse</a> gpudb::GPUdb::filterByGeometry </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1FilterByGeometryRequest">FilterByGeometryRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Applies a geometry filter against a geospatial geometry column in a given table or view. </p>
        <p>The filtering geometry is provided by <a href="/content/api/cpp/structgpudb_1_1FilterByGeometryRequest#ac5b2052fb73c01f70a130844001a0f26">inputWkt</a>.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1FilterByGeometryRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1FilterByGeometryResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a323acd0004c11a55be16b40ab91818ba">◆ </a></span>filterByGeometry() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1FilterByGeometryResponse">FilterByGeometryResponse</a> & gpudb::GPUdb::filterByGeometry </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1FilterByGeometryRequest">FilterByGeometryRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1FilterByGeometryResponse">FilterByGeometryResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Applies a geometry filter against a geospatial geometry column in a given table or view. </p>
        <p>The filtering geometry is provided by <a href="/content/api/cpp/structgpudb_1_1FilterByGeometryRequest#ac5b2052fb73c01f70a130844001a0f26">inputWkt</a>.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1FilterByGeometryRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1FilterByGeometryResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1FilterByGeometryResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a922116bd986d005f07507a265332b9eb">◆ </a></span>filterByGeometry() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1FilterByGeometryResponse">FilterByGeometryResponse</a> gpudb::GPUdb::filterByGeometry </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>viewName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>columnName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>inputWkt</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>operation</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Applies a geometry filter against a geospatial geometry column in a given table or view. </p>
        <p>The filtering geometry is provided by <span>inputWkt</span>.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of the table on which the filter by geometry will be performed, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. Must be an existing table or view containing a geospatial geometry column. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>viewName</td>
                <td>If provided, then this will be the name of the view containing the results, in \[schema\_name.]view\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a> and meeting <a href="/content/concepts/tables/#table-naming-criteria">table naming criteria</a>. Must not be an already existing table or view. The default value is ''. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>columnName</td>
                <td>Name of the column to be used in the filter. Must be a geospatial geometry column. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>inputWkt</td>
                <td>A geometry in WKT format that will be used to filter the objects in <span>tableName</span>. The default value is ''. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>operation</td>

                <td>
                  The geometric filtering operation to perform. Supported values:

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a18e75efa3105b3114b5c1b9c2224528b">filter\_by\_geometry\_contains</a>: Matches records that contain the given WKT in <span>inputWkt</span>, i.e. the given WKT is within the bounds of a record's geometry. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ae5410af2df2a4359ea7dfc6ed0d3736c">filter\_by\_geometry\_crosses</a>: Matches records that cross the given WKT. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a87414b24a199a8fa5ac7d0ccc57033bb">filter\_by\_geometry\_disjoint</a>: Matches records that are disjoint from the given WKT. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#acacd71c688c482644014669610e042c3">filter\_by\_geometry\_equals</a>: Matches records that are the same as the given WKT. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a254198784ee441bb1d3b45ff09bb95cc">filter\_by\_geometry\_intersects</a>: Matches records that intersect the given WKT. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a345259ee649acdc91f1313ef42201a8a">filter\_by\_geometry\_overlaps</a>: Matches records that overlap the given WKT. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a3c945c89b5659cf94c8b0a103eff19e1">filter\_by\_geometry\_touches</a>: Matches records that touch the given WKT. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#abb1a55908096c5b6022e015d15ed33bc">filter\_by\_geometry\_within</a>: Matches records that are within the given WKT. </li>
                  </ul>
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a430928cbcd28d8d3a637fa75fa015e2c">filter\_by\_geometry\_create\_temp\_table</a>: If <a href="/content/api/cpp/namespacegpudb#ad7b3f4f8483d75ee765eb47f5c3b6e8d">true</a>, a unique temporary table name will be generated in the sys\_temp schema and used in place of <span>viewName</span>. This is always allowed even if the caller does not have permission to create tables. The generated name is returned in <a href="/content/api/cpp/namespacegpudb#a40240a9667fc9afc3e67d97cf0304d12">qualified\_view\_name</a>. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad7b3f4f8483d75ee765eb47f5c3b6e8d">filter\_by\_geometry\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a7f1cefd18f30094ac2f8e99e3f0bfca3">filter\_by\_geometry\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a7f1cefd18f30094ac2f8e99e3f0bfca3">filter\_by\_geometry\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#ac38f8500129dfc84e3e0e1607c3b9ef5">filter\_by\_geometry\_collection\_name</a>: \[DEPRECATED–please specify the containing schema for the view as part of <span>viewName</span> and use <a href="#a33d9a0a8e738d14b688f9f869f9640ad">createSchema</a> to create the schema if non-existent] Name of a schema for the newly created view. If the schema provided is non-existent, it will be automatically created. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1FilterByGeometryResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a77c2a9d3b73e4bd4966bf2fe5e85e1cc">◆ </a></span>filterByGeometry() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1FilterByGeometryResponse">FilterByGeometryResponse</a> & gpudb::GPUdb::filterByGeometry </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>viewName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>columnName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>inputWkt</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>operation</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1FilterByGeometryResponse">FilterByGeometryResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Applies a geometry filter against a geospatial geometry column in a given table or view. </p>
        <p>The filtering geometry is provided by <span>inputWkt</span>.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of the table on which the filter by geometry will be performed, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. Must be an existing table or view containing a geospatial geometry column. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>viewName</td>
                <td>If provided, then this will be the name of the view containing the results, in \[schema\_name.]view\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a> and meeting <a href="/content/concepts/tables/#table-naming-criteria">table naming criteria</a>. Must not be an already existing table or view. The default value is ''. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>columnName</td>
                <td>Name of the column to be used in the filter. Must be a geospatial geometry column. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>inputWkt</td>
                <td>A geometry in WKT format that will be used to filter the objects in <span>tableName</span>. The default value is ''. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>operation</td>

                <td>
                  The geometric filtering operation to perform. Supported values:

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a18e75efa3105b3114b5c1b9c2224528b">filter\_by\_geometry\_contains</a>: Matches records that contain the given WKT in <span>inputWkt</span>, i.e. the given WKT is within the bounds of a record's geometry. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ae5410af2df2a4359ea7dfc6ed0d3736c">filter\_by\_geometry\_crosses</a>: Matches records that cross the given WKT. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a87414b24a199a8fa5ac7d0ccc57033bb">filter\_by\_geometry\_disjoint</a>: Matches records that are disjoint from the given WKT. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#acacd71c688c482644014669610e042c3">filter\_by\_geometry\_equals</a>: Matches records that are the same as the given WKT. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a254198784ee441bb1d3b45ff09bb95cc">filter\_by\_geometry\_intersects</a>: Matches records that intersect the given WKT. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a345259ee649acdc91f1313ef42201a8a">filter\_by\_geometry\_overlaps</a>: Matches records that overlap the given WKT. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a3c945c89b5659cf94c8b0a103eff19e1">filter\_by\_geometry\_touches</a>: Matches records that touch the given WKT. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#abb1a55908096c5b6022e015d15ed33bc">filter\_by\_geometry\_within</a>: Matches records that are within the given WKT. </li>
                  </ul>
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a430928cbcd28d8d3a637fa75fa015e2c">filter\_by\_geometry\_create\_temp\_table</a>: If <a href="/content/api/cpp/namespacegpudb#ad7b3f4f8483d75ee765eb47f5c3b6e8d">true</a>, a unique temporary table name will be generated in the sys\_temp schema and used in place of <span>viewName</span>. This is always allowed even if the caller does not have permission to create tables. The generated name is returned in <a href="/content/api/cpp/namespacegpudb#a40240a9667fc9afc3e67d97cf0304d12">qualified\_view\_name</a>. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad7b3f4f8483d75ee765eb47f5c3b6e8d">filter\_by\_geometry\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a7f1cefd18f30094ac2f8e99e3f0bfca3">filter\_by\_geometry\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a7f1cefd18f30094ac2f8e99e3f0bfca3">filter\_by\_geometry\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#ac38f8500129dfc84e3e0e1607c3b9ef5">filter\_by\_geometry\_collection\_name</a>: \[DEPRECATED–please specify the containing schema for the view as part of <span>viewName</span> and use <a href="#a33d9a0a8e738d14b688f9f869f9640ad">createSchema</a> to create the schema if non-existent] Name of a schema for the newly created view. If the schema provided is non-existent, it will be automatically created. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1FilterByGeometryResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1FilterByGeometryResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a16572195af55d6e7b2b6f267977998ec">◆ </a></span>filterByList() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1FilterByListResponse">FilterByListResponse</a> gpudb::GPUdb::filterByList </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1FilterByListRequest">FilterByListRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Calculates which records from a table have values in the given list for the corresponding column. </p>
        <p>The operation is synchronous, meaning that a response will not be returned until all the objects are fully available. The response payload provides the count of the resulting set. A new resultant set (view) which satisfies the input filter specification is also created if a <a href="/content/api/cpp/structgpudb_1_1FilterByListRequest#a99d3aaa6bd9b135d4b7c05f28dc2077a">viewName</a> is passed in as part of the request.</p>
        <p>For example, if a type definition has the columns 'x' and 'y', then a filter by list query with the column map "x":\["10.1", "2.3"], "y":\["0.0", "-31.5", "42.0"] will return the count of all data points whose x and y values match both in the respective x- and y-lists, e.g., "x = 10.1 and y = 0.0", "x = 2.3 and y = -31.5", etc. However, a record with "x = 10.1 and y = -31.5" or "x = 2.3 and y = 0.0" would not be returned because the values in the given lists do not correspond.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1FilterByListRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1FilterByListResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ac2e4d574684346f53d2662ff3f7b868d">◆ </a></span>filterByList() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1FilterByListResponse">FilterByListResponse</a> & gpudb::GPUdb::filterByList </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1FilterByListRequest">FilterByListRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1FilterByListResponse">FilterByListResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Calculates which records from a table have values in the given list for the corresponding column. </p>
        <p>The operation is synchronous, meaning that a response will not be returned until all the objects are fully available. The response payload provides the count of the resulting set. A new resultant set (view) which satisfies the input filter specification is also created if a <a href="/content/api/cpp/structgpudb_1_1FilterByListRequest#a99d3aaa6bd9b135d4b7c05f28dc2077a">viewName</a> is passed in as part of the request.</p>
        <p>For example, if a type definition has the columns 'x' and 'y', then a filter by list query with the column map "x":\["10.1", "2.3"], "y":\["0.0", "-31.5", "42.0"] will return the count of all data points whose x and y values match both in the respective x- and y-lists, e.g., "x = 10.1 and y = 0.0", "x = 2.3 and y = -31.5", etc. However, a record with "x = 10.1 and y = -31.5" or "x = 2.3 and y = 0.0" would not be returned because the values in the given lists do not correspond.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1FilterByListRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1FilterByListResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1FilterByListResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a2c1c1d116e1600a9426bd20f9d1ac425">◆ </a></span>filterByList() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1FilterByListResponse">FilterByListResponse</a> gpudb::GPUdb::filterByList </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>viewName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::vector\< std::string > > &</td>
            <td><span><span>columnValuesMap</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Calculates which records from a table have values in the given list for the corresponding column. </p>
        <p>The operation is synchronous, meaning that a response will not be returned until all the objects are fully available. The response payload provides the count of the resulting set. A new resultant set (view) which satisfies the input filter specification is also created if a <span>viewName</span> is passed in as part of the request.</p>
        <p>For example, if a type definition has the columns 'x' and 'y', then a filter by list query with the column map "x":\["10.1", "2.3"], "y":\["0.0", "-31.5", "42.0"] will return the count of all data points whose x and y values match both in the respective x- and y-lists, e.g., "x = 10.1 and y = 0.0", "x = 2.3 and y = -31.5", etc. However, a record with "x = 10.1 and y = -31.5" or "x = 2.3 and y = 0.0" would not be returned because the values in the given lists do not correspond.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of the table to filter, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. This may be the name of a table or a view (when chaining queries). </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>viewName</td>
                <td>If provided, then this will be the name of the view containing the results, in \[schema\_name.]view\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a> and meeting <a href="/content/concepts/tables/#table-naming-criteria">table naming criteria</a>. Must not be an already existing table or view. The default value is ''. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>columnValuesMap</td>
                <td>List of values for the corresponding column in the table. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a331703b68b6d54274c36694d3d4a6012">filter\_by\_list\_create\_temp\_table</a>: If <a href="/content/api/cpp/namespacegpudb#a496dc5055a6a4c6e4a21d62a5d1bf325">true</a>, a unique temporary table name will be generated in the sys\_temp schema and used in place of <span>viewName</span>. This is always allowed even if the caller does not have permission to create tables. The generated name is returned in <a href="/content/api/cpp/namespacegpudb#a00006e78b0ee84b2fc798cc5ed0df4fa">qualified\_view\_name</a>. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a496dc5055a6a4c6e4a21d62a5d1bf325">filter\_by\_list\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad85b11509308fd3f17c4cb162f838d90">filter\_by\_list\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ad85b11509308fd3f17c4cb162f838d90">filter\_by\_list\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a8354d9ff3b7fe5203feb37a50d34d0ac">filter\_by\_list\_collection\_name</a>: \[DEPRECATED–please specify the containing schema for the view as part of <span>viewName</span> and use <a href="#a33d9a0a8e738d14b688f9f869f9640ad">createSchema</a> to create the schema if non-existent] Name of a schema for the newly created view. If the schema provided is non-existent, it will be automatically created. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#adf952c68d6b5c8ad029210bbfaa31ce7">filter\_by\_list\_filter\_mode</a>: String indicating the filter mode, either 'in\_list' or 'not\_in\_list'. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a9499e74b3ac23a5d97e7200eea0a9063">filter\_by\_list\_in\_list</a>: The filter will match all items that are in the provided list(s). </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a8d53ccbffeb5a28fd7ed28cc10596b6c">filter\_by\_list\_not\_in\_list</a>: The filter will match all items that are not in the provided list(s). </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a9499e74b3ac23a5d97e7200eea0a9063">filter\_by\_list\_in\_list</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1FilterByListResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ad46d13e6efcd003b0877462de256703a">◆ </a></span>filterByList() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1FilterByListResponse">FilterByListResponse</a> & gpudb::GPUdb::filterByList </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>viewName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::vector\< std::string > > &</td>
            <td><span><span>columnValuesMap</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1FilterByListResponse">FilterByListResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Calculates which records from a table have values in the given list for the corresponding column. </p>
        <p>The operation is synchronous, meaning that a response will not be returned until all the objects are fully available. The response payload provides the count of the resulting set. A new resultant set (view) which satisfies the input filter specification is also created if a <span>viewName</span> is passed in as part of the request.</p>
        <p>For example, if a type definition has the columns 'x' and 'y', then a filter by list query with the column map "x":\["10.1", "2.3"], "y":\["0.0", "-31.5", "42.0"] will return the count of all data points whose x and y values match both in the respective x- and y-lists, e.g., "x = 10.1 and y = 0.0", "x = 2.3 and y = -31.5", etc. However, a record with "x = 10.1 and y = -31.5" or "x = 2.3 and y = 0.0" would not be returned because the values in the given lists do not correspond.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of the table to filter, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. This may be the name of a table or a view (when chaining queries). </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>viewName</td>
                <td>If provided, then this will be the name of the view containing the results, in \[schema\_name.]view\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a> and meeting <a href="/content/concepts/tables/#table-naming-criteria">table naming criteria</a>. Must not be an already existing table or view. The default value is ''. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>columnValuesMap</td>
                <td>List of values for the corresponding column in the table. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a331703b68b6d54274c36694d3d4a6012">filter\_by\_list\_create\_temp\_table</a>: If <a href="/content/api/cpp/namespacegpudb#a496dc5055a6a4c6e4a21d62a5d1bf325">true</a>, a unique temporary table name will be generated in the sys\_temp schema and used in place of <span>viewName</span>. This is always allowed even if the caller does not have permission to create tables. The generated name is returned in <a href="/content/api/cpp/namespacegpudb#a00006e78b0ee84b2fc798cc5ed0df4fa">qualified\_view\_name</a>. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a496dc5055a6a4c6e4a21d62a5d1bf325">filter\_by\_list\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad85b11509308fd3f17c4cb162f838d90">filter\_by\_list\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ad85b11509308fd3f17c4cb162f838d90">filter\_by\_list\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a8354d9ff3b7fe5203feb37a50d34d0ac">filter\_by\_list\_collection\_name</a>: \[DEPRECATED–please specify the containing schema for the view as part of <span>viewName</span> and use <a href="#a33d9a0a8e738d14b688f9f869f9640ad">createSchema</a> to create the schema if non-existent] Name of a schema for the newly created view. If the schema provided is non-existent, it will be automatically created. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#adf952c68d6b5c8ad029210bbfaa31ce7">filter\_by\_list\_filter\_mode</a>: String indicating the filter mode, either 'in\_list' or 'not\_in\_list'. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a9499e74b3ac23a5d97e7200eea0a9063">filter\_by\_list\_in\_list</a>: The filter will match all items that are in the provided list(s). </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a8d53ccbffeb5a28fd7ed28cc10596b6c">filter\_by\_list\_not\_in\_list</a>: The filter will match all items that are not in the provided list(s). </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a9499e74b3ac23a5d97e7200eea0a9063">filter\_by\_list\_in\_list</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1FilterByListResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1FilterByListResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a2c1e67f2a3f2381078fdc39377184c0c">◆ </a></span>filterByRadius() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1FilterByRadiusResponse">FilterByRadiusResponse</a> gpudb::GPUdb::filterByRadius </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1FilterByRadiusRequest">FilterByRadiusRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Calculates which objects from a table lie within a circle with the given radius and center point (i.e. circular NAI). </p>
        <p>The operation is synchronous, meaning that a response will not be returned until all the objects are fully available. The response payload provides the count of the resulting set. A new resultant set (view) which satisfies the input circular NAI restriction specification is also created if a <a href="/content/api/cpp/structgpudb_1_1FilterByRadiusRequest#a6a8b7293f90dd4434b8a7c9f9219dd97">viewName</a> is passed in as part of the request.</p>
        <p>For track data, all track points that lie within the circle plus one point on either side of the circle (if the track goes beyond the circle) will be included in the result.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1FilterByRadiusRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1FilterByRadiusResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#adc36d48ae5bb60782da377c45ef1836e">◆ </a></span>filterByRadius() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1FilterByRadiusResponse">FilterByRadiusResponse</a> & gpudb::GPUdb::filterByRadius </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1FilterByRadiusRequest">FilterByRadiusRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1FilterByRadiusResponse">FilterByRadiusResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Calculates which objects from a table lie within a circle with the given radius and center point (i.e. circular NAI). </p>
        <p>The operation is synchronous, meaning that a response will not be returned until all the objects are fully available. The response payload provides the count of the resulting set. A new resultant set (view) which satisfies the input circular NAI restriction specification is also created if a <a href="/content/api/cpp/structgpudb_1_1FilterByRadiusRequest#a6a8b7293f90dd4434b8a7c9f9219dd97">viewName</a> is passed in as part of the request.</p>
        <p>For track data, all track points that lie within the circle plus one point on either side of the circle (if the track goes beyond the circle) will be included in the result.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1FilterByRadiusRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1FilterByRadiusResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1FilterByRadiusResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a28e32e78ccc815eeaac93f3cb3e59bac">◆ </a></span>filterByRadius() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1FilterByRadiusResponse">FilterByRadiusResponse</a> gpudb::GPUdb::filterByRadius </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>viewName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>xColumnName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const double</td>
            <td><span><span>xCenter</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>yColumnName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const double</td>
            <td><span><span>yCenter</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const double</td>
            <td><span><span>radius</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Calculates which objects from a table lie within a circle with the given radius and center point (i.e. circular NAI). </p>
        <p>The operation is synchronous, meaning that a response will not be returned until all the objects are fully available. The response payload provides the count of the resulting set. A new resultant set (view) which satisfies the input circular NAI restriction specification is also created if a <span>viewName</span> is passed in as part of the request.</p>
        <p>For track data, all track points that lie within the circle plus one point on either side of the circle (if the track goes beyond the circle) will be included in the result.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of the table on which the filter by radius operation will be performed, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. Must be an existing table. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>viewName</td>
                <td>If provided, then this will be the name of the view containing the results, in \[schema\_name.]view\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a> and meeting <a href="/content/concepts/tables/#table-naming-criteria">table naming criteria</a>. Must not be an already existing table or view. The default value is ''. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>xColumnName</td>
                <td>Name of the column to be used for the x-coordinate (the longitude) of the center. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>xCenter</td>
                <td>Value of the longitude of the center. Must be within \[-180.0, 180.0]. The minimum allowed value is -180. The maximum allowed value is 180. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>yColumnName</td>
                <td>Name of the column to be used for the y-coordinate-the latitude-of the center. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>yCenter</td>
                <td>Value of the latitude of the center. Must be within \[-90.0, 90.0]. The minimum allowed value is -90. The maximum allowed value is 90. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>radius</td>
                <td>The radius of the circle within which the search will be performed. Must be a non-zero positive value. It is in meters; so, for example, a value of '42000' means 42 km. The minimum allowed value is 0. The maximum allowed value is MAX\_INT. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ac67d441b4ef58dacadaf90ec5b87ecda">filter\_by\_radius\_create\_temp\_table</a>: If <a href="/content/api/cpp/namespacegpudb#a72475d5ac0e94cd7d7a299235da2b9a6">true</a>, a unique temporary table name will be generated in the sys\_temp schema and used in place of <span>viewName</span>. This is always allowed even if the caller does not have permission to create tables. The generated name is returned in <a href="/content/api/cpp/namespacegpudb#a6f61959240374e1250b8b93df1980b76">qualified\_view\_name</a>. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a72475d5ac0e94cd7d7a299235da2b9a6">filter\_by\_radius\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a4acf8b08b4ffbaafeb3e014c9f806f07">filter\_by\_radius\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a4acf8b08b4ffbaafeb3e014c9f806f07">filter\_by\_radius\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a59e58d317f0ce608984130cf4dabb2dd">filter\_by\_radius\_collection\_name</a>: \[DEPRECATED–please specify the containing schema for the view as part of <span>viewName</span> and use <a href="#a33d9a0a8e738d14b688f9f869f9640ad">createSchema</a> to create the schema if non-existent] Name of a schema which is to contain the newly created view. If the schema is non-existent, it will be automatically created. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1FilterByRadiusResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a339d080b90896acb584c8c903ccc6135">◆ </a></span>filterByRadius() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1FilterByRadiusResponse">FilterByRadiusResponse</a> & gpudb::GPUdb::filterByRadius </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>viewName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>xColumnName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const double</td>
            <td><span><span>xCenter</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>yColumnName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const double</td>
            <td><span><span>yCenter</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const double</td>
            <td><span><span>radius</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1FilterByRadiusResponse">FilterByRadiusResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Calculates which objects from a table lie within a circle with the given radius and center point (i.e. circular NAI). </p>
        <p>The operation is synchronous, meaning that a response will not be returned until all the objects are fully available. The response payload provides the count of the resulting set. A new resultant set (view) which satisfies the input circular NAI restriction specification is also created if a <span>viewName</span> is passed in as part of the request.</p>
        <p>For track data, all track points that lie within the circle plus one point on either side of the circle (if the track goes beyond the circle) will be included in the result.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of the table on which the filter by radius operation will be performed, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. Must be an existing table. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>viewName</td>
                <td>If provided, then this will be the name of the view containing the results, in \[schema\_name.]view\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a> and meeting <a href="/content/concepts/tables/#table-naming-criteria">table naming criteria</a>. Must not be an already existing table or view. The default value is ''. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>xColumnName</td>
                <td>Name of the column to be used for the x-coordinate (the longitude) of the center. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>xCenter</td>
                <td>Value of the longitude of the center. Must be within \[-180.0, 180.0]. The minimum allowed value is -180. The maximum allowed value is 180. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>yColumnName</td>
                <td>Name of the column to be used for the y-coordinate-the latitude-of the center. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>yCenter</td>
                <td>Value of the latitude of the center. Must be within \[-90.0, 90.0]. The minimum allowed value is -90. The maximum allowed value is 90. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>radius</td>
                <td>The radius of the circle within which the search will be performed. Must be a non-zero positive value. It is in meters; so, for example, a value of '42000' means 42 km. The minimum allowed value is 0. The maximum allowed value is MAX\_INT. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ac67d441b4ef58dacadaf90ec5b87ecda">filter\_by\_radius\_create\_temp\_table</a>: If <a href="/content/api/cpp/namespacegpudb#a72475d5ac0e94cd7d7a299235da2b9a6">true</a>, a unique temporary table name will be generated in the sys\_temp schema and used in place of <span>viewName</span>. This is always allowed even if the caller does not have permission to create tables. The generated name is returned in <a href="/content/api/cpp/namespacegpudb#a6f61959240374e1250b8b93df1980b76">qualified\_view\_name</a>. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a72475d5ac0e94cd7d7a299235da2b9a6">filter\_by\_radius\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a4acf8b08b4ffbaafeb3e014c9f806f07">filter\_by\_radius\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a4acf8b08b4ffbaafeb3e014c9f806f07">filter\_by\_radius\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a59e58d317f0ce608984130cf4dabb2dd">filter\_by\_radius\_collection\_name</a>: \[DEPRECATED–please specify the containing schema for the view as part of <span>viewName</span> and use <a href="#a33d9a0a8e738d14b688f9f869f9640ad">createSchema</a> to create the schema if non-existent] Name of a schema which is to contain the newly created view. If the schema is non-existent, it will be automatically created. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1FilterByRadiusResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1FilterByRadiusResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a053919df7c9a2cd548386cf5490b626b">◆ </a></span>filterByRadiusGeometry() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1FilterByRadiusGeometryResponse">FilterByRadiusGeometryResponse</a> gpudb::GPUdb::filterByRadiusGeometry </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1FilterByRadiusGeometryRequest">FilterByRadiusGeometryRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Calculates which geospatial geometry objects from a table intersect a circle with the given radius and center point (i.e. circular NAI). </p>
        <p>The operation is synchronous, meaning that a response will not be returned until all the objects are fully available. The response payload provides the count of the resulting set. A new resultant set (view) which satisfies the input circular NAI restriction specification is also created if a <a href="/content/api/cpp/structgpudb_1_1FilterByRadiusGeometryRequest#a1cc4478cbc7325261653f39f397eb81e">viewName</a> is passed in as part of the request.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1FilterByRadiusGeometryRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1FilterByRadiusGeometryResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a4fd603a05fcd7e293eacac31dbef40ee">◆ </a></span>filterByRadiusGeometry() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1FilterByRadiusGeometryResponse">FilterByRadiusGeometryResponse</a> & gpudb::GPUdb::filterByRadiusGeometry </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1FilterByRadiusGeometryRequest">FilterByRadiusGeometryRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1FilterByRadiusGeometryResponse">FilterByRadiusGeometryResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Calculates which geospatial geometry objects from a table intersect a circle with the given radius and center point (i.e. circular NAI). </p>
        <p>The operation is synchronous, meaning that a response will not be returned until all the objects are fully available. The response payload provides the count of the resulting set. A new resultant set (view) which satisfies the input circular NAI restriction specification is also created if a <a href="/content/api/cpp/structgpudb_1_1FilterByRadiusGeometryRequest#a1cc4478cbc7325261653f39f397eb81e">viewName</a> is passed in as part of the request.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1FilterByRadiusGeometryRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1FilterByRadiusGeometryResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1FilterByRadiusGeometryResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a007497ef1b48038f75b28a5236fbae5e">◆ </a></span>filterByRadiusGeometry() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1FilterByRadiusGeometryResponse">FilterByRadiusGeometryResponse</a> gpudb::GPUdb::filterByRadiusGeometry </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>viewName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>columnName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const double</td>
            <td><span><span>xCenter</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const double</td>
            <td><span><span>yCenter</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const double</td>
            <td><span><span>radius</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Calculates which geospatial geometry objects from a table intersect a circle with the given radius and center point (i.e. circular NAI). </p>
        <p>The operation is synchronous, meaning that a response will not be returned until all the objects are fully available. The response payload provides the count of the resulting set. A new resultant set (view) which satisfies the input circular NAI restriction specification is also created if a <span>viewName</span> is passed in as part of the request.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of the table on which the filter by radius operation will be performed, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. Must be an existing table. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>viewName</td>
                <td>If provided, then this will be the name of the view containing the results, in \[schema\_name.]view\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a> and meeting <a href="/content/concepts/tables/#table-naming-criteria">table naming criteria</a>. Must not be an already existing table or view. The default value is ''. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>columnName</td>
                <td>Name of the geospatial geometry column to be filtered. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>xCenter</td>
                <td>Value of the longitude of the center. Must be within \[-180.0, 180.0]. The minimum allowed value is -180. The maximum allowed value is 180. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>yCenter</td>
                <td>Value of the latitude of the center. Must be within \[-90.0, 90.0]. The minimum allowed value is -90. The maximum allowed value is 90. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>radius</td>
                <td>The radius of the circle within which the search will be performed. Must be a non-zero positive value. It is in meters; so, for example, a value of '42000' means 42 km. The minimum allowed value is 0. The maximum allowed value is MAX\_INT. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a206ecb3f8948133e3e4d2e4f758bad73">filter\_by\_radius\_geometry\_create\_temp\_table</a>: If <a href="/content/api/cpp/namespacegpudb#a3306010b6a6119dd44e51741fa862c79">true</a>, a unique temporary table name will be generated in the sys\_temp schema and used in place of <span>viewName</span>. This is always allowed even if the caller does not have permission to create tables. The generated name is returned in <a href="/content/api/cpp/namespacegpudb#a9d0298f4085fe36d3df407f8f7e67274">qualified\_view\_name</a>. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a3306010b6a6119dd44e51741fa862c79">filter\_by\_radius\_geometry\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a1bfabc51d254db372da42a0b518fb463">filter\_by\_radius\_geometry\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a1bfabc51d254db372da42a0b518fb463">filter\_by\_radius\_geometry\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#ad76b3c2c14fe1243aaf69fb9093a9ddd">filter\_by\_radius\_geometry\_collection\_name</a>: \[DEPRECATED–please specify the containing schema for the view as part of <span>viewName</span> and use <a href="#a33d9a0a8e738d14b688f9f869f9640ad">createSchema</a> to create the schema if non-existent] Name of a schema for the newly created view. If the schema provided is non-existent, it will be automatically created. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1FilterByRadiusGeometryResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ab97caa1af20257efea7ca3c1e8dbbc10">◆ </a></span>filterByRadiusGeometry() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1FilterByRadiusGeometryResponse">FilterByRadiusGeometryResponse</a> & gpudb::GPUdb::filterByRadiusGeometry </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>viewName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>columnName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const double</td>
            <td><span><span>xCenter</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const double</td>
            <td><span><span>yCenter</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const double</td>
            <td><span><span>radius</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1FilterByRadiusGeometryResponse">FilterByRadiusGeometryResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Calculates which geospatial geometry objects from a table intersect a circle with the given radius and center point (i.e. circular NAI). </p>
        <p>The operation is synchronous, meaning that a response will not be returned until all the objects are fully available. The response payload provides the count of the resulting set. A new resultant set (view) which satisfies the input circular NAI restriction specification is also created if a <span>viewName</span> is passed in as part of the request.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of the table on which the filter by radius operation will be performed, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. Must be an existing table. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>viewName</td>
                <td>If provided, then this will be the name of the view containing the results, in \[schema\_name.]view\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a> and meeting <a href="/content/concepts/tables/#table-naming-criteria">table naming criteria</a>. Must not be an already existing table or view. The default value is ''. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>columnName</td>
                <td>Name of the geospatial geometry column to be filtered. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>xCenter</td>
                <td>Value of the longitude of the center. Must be within \[-180.0, 180.0]. The minimum allowed value is -180. The maximum allowed value is 180. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>yCenter</td>
                <td>Value of the latitude of the center. Must be within \[-90.0, 90.0]. The minimum allowed value is -90. The maximum allowed value is 90. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>radius</td>
                <td>The radius of the circle within which the search will be performed. Must be a non-zero positive value. It is in meters; so, for example, a value of '42000' means 42 km. The minimum allowed value is 0. The maximum allowed value is MAX\_INT. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a206ecb3f8948133e3e4d2e4f758bad73">filter\_by\_radius\_geometry\_create\_temp\_table</a>: If <a href="/content/api/cpp/namespacegpudb#a3306010b6a6119dd44e51741fa862c79">true</a>, a unique temporary table name will be generated in the sys\_temp schema and used in place of <span>viewName</span>. This is always allowed even if the caller does not have permission to create tables. The generated name is returned in <a href="/content/api/cpp/namespacegpudb#a9d0298f4085fe36d3df407f8f7e67274">qualified\_view\_name</a>. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a3306010b6a6119dd44e51741fa862c79">filter\_by\_radius\_geometry\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a1bfabc51d254db372da42a0b518fb463">filter\_by\_radius\_geometry\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a1bfabc51d254db372da42a0b518fb463">filter\_by\_radius\_geometry\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#ad76b3c2c14fe1243aaf69fb9093a9ddd">filter\_by\_radius\_geometry\_collection\_name</a>: \[DEPRECATED–please specify the containing schema for the view as part of <span>viewName</span> and use <a href="#a33d9a0a8e738d14b688f9f869f9640ad">createSchema</a> to create the schema if non-existent] Name of a schema for the newly created view. If the schema provided is non-existent, it will be automatically created. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1FilterByRadiusGeometryResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1FilterByRadiusGeometryResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#abb55e3a7ca457708686d596cdd5f1d05">◆ </a></span>filterByRange() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1FilterByRangeResponse">FilterByRangeResponse</a> gpudb::GPUdb::filterByRange </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1FilterByRangeRequest">FilterByRangeRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Calculates which objects from a table have a column that is within the given bounds. </p>
        <p>An object from the table identified by <a href="/content/api/cpp/structgpudb_1_1FilterByRangeRequest#a669efcf8167a36aef6d8bd5c0199e430">tableName</a> is added to the view <a href="/content/api/cpp/structgpudb_1_1FilterByRangeRequest#ab088a1e77fb566b1732b9e8696e258a9">viewName</a> if its column is within \[<a href="/content/api/cpp/structgpudb_1_1FilterByRangeRequest#a3ecf2521d8347867930e5d43b4743ef6">lowerBound</a>, <a href="/content/api/cpp/structgpudb_1_1FilterByRangeRequest#a8558d271c3649580d12f65e5ff0ee7f1">upperBound</a>] (inclusive). The operation is synchronous. The response provides a count of the number of objects which passed the bound filter. Although this functionality can also be accomplished with the standard filter function, it is more efficient.</p>
        <p>For track objects, the count reflects how many points fall within the given bounds (which may not include all the track points of any given track).</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1FilterByRangeRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1FilterByRangeResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ab9870f431c1afe2a8454a167c143f1be">◆ </a></span>filterByRange() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1FilterByRangeResponse">FilterByRangeResponse</a> & gpudb::GPUdb::filterByRange </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1FilterByRangeRequest">FilterByRangeRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1FilterByRangeResponse">FilterByRangeResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Calculates which objects from a table have a column that is within the given bounds. </p>
        <p>An object from the table identified by <a href="/content/api/cpp/structgpudb_1_1FilterByRangeRequest#a669efcf8167a36aef6d8bd5c0199e430">tableName</a> is added to the view <a href="/content/api/cpp/structgpudb_1_1FilterByRangeRequest#ab088a1e77fb566b1732b9e8696e258a9">viewName</a> if its column is within \[<a href="/content/api/cpp/structgpudb_1_1FilterByRangeRequest#a3ecf2521d8347867930e5d43b4743ef6">lowerBound</a>, <a href="/content/api/cpp/structgpudb_1_1FilterByRangeRequest#a8558d271c3649580d12f65e5ff0ee7f1">upperBound</a>] (inclusive). The operation is synchronous. The response provides a count of the number of objects which passed the bound filter. Although this functionality can also be accomplished with the standard filter function, it is more efficient.</p>
        <p>For track objects, the count reflects how many points fall within the given bounds (which may not include all the track points of any given track).</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1FilterByRangeRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1FilterByRangeResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1FilterByRangeResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a5053d89bf393fe4405f6011fa4a2a6ce">◆ </a></span>filterByRange() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1FilterByRangeResponse">FilterByRangeResponse</a> gpudb::GPUdb::filterByRange </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>viewName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>columnName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const double</td>
            <td><span><span>lowerBound</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const double</td>
            <td><span><span>upperBound</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Calculates which objects from a table have a column that is within the given bounds. </p>
        <p>An object from the table identified by <span>tableName</span> is added to the view <span>viewName</span> if its column is within \[<span>lowerBound</span>, <span>upperBound</span>] (inclusive). The operation is synchronous. The response provides a count of the number of objects which passed the bound filter. Although this functionality can also be accomplished with the standard filter function, it is more efficient.</p>
        <p>For track objects, the count reflects how many points fall within the given bounds (which may not include all the track points of any given track).</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of the table on which the filter by range operation will be performed, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. Must be an existing table. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>viewName</td>
                <td>If provided, then this will be the name of the view containing the results, in \[schema\_name.]view\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a> and meeting <a href="/content/concepts/tables/#table-naming-criteria">table naming criteria</a>. Must not be an already existing table or view. The default value is ''. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>columnName</td>
                <td>Name of a column on which the operation would be applied. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>lowerBound</td>
                <td>Value of the lower bound (inclusive). </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>upperBound</td>
                <td>Value of the upper bound (inclusive). </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#aa20bd18ef39d26154308f8866767c01a">filter\_by\_range\_create\_temp\_table</a>: If <a href="/content/api/cpp/namespacegpudb#a0a3e23476b8657bdb3286baaf72a4640">true</a>, a unique temporary table name will be generated in the sys\_temp schema and used in place of <span>viewName</span>. This is always allowed even if the caller does not have permission to create tables. The generated name is returned in <a href="/content/api/cpp/namespacegpudb#af0bddfdcae500e3747cd9fa34244a8ab">qualified\_view\_name</a>. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a0a3e23476b8657bdb3286baaf72a4640">filter\_by\_range\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad711517efbefcd93e24b0768132b8bc0">filter\_by\_range\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ad711517efbefcd93e24b0768132b8bc0">filter\_by\_range\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a72e7794cdf95ed6cd92dc21a80537d76">filter\_by\_range\_collection\_name</a>: \[DEPRECATED–please specify the containing schema for the view as part of <span>viewName</span> and use <a href="#a33d9a0a8e738d14b688f9f869f9640ad">createSchema</a> to create the schema if non-existent] Name of a schema for the newly created view. If the schema is non-existent, it will be automatically created. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1FilterByRangeResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a2f9a414b5ba06eba04464e4b76dae887">◆ </a></span>filterByRange() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1FilterByRangeResponse">FilterByRangeResponse</a> & gpudb::GPUdb::filterByRange </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>viewName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>columnName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const double</td>
            <td><span><span>lowerBound</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const double</td>
            <td><span><span>upperBound</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1FilterByRangeResponse">FilterByRangeResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Calculates which objects from a table have a column that is within the given bounds. </p>
        <p>An object from the table identified by <span>tableName</span> is added to the view <span>viewName</span> if its column is within \[<span>lowerBound</span>, <span>upperBound</span>] (inclusive). The operation is synchronous. The response provides a count of the number of objects which passed the bound filter. Although this functionality can also be accomplished with the standard filter function, it is more efficient.</p>
        <p>For track objects, the count reflects how many points fall within the given bounds (which may not include all the track points of any given track).</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of the table on which the filter by range operation will be performed, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. Must be an existing table. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>viewName</td>
                <td>If provided, then this will be the name of the view containing the results, in \[schema\_name.]view\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a> and meeting <a href="/content/concepts/tables/#table-naming-criteria">table naming criteria</a>. Must not be an already existing table or view. The default value is ''. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>columnName</td>
                <td>Name of a column on which the operation would be applied. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>lowerBound</td>
                <td>Value of the lower bound (inclusive). </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>upperBound</td>
                <td>Value of the upper bound (inclusive). </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#aa20bd18ef39d26154308f8866767c01a">filter\_by\_range\_create\_temp\_table</a>: If <a href="/content/api/cpp/namespacegpudb#a0a3e23476b8657bdb3286baaf72a4640">true</a>, a unique temporary table name will be generated in the sys\_temp schema and used in place of <span>viewName</span>. This is always allowed even if the caller does not have permission to create tables. The generated name is returned in <a href="/content/api/cpp/namespacegpudb#af0bddfdcae500e3747cd9fa34244a8ab">qualified\_view\_name</a>. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a0a3e23476b8657bdb3286baaf72a4640">filter\_by\_range\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad711517efbefcd93e24b0768132b8bc0">filter\_by\_range\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ad711517efbefcd93e24b0768132b8bc0">filter\_by\_range\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a72e7794cdf95ed6cd92dc21a80537d76">filter\_by\_range\_collection\_name</a>: \[DEPRECATED–please specify the containing schema for the view as part of <span>viewName</span> and use <a href="#a33d9a0a8e738d14b688f9f869f9640ad">createSchema</a> to create the schema if non-existent] Name of a schema for the newly created view. If the schema is non-existent, it will be automatically created. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1FilterByRangeResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1FilterByRangeResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#aa46f3221490a48a0145d65ed38a97563">◆ </a></span>filterBySeries() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1FilterBySeriesResponse">FilterBySeriesResponse</a> gpudb::GPUdb::filterBySeries </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1FilterBySeriesRequest">FilterBySeriesRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Filters objects matching all points of the given track (works only on track type data). </p>
        <p>It allows users to specify a particular track to find all other points in the table that fall within specified ranges (spatial and temporal) of all points of the given track. Additionally, the user can specify another track to see if the two intersect (or go close to each other within the specified ranges). The user also has the flexibility of using different metrics for the spatial distance calculation: Euclidean (flat geometry) or Great Circle (spherical geometry to approximate the Earth's surface distances). The filtered points are stored in a newly created result set. The return value of the function is the number of points in the resultant set (view).</p>
        <p>This operation is synchronous, meaning that a response will not be returned until all the objects are fully available.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1FilterBySeriesRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1FilterBySeriesResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a8a754c08f50d55e2d688eecd62772dde">◆ </a></span>filterBySeries() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1FilterBySeriesResponse">FilterBySeriesResponse</a> & gpudb::GPUdb::filterBySeries </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1FilterBySeriesRequest">FilterBySeriesRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1FilterBySeriesResponse">FilterBySeriesResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Filters objects matching all points of the given track (works only on track type data). </p>
        <p>It allows users to specify a particular track to find all other points in the table that fall within specified ranges (spatial and temporal) of all points of the given track. Additionally, the user can specify another track to see if the two intersect (or go close to each other within the specified ranges). The user also has the flexibility of using different metrics for the spatial distance calculation: Euclidean (flat geometry) or Great Circle (spherical geometry to approximate the Earth's surface distances). The filtered points are stored in a newly created result set. The return value of the function is the number of points in the resultant set (view).</p>
        <p>This operation is synchronous, meaning that a response will not be returned until all the objects are fully available.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1FilterBySeriesRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1FilterBySeriesResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1FilterBySeriesResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a0a04108b75417e335df61fae04747929">◆ </a></span>filterBySeries() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1FilterBySeriesResponse">FilterBySeriesResponse</a> gpudb::GPUdb::filterBySeries </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>viewName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>trackId</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< std::string > &</td>
            <td><span><span>targetTrackIds</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Filters objects matching all points of the given track (works only on track type data). </p>
        <p>It allows users to specify a particular track to find all other points in the table that fall within specified ranges (spatial and temporal) of all points of the given track. Additionally, the user can specify another track to see if the two intersect (or go close to each other within the specified ranges). The user also has the flexibility of using different metrics for the spatial distance calculation: Euclidean (flat geometry) or Great Circle (spherical geometry to approximate the Earth's surface distances). The filtered points are stored in a newly created result set. The return value of the function is the number of points in the resultant set (view).</p>
        <p>This operation is synchronous, meaning that a response will not be returned until all the objects are fully available.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of the table on which the filter by track operation will be performed, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. Must be a currently existing table with a <a href="/content/geospatial/geo_objects/">track</a> present. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>viewName</td>
                <td>If provided, then this will be the name of the view containing the results, in \[schema\_name.]view\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a> and meeting <a href="/content/concepts/tables/#table-naming-criteria">table naming criteria</a>. Must not be an already existing table or view. The default value is ''. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>trackId</td>
                <td>The ID of the track which will act as the filtering points. Must be an existing track within the given table. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>targetTrackIds</td>
                <td>Up to one track ID to intersect with the "filter" track. If any provided, it must be an valid track ID within the given set. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a027f6a58649d6d12fe2db68af334208e">filter\_by\_series\_create\_temp\_table</a>: If <a href="/content/api/cpp/namespacegpudb#a14b9a8eeaeb853a3d4c4d5a53aab29b8">true</a>, a unique temporary table name will be generated in the sys\_temp schema and used in place of <span>viewName</span>. This is always allowed even if the caller does not have permission to create tables. The generated name is returned in <a href="/content/api/cpp/namespacegpudb#a11bcec7ebbe1f46fa414e4534e47aa82">qualified\_view\_name</a>. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a14b9a8eeaeb853a3d4c4d5a53aab29b8">filter\_by\_series\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad9bb591902bfe029f9d4cf5af8944a5a">filter\_by\_series\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ad9bb591902bfe029f9d4cf5af8944a5a">filter\_by\_series\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a0f1949519a0fb2b6a89bc27b55521629">filter\_by\_series\_collection\_name</a>: \[DEPRECATED–please specify the containing schema for the view as part of <span>viewName</span> and use <a href="#a33d9a0a8e738d14b688f9f869f9640ad">createSchema</a> to create the schema if non-existent] Name of a schema for the newly created view. If the schema is non-existent, it will be automatically created. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a92ef044c5b90a62b14df3c825c1dd7a8">filter\_by\_series\_spatial\_radius</a>: A positive number passed as a string representing the radius of the search area centered around each track point's geospatial coordinates. The value is interpreted in meters. Required parameter. The minimum allowed value is '0'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a32e0f3da5be3ec4af3e907c5ba6e7877">filter\_by\_series\_time\_radius</a>: A positive number passed as a string representing the maximum allowable time difference between the timestamps of a filtered object and the given track's points. The value is interpreted in seconds. Required parameter. The minimum allowed value is '0'. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#afac16963cfa0d1d47e7a5a2054a0a3d6">filter\_by\_series\_spatial\_distance\_metric</a>: A string representing the coordinate system to use for the spatial search criteria. Acceptable values are 'euclidean' and 'great\_circle'. Optional parameter; default is 'euclidean'. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a49b8914bee810b08c34a4221030802e7">filter\_by\_series\_euclidean</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a12328a3721380f9b0559ee5e4dd1434f">filter\_by\_series\_great\_circle</a> </li>
                      </ul>
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1FilterBySeriesResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ad1319704a118df63b66e7762bf99e9a2">◆ </a></span>filterBySeries() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1FilterBySeriesResponse">FilterBySeriesResponse</a> & gpudb::GPUdb::filterBySeries </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>viewName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>trackId</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< std::string > &</td>
            <td><span><span>targetTrackIds</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1FilterBySeriesResponse">FilterBySeriesResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Filters objects matching all points of the given track (works only on track type data). </p>
        <p>It allows users to specify a particular track to find all other points in the table that fall within specified ranges (spatial and temporal) of all points of the given track. Additionally, the user can specify another track to see if the two intersect (or go close to each other within the specified ranges). The user also has the flexibility of using different metrics for the spatial distance calculation: Euclidean (flat geometry) or Great Circle (spherical geometry to approximate the Earth's surface distances). The filtered points are stored in a newly created result set. The return value of the function is the number of points in the resultant set (view).</p>
        <p>This operation is synchronous, meaning that a response will not be returned until all the objects are fully available.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of the table on which the filter by track operation will be performed, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. Must be a currently existing table with a <a href="/content/geospatial/geo_objects/">track</a> present. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>viewName</td>
                <td>If provided, then this will be the name of the view containing the results, in \[schema\_name.]view\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a> and meeting <a href="/content/concepts/tables/#table-naming-criteria">table naming criteria</a>. Must not be an already existing table or view. The default value is ''. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>trackId</td>
                <td>The ID of the track which will act as the filtering points. Must be an existing track within the given table. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>targetTrackIds</td>
                <td>Up to one track ID to intersect with the "filter" track. If any provided, it must be an valid track ID within the given set. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a027f6a58649d6d12fe2db68af334208e">filter\_by\_series\_create\_temp\_table</a>: If <a href="/content/api/cpp/namespacegpudb#a14b9a8eeaeb853a3d4c4d5a53aab29b8">true</a>, a unique temporary table name will be generated in the sys\_temp schema and used in place of <span>viewName</span>. This is always allowed even if the caller does not have permission to create tables. The generated name is returned in <a href="/content/api/cpp/namespacegpudb#a11bcec7ebbe1f46fa414e4534e47aa82">qualified\_view\_name</a>. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a14b9a8eeaeb853a3d4c4d5a53aab29b8">filter\_by\_series\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad9bb591902bfe029f9d4cf5af8944a5a">filter\_by\_series\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ad9bb591902bfe029f9d4cf5af8944a5a">filter\_by\_series\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a0f1949519a0fb2b6a89bc27b55521629">filter\_by\_series\_collection\_name</a>: \[DEPRECATED–please specify the containing schema for the view as part of <span>viewName</span> and use <a href="#a33d9a0a8e738d14b688f9f869f9640ad">createSchema</a> to create the schema if non-existent] Name of a schema for the newly created view. If the schema is non-existent, it will be automatically created. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a92ef044c5b90a62b14df3c825c1dd7a8">filter\_by\_series\_spatial\_radius</a>: A positive number passed as a string representing the radius of the search area centered around each track point's geospatial coordinates. The value is interpreted in meters. Required parameter. The minimum allowed value is '0'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a32e0f3da5be3ec4af3e907c5ba6e7877">filter\_by\_series\_time\_radius</a>: A positive number passed as a string representing the maximum allowable time difference between the timestamps of a filtered object and the given track's points. The value is interpreted in seconds. Required parameter. The minimum allowed value is '0'. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#afac16963cfa0d1d47e7a5a2054a0a3d6">filter\_by\_series\_spatial\_distance\_metric</a>: A string representing the coordinate system to use for the spatial search criteria. Acceptable values are 'euclidean' and 'great\_circle'. Optional parameter; default is 'euclidean'. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a49b8914bee810b08c34a4221030802e7">filter\_by\_series\_euclidean</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a12328a3721380f9b0559ee5e4dd1434f">filter\_by\_series\_great\_circle</a> </li>
                      </ul>
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1FilterBySeriesResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1FilterBySeriesResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a4c7a7acb22b8793a57a5c9162f7e063e">◆ </a></span>filterByString() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1FilterByStringResponse">FilterByStringResponse</a> gpudb::GPUdb::filterByString </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1FilterByStringRequest">FilterByStringRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Calculates which objects from a table or view match a string expression for the given string columns. </p>
        <p>Setting <a href="/content/api/cpp/namespacegpudb#a03974abe744afd69b0a93a332c3c06a0">case\_sensitive</a> can modify case sensitivity in matching for all modes except <a href="/content/api/cpp/namespacegpudb#a344e39d3272af6d6cd26efd95370abe1">search</a>. For <a href="/content/api/cpp/namespacegpudb#a344e39d3272af6d6cd26efd95370abe1">search</a> mode details and limitations, see <a href="/content/concepts/full_text_search/">Full Text Search</a>.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1FilterByStringRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1FilterByStringResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a2fbef5ccbedc476c240e83e1350a898a">◆ </a></span>filterByString() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1FilterByStringResponse">FilterByStringResponse</a> & gpudb::GPUdb::filterByString </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1FilterByStringRequest">FilterByStringRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1FilterByStringResponse">FilterByStringResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Calculates which objects from a table or view match a string expression for the given string columns. </p>
        <p>Setting <a href="/content/api/cpp/namespacegpudb#a03974abe744afd69b0a93a332c3c06a0">case\_sensitive</a> can modify case sensitivity in matching for all modes except <a href="/content/api/cpp/namespacegpudb#a344e39d3272af6d6cd26efd95370abe1">search</a>. For <a href="/content/api/cpp/namespacegpudb#a344e39d3272af6d6cd26efd95370abe1">search</a> mode details and limitations, see <a href="/content/concepts/full_text_search/">Full Text Search</a>.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1FilterByStringRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1FilterByStringResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1FilterByStringResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a950c256cf401850944e641ab760f9e5e">◆ </a></span>filterByString() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1FilterByStringResponse">FilterByStringResponse</a> gpudb::GPUdb::filterByString </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>viewName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>expression</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>mode</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< std::string > &</td>
            <td><span><span>columnNames</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Calculates which objects from a table or view match a string expression for the given string columns. </p>
        <p>Setting <a href="/content/api/cpp/namespacegpudb#a03974abe744afd69b0a93a332c3c06a0">case\_sensitive</a> can modify case sensitivity in matching for all modes except <a href="/content/api/cpp/namespacegpudb#a344e39d3272af6d6cd26efd95370abe1">search</a>. For <a href="/content/api/cpp/namespacegpudb#a344e39d3272af6d6cd26efd95370abe1">search</a> mode details and limitations, see <a href="/content/concepts/full_text_search/">Full Text Search</a>.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of the table on which the filter operation will be performed, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. Must be an existing table or view. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>viewName</td>
                <td>If provided, then this will be the name of the view containing the results, in \[schema\_name.]view\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a> and meeting <a href="/content/concepts/tables/#table-naming-criteria">table naming criteria</a>. Must not be an already existing table or view. The default value is ''. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>expression</td>
                <td>The expression with which to filter the table. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>mode</td>

                <td>
                  The string filtering mode to apply. See below for details. Supported values:

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a344e39d3272af6d6cd26efd95370abe1">filter\_by\_string\_search</a>: Full text search query with wildcards and boolean operators. Note that for this mode, no column can be specified in <span>columnNames</span>; all string columns of the table that have text search enabled will be searched. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a23c0c11ad0967c707d790d64e71e20af">filter\_by\_string\_equals</a>: Exact whole-string match (accelerated). </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#af8dfaafd43b3cb9dbca90fc60f3667ba">filter\_by\_string\_contains</a>: Partial substring match (not accelerated). If the column is a string type (non-charN) and the number of records is too large, it will return 0. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a04336e34ac48efe030a77e76e5eddbd4">filter\_by\_string\_starts\_with</a>: Strings that start with the given expression (not accelerated). If the column is a string type (non-charN) and the number of records is too large, it will return 0. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#afe5b76dc543d431780210b16e600746d">filter\_by\_string\_regex</a>: Full regular expression search (not accelerated). If the column is a string type (non-charN) and the number of records is too large, it will return 0. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a9edc529ee2ab64b80cd35da27f61668e">filter\_by\_string\_search\_stats</a>: Cross-shard BM25 corpus statistics for one (column, query) pair. Returns the merged BM25 statistics (max\_doc, doc\_count, sum\_total\_term\_freq, per-term doc\_freq / total\_term\_freq) needed by callers that score documents themselves (e.g. text\_match\_bm25\_global SQL function pre-pass). Requires <span>column\_names</span> to contain exactly one column with text search enabled. The <span>view\_name</span> field is ignored — this mode does not produce a result table. </li>
                  </ul>
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>columnNames</td>
                <td>List of columns on which to apply the filter. Ignored for <a href="/content/api/cpp/namespacegpudb#a344e39d3272af6d6cd26efd95370abe1">search</a> mode. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a5ab071ec4ac6b35cdf6abe4b3ee59ce0">filter\_by\_string\_create\_temp\_table</a>: If <a href="/content/api/cpp/namespacegpudb#af3080edf9fd7312c560898325f468a2e">true</a>, a unique temporary table name will be generated in the sys\_temp schema and used in place of <span>viewName</span>. This is always allowed even if the caller does not have permission to create tables. The generated name is returned in <a href="/content/api/cpp/namespacegpudb#aadd6c9450b2af70fc3a835c9be725e60">qualified\_view\_name</a>. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#af3080edf9fd7312c560898325f468a2e">filter\_by\_string\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a7f21e1256d545666c9face38129ff449">filter\_by\_string\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a7f21e1256d545666c9face38129ff449">filter\_by\_string\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a11440f1ad8db563a96ddd47a7a1d9c33">filter\_by\_string\_collection\_name</a>: \[DEPRECATED–please specify the containing schema for the view as part of <span>viewName</span> and use <a href="#a33d9a0a8e738d14b688f9f869f9640ad">createSchema</a> to create the schema if non-existent] Name of a schema for the newly created view. If the schema is non-existent, it will be automatically created. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a03974abe744afd69b0a93a332c3c06a0">filter\_by\_string\_case\_sensitive</a>: If <a href="/content/api/cpp/namespacegpudb#a7f21e1256d545666c9face38129ff449">false</a> then string filtering will ignore case. Does not apply to <a href="/content/api/cpp/namespacegpudb#a344e39d3272af6d6cd26efd95370abe1">search</a> mode. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#af3080edf9fd7312c560898325f468a2e">filter\_by\_string\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a7f21e1256d545666c9face38129ff449">filter\_by\_string\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#af3080edf9fd7312c560898325f468a2e">filter\_by\_string\_true</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1FilterByStringResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#abe5f7d81e26d9ae26b172fe2670eb41f">◆ </a></span>filterByString() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1FilterByStringResponse">FilterByStringResponse</a> & gpudb::GPUdb::filterByString </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>viewName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>expression</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>mode</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< std::string > &</td>
            <td><span><span>columnNames</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1FilterByStringResponse">FilterByStringResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Calculates which objects from a table or view match a string expression for the given string columns. </p>
        <p>Setting <a href="/content/api/cpp/namespacegpudb#a03974abe744afd69b0a93a332c3c06a0">case\_sensitive</a> can modify case sensitivity in matching for all modes except <a href="/content/api/cpp/namespacegpudb#a344e39d3272af6d6cd26efd95370abe1">search</a>. For <a href="/content/api/cpp/namespacegpudb#a344e39d3272af6d6cd26efd95370abe1">search</a> mode details and limitations, see <a href="/content/concepts/full_text_search/">Full Text Search</a>.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of the table on which the filter operation will be performed, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. Must be an existing table or view. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>viewName</td>
                <td>If provided, then this will be the name of the view containing the results, in \[schema\_name.]view\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a> and meeting <a href="/content/concepts/tables/#table-naming-criteria">table naming criteria</a>. Must not be an already existing table or view. The default value is ''. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>expression</td>
                <td>The expression with which to filter the table. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>mode</td>

                <td>
                  The string filtering mode to apply. See below for details. Supported values:

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a344e39d3272af6d6cd26efd95370abe1">filter\_by\_string\_search</a>: Full text search query with wildcards and boolean operators. Note that for this mode, no column can be specified in <span>columnNames</span>; all string columns of the table that have text search enabled will be searched. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a23c0c11ad0967c707d790d64e71e20af">filter\_by\_string\_equals</a>: Exact whole-string match (accelerated). </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#af8dfaafd43b3cb9dbca90fc60f3667ba">filter\_by\_string\_contains</a>: Partial substring match (not accelerated). If the column is a string type (non-charN) and the number of records is too large, it will return 0. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a04336e34ac48efe030a77e76e5eddbd4">filter\_by\_string\_starts\_with</a>: Strings that start with the given expression (not accelerated). If the column is a string type (non-charN) and the number of records is too large, it will return 0. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#afe5b76dc543d431780210b16e600746d">filter\_by\_string\_regex</a>: Full regular expression search (not accelerated). If the column is a string type (non-charN) and the number of records is too large, it will return 0. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a9edc529ee2ab64b80cd35da27f61668e">filter\_by\_string\_search\_stats</a>: Cross-shard BM25 corpus statistics for one (column, query) pair. Returns the merged BM25 statistics (max\_doc, doc\_count, sum\_total\_term\_freq, per-term doc\_freq / total\_term\_freq) needed by callers that score documents themselves (e.g. text\_match\_bm25\_global SQL function pre-pass). Requires <span>column\_names</span> to contain exactly one column with text search enabled. The <span>view\_name</span> field is ignored — this mode does not produce a result table. </li>
                  </ul>
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>columnNames</td>
                <td>List of columns on which to apply the filter. Ignored for <a href="/content/api/cpp/namespacegpudb#a344e39d3272af6d6cd26efd95370abe1">search</a> mode. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a5ab071ec4ac6b35cdf6abe4b3ee59ce0">filter\_by\_string\_create\_temp\_table</a>: If <a href="/content/api/cpp/namespacegpudb#af3080edf9fd7312c560898325f468a2e">true</a>, a unique temporary table name will be generated in the sys\_temp schema and used in place of <span>viewName</span>. This is always allowed even if the caller does not have permission to create tables. The generated name is returned in <a href="/content/api/cpp/namespacegpudb#aadd6c9450b2af70fc3a835c9be725e60">qualified\_view\_name</a>. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#af3080edf9fd7312c560898325f468a2e">filter\_by\_string\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a7f21e1256d545666c9face38129ff449">filter\_by\_string\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a7f21e1256d545666c9face38129ff449">filter\_by\_string\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a11440f1ad8db563a96ddd47a7a1d9c33">filter\_by\_string\_collection\_name</a>: \[DEPRECATED–please specify the containing schema for the view as part of <span>viewName</span> and use <a href="#a33d9a0a8e738d14b688f9f869f9640ad">createSchema</a> to create the schema if non-existent] Name of a schema for the newly created view. If the schema is non-existent, it will be automatically created. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a03974abe744afd69b0a93a332c3c06a0">filter\_by\_string\_case\_sensitive</a>: If <a href="/content/api/cpp/namespacegpudb#a7f21e1256d545666c9face38129ff449">false</a> then string filtering will ignore case. Does not apply to <a href="/content/api/cpp/namespacegpudb#a344e39d3272af6d6cd26efd95370abe1">search</a> mode. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#af3080edf9fd7312c560898325f468a2e">filter\_by\_string\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a7f21e1256d545666c9face38129ff449">filter\_by\_string\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#af3080edf9fd7312c560898325f468a2e">filter\_by\_string\_true</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1FilterByStringResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1FilterByStringResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a5c433b2d7eecc3b3942dfa4b3a8a8439">◆ </a></span>filterByTable() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1FilterByTableResponse">FilterByTableResponse</a> gpudb::GPUdb::filterByTable </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1FilterByTableRequest">FilterByTableRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Filters objects in one table based on objects in another table. </p>
        <p>The user must specify matching column types from the two tables (i.e. the target table from which objects will be filtered and the source table based on which the filter will be created); the column names need not be the same. If a <a href="/content/api/cpp/structgpudb_1_1FilterByTableRequest#a777a10b176303c8048abf4659ac05416">viewName</a> is specified, then the filtered objects will then be put in a newly created view. The operation is synchronous, meaning that a response will not be returned until all objects are fully available in the result view. The return value contains the count (i.e. the size) of the resulting view.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1FilterByTableRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1FilterByTableResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a8ba8e97be0cc690bb7d2e50a986006f7">◆ </a></span>filterByTable() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1FilterByTableResponse">FilterByTableResponse</a> & gpudb::GPUdb::filterByTable </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1FilterByTableRequest">FilterByTableRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1FilterByTableResponse">FilterByTableResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Filters objects in one table based on objects in another table. </p>
        <p>The user must specify matching column types from the two tables (i.e. the target table from which objects will be filtered and the source table based on which the filter will be created); the column names need not be the same. If a <a href="/content/api/cpp/structgpudb_1_1FilterByTableRequest#a777a10b176303c8048abf4659ac05416">viewName</a> is specified, then the filtered objects will then be put in a newly created view. The operation is synchronous, meaning that a response will not be returned until all objects are fully available in the result view. The return value contains the count (i.e. the size) of the resulting view.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1FilterByTableRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1FilterByTableResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1FilterByTableResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a5b1459e1faf37b5d66c404ba87a1a959">◆ </a></span>filterByTable() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1FilterByTableResponse">FilterByTableResponse</a> gpudb::GPUdb::filterByTable </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>viewName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>columnName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>sourceTableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>sourceTableColumnName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Filters objects in one table based on objects in another table. </p>
        <p>The user must specify matching column types from the two tables (i.e. the target table from which objects will be filtered and the source table based on which the filter will be created); the column names need not be the same. If a <span>viewName</span> is specified, then the filtered objects will then be put in a newly created view. The operation is synchronous, meaning that a response will not be returned until all objects are fully available in the result view. The return value contains the count (i.e. the size) of the resulting view.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of the table whose data will be filtered, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. Must be an existing table. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>viewName</td>
                <td>If provided, then this will be the name of the view containing the results, in \[schema\_name.]view\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a> and meeting <a href="/content/concepts/tables/#table-naming-criteria">table naming criteria</a>. Must not be an already existing table or view. The default value is ''. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>columnName</td>
                <td>Name of the column by whose value the data will be filtered from the table designated by <span>tableName</span>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>sourceTableName</td>
                <td>Name of the table whose data will be compared against in the table called <span>tableName</span>, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. Must be an existing table. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>sourceTableColumnName</td>
                <td>Name of the column in the <span>sourceTableName</span> whose values will be used as the filter for table <span>tableName</span>. Must be a geospatial geometry column if in 'spatial' mode; otherwise, Must match the type of the <span>columnName</span>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a3a8fb532ba3fe3c29cd192f503ab1087">filter\_by\_table\_create\_temp\_table</a>: If <a href="/content/api/cpp/namespacegpudb#a5b373ba022dd21dd1624974a76acefb0">true</a>, a unique temporary table name will be generated in the sys\_temp schema and used in place of <span>viewName</span>. This is always allowed even if the caller does not have permission to create tables. The generated name is returned in <a href="/content/api/cpp/namespacegpudb#ae404b86fed68bc649b0fcff3021833eb">qualified\_view\_name</a>. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a5b373ba022dd21dd1624974a76acefb0">filter\_by\_table\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#adb191d9d88cb8b0d883734d1a9d04694">filter\_by\_table\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#adb191d9d88cb8b0d883734d1a9d04694">filter\_by\_table\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#af82aee30e270aaa9d2ce7bc808367624">filter\_by\_table\_collection\_name</a>: \[DEPRECATED–please specify the containing schema for the view as part of <span>viewName</span> and use <a href="#a33d9a0a8e738d14b688f9f869f9640ad">createSchema</a> to create the schema if non-existent] Name of a schema for the newly created view. If the schema is non-existent, it will be automatically created. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a690a30af1513b7aef7a7775841a7218c">filter\_by\_table\_filter\_mode</a>: String indicating the filter mode, either <a href="/content/api/cpp/namespacegpudb#a9637b8977703beafcd73031ec343cd91">in\_table</a> or <a href="/content/api/cpp/namespacegpudb#ad33ac55cc0461fddfe3361641f6389c6">not\_in\_table</a>. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a9637b8977703beafcd73031ec343cd91">filter\_by\_table\_in\_table</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad33ac55cc0461fddfe3361641f6389c6">filter\_by\_table\_not\_in\_table</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a9637b8977703beafcd73031ec343cd91">filter\_by\_table\_in\_table</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a6d7967e0e760808f519ed4409d0a48d6">filter\_by\_table\_mode</a>: Mode - should be either <a href="/content/api/cpp/namespacegpudb#a52edb480eb110814e63f827430a8af20">spatial</a> or <a href="/content/api/cpp/namespacegpudb#a308d741e5a8a1e9ac7a44f266e6373a8">normal</a>. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a308d741e5a8a1e9ac7a44f266e6373a8">filter\_by\_table\_normal</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a52edb480eb110814e63f827430a8af20">filter\_by\_table\_spatial</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a308d741e5a8a1e9ac7a44f266e6373a8">filter\_by\_table\_normal</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#ad7ef57907ab11653841405892df0f973">filter\_by\_table\_buffer</a>: Buffer size, in meters. Only relevant for <a href="/content/api/cpp/namespacegpudb#a52edb480eb110814e63f827430a8af20">spatial</a> mode. The default value is '0'. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a6266c0eb68d3ad24e6e4377cab638498">filter\_by\_table\_buffer\_method</a>: Method used to buffer polygons. Only relevant for <a href="/content/api/cpp/namespacegpudb#a52edb480eb110814e63f827430a8af20">spatial</a> mode. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a308d741e5a8a1e9ac7a44f266e6373a8">filter\_by\_table\_normal</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ab7ce4aba83f8d4a040076f51df67efde">filter\_by\_table\_geos</a>: Use geos 1 edge per corner algorithm. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a308d741e5a8a1e9ac7a44f266e6373a8">filter\_by\_table\_normal</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a6013afea4dddb4146a429a9be0f97e49">filter\_by\_table\_max\_partition\_size</a>: Maximum number of points in a partition. Only relevant for <a href="/content/api/cpp/namespacegpudb#a52edb480eb110814e63f827430a8af20">spatial</a> mode. The default value is '0'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aa968db7e3522bc707588a12333f0f058">filter\_by\_table\_max\_partition\_score</a>: Maximum number of points \* edges in a partition. Only relevant for <a href="/content/api/cpp/namespacegpudb#a52edb480eb110814e63f827430a8af20">spatial</a> mode. The default value is '8000000'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a89aa1556b2d39a31454ecf4a3d94e704">filter\_by\_table\_x\_column\_name</a>: Name of column containing x value of point being filtered in <a href="/content/api/cpp/namespacegpudb#a52edb480eb110814e63f827430a8af20">spatial</a> mode. The default value is 'x'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ad4b29869b86aa82a7f25e972855b567a">filter\_by\_table\_y\_column\_name</a>: Name of column containing y value of point being filtered in <a href="/content/api/cpp/namespacegpudb#a52edb480eb110814e63f827430a8af20">spatial</a> mode. The default value is 'y'. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1FilterByTableResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a05ba1ecb87eef74577e33e6638000855">◆ </a></span>filterByTable() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1FilterByTableResponse">FilterByTableResponse</a> & gpudb::GPUdb::filterByTable </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>viewName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>columnName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>sourceTableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>sourceTableColumnName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1FilterByTableResponse">FilterByTableResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Filters objects in one table based on objects in another table. </p>
        <p>The user must specify matching column types from the two tables (i.e. the target table from which objects will be filtered and the source table based on which the filter will be created); the column names need not be the same. If a <span>viewName</span> is specified, then the filtered objects will then be put in a newly created view. The operation is synchronous, meaning that a response will not be returned until all objects are fully available in the result view. The return value contains the count (i.e. the size) of the resulting view.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of the table whose data will be filtered, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. Must be an existing table. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>viewName</td>
                <td>If provided, then this will be the name of the view containing the results, in \[schema\_name.]view\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a> and meeting <a href="/content/concepts/tables/#table-naming-criteria">table naming criteria</a>. Must not be an already existing table or view. The default value is ''. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>columnName</td>
                <td>Name of the column by whose value the data will be filtered from the table designated by <span>tableName</span>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>sourceTableName</td>
                <td>Name of the table whose data will be compared against in the table called <span>tableName</span>, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. Must be an existing table. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>sourceTableColumnName</td>
                <td>Name of the column in the <span>sourceTableName</span> whose values will be used as the filter for table <span>tableName</span>. Must be a geospatial geometry column if in 'spatial' mode; otherwise, Must match the type of the <span>columnName</span>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a3a8fb532ba3fe3c29cd192f503ab1087">filter\_by\_table\_create\_temp\_table</a>: If <a href="/content/api/cpp/namespacegpudb#a5b373ba022dd21dd1624974a76acefb0">true</a>, a unique temporary table name will be generated in the sys\_temp schema and used in place of <span>viewName</span>. This is always allowed even if the caller does not have permission to create tables. The generated name is returned in <a href="/content/api/cpp/namespacegpudb#ae404b86fed68bc649b0fcff3021833eb">qualified\_view\_name</a>. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a5b373ba022dd21dd1624974a76acefb0">filter\_by\_table\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#adb191d9d88cb8b0d883734d1a9d04694">filter\_by\_table\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#adb191d9d88cb8b0d883734d1a9d04694">filter\_by\_table\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#af82aee30e270aaa9d2ce7bc808367624">filter\_by\_table\_collection\_name</a>: \[DEPRECATED–please specify the containing schema for the view as part of <span>viewName</span> and use <a href="#a33d9a0a8e738d14b688f9f869f9640ad">createSchema</a> to create the schema if non-existent] Name of a schema for the newly created view. If the schema is non-existent, it will be automatically created. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a690a30af1513b7aef7a7775841a7218c">filter\_by\_table\_filter\_mode</a>: String indicating the filter mode, either <a href="/content/api/cpp/namespacegpudb#a9637b8977703beafcd73031ec343cd91">in\_table</a> or <a href="/content/api/cpp/namespacegpudb#ad33ac55cc0461fddfe3361641f6389c6">not\_in\_table</a>. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a9637b8977703beafcd73031ec343cd91">filter\_by\_table\_in\_table</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad33ac55cc0461fddfe3361641f6389c6">filter\_by\_table\_not\_in\_table</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a9637b8977703beafcd73031ec343cd91">filter\_by\_table\_in\_table</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a6d7967e0e760808f519ed4409d0a48d6">filter\_by\_table\_mode</a>: Mode - should be either <a href="/content/api/cpp/namespacegpudb#a52edb480eb110814e63f827430a8af20">spatial</a> or <a href="/content/api/cpp/namespacegpudb#a308d741e5a8a1e9ac7a44f266e6373a8">normal</a>. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a308d741e5a8a1e9ac7a44f266e6373a8">filter\_by\_table\_normal</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a52edb480eb110814e63f827430a8af20">filter\_by\_table\_spatial</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a308d741e5a8a1e9ac7a44f266e6373a8">filter\_by\_table\_normal</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#ad7ef57907ab11653841405892df0f973">filter\_by\_table\_buffer</a>: Buffer size, in meters. Only relevant for <a href="/content/api/cpp/namespacegpudb#a52edb480eb110814e63f827430a8af20">spatial</a> mode. The default value is '0'. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a6266c0eb68d3ad24e6e4377cab638498">filter\_by\_table\_buffer\_method</a>: Method used to buffer polygons. Only relevant for <a href="/content/api/cpp/namespacegpudb#a52edb480eb110814e63f827430a8af20">spatial</a> mode. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a308d741e5a8a1e9ac7a44f266e6373a8">filter\_by\_table\_normal</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ab7ce4aba83f8d4a040076f51df67efde">filter\_by\_table\_geos</a>: Use geos 1 edge per corner algorithm. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a308d741e5a8a1e9ac7a44f266e6373a8">filter\_by\_table\_normal</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a6013afea4dddb4146a429a9be0f97e49">filter\_by\_table\_max\_partition\_size</a>: Maximum number of points in a partition. Only relevant for <a href="/content/api/cpp/namespacegpudb#a52edb480eb110814e63f827430a8af20">spatial</a> mode. The default value is '0'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aa968db7e3522bc707588a12333f0f058">filter\_by\_table\_max\_partition\_score</a>: Maximum number of points \* edges in a partition. Only relevant for <a href="/content/api/cpp/namespacegpudb#a52edb480eb110814e63f827430a8af20">spatial</a> mode. The default value is '8000000'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a89aa1556b2d39a31454ecf4a3d94e704">filter\_by\_table\_x\_column\_name</a>: Name of column containing x value of point being filtered in <a href="/content/api/cpp/namespacegpudb#a52edb480eb110814e63f827430a8af20">spatial</a> mode. The default value is 'x'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ad4b29869b86aa82a7f25e972855b567a">filter\_by\_table\_y\_column\_name</a>: Name of column containing y value of point being filtered in <a href="/content/api/cpp/namespacegpudb#a52edb480eb110814e63f827430a8af20">spatial</a> mode. The default value is 'y'. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1FilterByTableResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1FilterByTableResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#adf1643ba8a5fb03eaf47c8991c004a4c">◆ </a></span>filterByValue() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1FilterByValueResponse">FilterByValueResponse</a> gpudb::GPUdb::filterByValue </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1FilterByValueRequest">FilterByValueRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Calculates which objects from a table has a particular value for a particular column. </p>
        <p>The input parameters provide a way to specify either a String or a Double valued column and a desired value for the column on which the filter is performed. The operation is synchronous, meaning that a response will not be returned until all the objects are fully available. The response payload provides the count of the resulting set. A new result view which satisfies the input filter restriction specification is also created with a view name passed in as part of the input payload. Although this functionality can also be accomplished with the standard filter function, it is more efficient.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1FilterByValueRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1FilterByValueResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a5e7b729ac26c2847bb2d3d59d332d9e3">◆ </a></span>filterByValue() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1FilterByValueResponse">FilterByValueResponse</a> & gpudb::GPUdb::filterByValue </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1FilterByValueRequest">FilterByValueRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1FilterByValueResponse">FilterByValueResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Calculates which objects from a table has a particular value for a particular column. </p>
        <p>The input parameters provide a way to specify either a String or a Double valued column and a desired value for the column on which the filter is performed. The operation is synchronous, meaning that a response will not be returned until all the objects are fully available. The response payload provides the count of the resulting set. A new result view which satisfies the input filter restriction specification is also created with a view name passed in as part of the input payload. Although this functionality can also be accomplished with the standard filter function, it is more efficient.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1FilterByValueRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1FilterByValueResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1FilterByValueResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a38c7ac75e711488e45d6480b5081587b">◆ </a></span>filterByValue() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1FilterByValueResponse">FilterByValueResponse</a> gpudb::GPUdb::filterByValue </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>viewName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const bool</td>
            <td><span><span>isString</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const double</td>
            <td><span><span>value</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>valueStr</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>columnName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Calculates which objects from a table has a particular value for a particular column. </p>
        <p>The input parameters provide a way to specify either a String or a Double valued column and a desired value for the column on which the filter is performed. The operation is synchronous, meaning that a response will not be returned until all the objects are fully available. The response payload provides the count of the resulting set. A new result view which satisfies the input filter restriction specification is also created with a view name passed in as part of the input payload. Although this functionality can also be accomplished with the standard filter function, it is more efficient.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of an existing table on which to perform the calculation, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>viewName</td>
                <td>If provided, then this will be the name of the view containing the results, in \[schema\_name.]view\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a> and meeting <a href="/content/concepts/tables/#table-naming-criteria">table naming criteria</a>. Must not be an already existing table or view. The default value is ''. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>isString</td>
                <td>Indicates whether the value being searched for is string or numeric. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>value</td>
                <td>The value to search for. The default value is 0. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>valueStr</td>
                <td>The string value to search for. The default value is ''. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>columnName</td>
                <td>Name of a column on which the filter by value would be applied. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ad8d0e2db24b84f13c1b6a4cf1da8344a">filter\_by\_value\_create\_temp\_table</a>: If <a href="/content/api/cpp/namespacegpudb#a0c9fc58a0c48f653739b15c9edee8e98">true</a>, a unique temporary table name will be generated in the sys\_temp schema and used in place of <span>viewName</span>. This is always allowed even if the caller does not have permission to create tables. The generated name is returned in <a href="/content/api/cpp/namespacegpudb#a6a03ad0d8c3320605cb7561f596a4cc7">qualified\_view\_name</a>. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a0c9fc58a0c48f653739b15c9edee8e98">filter\_by\_value\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a77a87ad5044068fc0073e5c3d2fcab75">filter\_by\_value\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a77a87ad5044068fc0073e5c3d2fcab75">filter\_by\_value\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#aaa6f5bdc2db2936498af3101c7d30809">filter\_by\_value\_collection\_name</a>: \[DEPRECATED–please specify the containing schema for the view as part of <span>viewName</span> and use <a href="#a33d9a0a8e738d14b688f9f869f9640ad">createSchema</a> to create the schema if non-existent] Name of a schema for the newly created view. If the schema is non-existent, it will be automatically created. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1FilterByValueResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a7037257854419f4cd849349c908358af">◆ </a></span>filterByValue() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1FilterByValueResponse">FilterByValueResponse</a> & gpudb::GPUdb::filterByValue </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>viewName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const bool</td>
            <td><span><span>isString</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const double</td>
            <td><span><span>value</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>valueStr</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>columnName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1FilterByValueResponse">FilterByValueResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Calculates which objects from a table has a particular value for a particular column. </p>
        <p>The input parameters provide a way to specify either a String or a Double valued column and a desired value for the column on which the filter is performed. The operation is synchronous, meaning that a response will not be returned until all the objects are fully available. The response payload provides the count of the resulting set. A new result view which satisfies the input filter restriction specification is also created with a view name passed in as part of the input payload. Although this functionality can also be accomplished with the standard filter function, it is more efficient.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of an existing table on which to perform the calculation, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>viewName</td>
                <td>If provided, then this will be the name of the view containing the results, in \[schema\_name.]view\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a> and meeting <a href="/content/concepts/tables/#table-naming-criteria">table naming criteria</a>. Must not be an already existing table or view. The default value is ''. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>isString</td>
                <td>Indicates whether the value being searched for is string or numeric. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>value</td>
                <td>The value to search for. The default value is 0. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>valueStr</td>
                <td>The string value to search for. The default value is ''. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>columnName</td>
                <td>Name of a column on which the filter by value would be applied. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ad8d0e2db24b84f13c1b6a4cf1da8344a">filter\_by\_value\_create\_temp\_table</a>: If <a href="/content/api/cpp/namespacegpudb#a0c9fc58a0c48f653739b15c9edee8e98">true</a>, a unique temporary table name will be generated in the sys\_temp schema and used in place of <span>viewName</span>. This is always allowed even if the caller does not have permission to create tables. The generated name is returned in <a href="/content/api/cpp/namespacegpudb#a6a03ad0d8c3320605cb7561f596a4cc7">qualified\_view\_name</a>. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a0c9fc58a0c48f653739b15c9edee8e98">filter\_by\_value\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a77a87ad5044068fc0073e5c3d2fcab75">filter\_by\_value\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a77a87ad5044068fc0073e5c3d2fcab75">filter\_by\_value\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#aaa6f5bdc2db2936498af3101c7d30809">filter\_by\_value\_collection\_name</a>: \[DEPRECATED–please specify the containing schema for the view as part of <span>viewName</span> and use <a href="#a33d9a0a8e738d14b688f9f869f9640ad">createSchema</a> to create the schema if non-existent] Name of a schema for the newly created view. If the schema is non-existent, it will be automatically created. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1FilterByValueResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1FilterByValueResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#aa43463a086aefafc7d123795fa543764">◆ </a></span>getApiVersion()</h2>

    <div>
      <div>
        <table>
          <tr>
            <td>
              <table>
                <tr>
                  <td>static std::string gpudb::GPUdb::getApiVersion </td>
                  <td>(</td>

                  <td>
                    <span>
                      <span />
                    </span>
                  </td>

                  <td>)</td>

                  <td />
                </tr>
              </table>
            </td>

            <td> <span><span>inline</span><span>static</span></span> </td>
          </tr>
        </table>
      </div>

      <div>
        <p>Definition at line <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp#L188">188</a> of file <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">GPUdb.hpp</a>.</p>
      </div>
    </div>

    <h2><span><a href="#a9df18e1554f55b50946316b044780699">◆ </a></span>getBypassSslCertCheck()</h2>

    <div>
      <div>
        <table>
          <tr>
            <td>bool gpudb::GPUdb::getBypassSslCertCheck </td>
            <td>(</td>

            <td>
              <span>
                <span />
              </span>
            </td>

            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#a42e64c54611ca14b27daa3d1417d982e">◆ </a></span>getExecutor()</h2>

    <div>
      <div>
        <table>
          <tr>
            <td>avro::ExecutorPtr gpudb::GPUdb::getExecutor </td>
            <td>(</td>

            <td>
              <span>
                <span />
              </span>
            </td>

            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#a6646fdaddf14aa7d9857ec0636fa204f">◆ </a></span>getGraphEntities() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1GetGraphEntitiesResponse">GetGraphEntitiesResponse</a> gpudb::GPUdb::getGraphEntities </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1GetGraphEntitiesRequest">GetGraphEntitiesRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Retrieves node or edge entities from an existing graph, with pagination support via offset and limit. </p>
        <p>Use <a href="#aa26104ece9a4825f8fd309470e2477ec">showGraph</a> to obtain the total number of nodes and edges.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GetGraphEntitiesRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1GetGraphEntitiesResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a2ece66c08b4b6d9350f7d829b792ccec">◆ </a></span>getGraphEntities() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1GetGraphEntitiesResponse">GetGraphEntitiesResponse</a> & gpudb::GPUdb::getGraphEntities </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1GetGraphEntitiesRequest">GetGraphEntitiesRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1GetGraphEntitiesResponse">GetGraphEntitiesResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Retrieves node or edge entities from an existing graph, with pagination support via offset and limit. </p>
        <p>Use <a href="#aa26104ece9a4825f8fd309470e2477ec">showGraph</a> to obtain the total number of nodes and edges.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GetGraphEntitiesRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GetGraphEntitiesResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1GetGraphEntitiesResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a6800299fb04843d1be5d5ffbd2a425f7">◆ </a></span>getGraphEntities() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1GetGraphEntitiesResponse">GetGraphEntitiesResponse</a> gpudb::GPUdb::getGraphEntities </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>graphName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const int64\_t</td>
            <td><span><span>offset</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const int64\_t</td>
            <td><span><span>limit</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Retrieves node or edge entities from an existing graph, with pagination support via offset and limit. </p>
        <p>Use <a href="#a9debdae46b9cb8ce19f782d73a958c51">showGraph</a> to obtain the total number of nodes and edges.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>graphName</td>
                <td>Name of the graph from which to retrieve entities. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>offset</td>
                <td>Starting index of the entities to retrieve (0-based). The default value is 0. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>limit</td>
                <td>Number of entities to retrieve starting from <span>offset</span>. A value of -1 returns all entities from the offset to the end. Note: the <a href="/content/api/cpp/structgpudb_1_1GetGraphEntitiesResponse#a44bf7d173a8d88f14d3589ab46f37b65">entitiesInt</a> or <a href="/content/api/cpp/structgpudb_1_1GetGraphEntitiesResponse#aeb990f1a1e8c5d3b326cd9a25e72278e">entitiesString</a> array size will be 2x this value for nodes (stride 2) or 4x for edges (stride 4). The default value is 10000. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a2345820580392f2dbccc1b28d215e5a0">get\_graph\_entities\_entity\_type</a>: The type of entity to retrieve. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a4d16381ec71a2d7f4feee2369f21802b">get\_graph\_entities\_edge</a>: Retrieve edge entities (default). </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a696aae2efa2ebe46637e98aefe09237c">get\_graph\_entities\_node</a>: Retrieve node entities. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a4d16381ec71a2d7f4feee2369f21802b">get\_graph\_entities\_edge</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#ab50ee21961f648d580d24453c91ff2da">get\_graph\_entities\_server\_id</a>: Indicates which graph server to send the request to. Required when the graph is distributed across multiple servers. The default value is '0'. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a0f68beb9ed8678c5c7f481da0d3e3301">get\_graph\_entities\_concise\_edge\_connectivity</a>: When true, edges are emitted in a compact connectivity form regardless of the graph's identifier type: <a href="/content/api/cpp/structgpudb_1_1GetGraphEntitiesResponse#a44bf7d173a8d88f14d3589ab46f37b65">entitiesInt</a> contains stride-4 records \[edge\_id, node1\_index, node2\_index, edge\_label\_index] where node1\_index/node2\_index are 0-based positions into the node array (obtained from a node-entity call on the same graph). When requesting nodes with this option, the response includes tombstoned (deleted) slots in order to keep position indices stable so edge indices resolve correctly; deleted slots carry id=0 for integer graphs or an empty identifier for string/WKT graphs. For paginated node calls, subtract <span>offset</span> from an edge endpoint index to locate it within the returned page. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a86324b9933191bf4884d7861a71493e3">get\_graph\_entities\_true</a>: Compact integer connectivity for edges; deleted node slots included in node output. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aa0a47c74aba42ebff1ec88a0567f0a01">get\_graph\_entities\_false</a>: Default: edges emit node identifiers (int/string/WKT) matching the graph; deleted nodes are skipped. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#aa0a47c74aba42ebff1ec88a0567f0a01">get\_graph\_entities\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a0a4c968d1f2d30f7b826f7ea60a2dbd2">get\_graph\_entities\_include\_weights</a>: When true and <span>options</span> entityType is 'edge', the response <a href="/content/api/cpp/structgpudb_1_1GetGraphEntitiesResponse#acddf7d172e34c1d5dba5970ebfd1501a">entitiesWeight</a> array is populated with one float weight per emitted edge (aligned 1:1 with the edge records in <a href="/content/api/cpp/structgpudb_1_1GetGraphEntitiesResponse#a44bf7d173a8d88f14d3589ab46f37b65">entitiesInt</a> or <a href="/content/api/cpp/structgpudb_1_1GetGraphEntitiesResponse#aeb990f1a1e8c5d3b326cd9a25e72278e">entitiesString</a>). Empty when the graph has no weights component or when requesting nodes. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a86324b9933191bf4884d7861a71493e3">get\_graph\_entities\_true</a>: Populate <a href="/content/api/cpp/structgpudb_1_1GetGraphEntitiesResponse#acddf7d172e34c1d5dba5970ebfd1501a">entitiesWeight</a> with per-edge weights (edge requests only). </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aa0a47c74aba42ebff1ec88a0567f0a01">get\_graph\_entities\_false</a>: Default: <a href="/content/api/cpp/structgpudb_1_1GetGraphEntitiesResponse#acddf7d172e34c1d5dba5970ebfd1501a">entitiesWeight</a> is empty. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#aa0a47c74aba42ebff1ec88a0567f0a01">get\_graph\_entities\_false</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1GetGraphEntitiesResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a641d9be4063a18ae8970878abb94d0ed">◆ </a></span>getGraphEntities() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1GetGraphEntitiesResponse">GetGraphEntitiesResponse</a> & gpudb::GPUdb::getGraphEntities </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>graphName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const int64\_t</td>
            <td><span><span>offset</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const int64\_t</td>
            <td><span><span>limit</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1GetGraphEntitiesResponse">GetGraphEntitiesResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Retrieves node or edge entities from an existing graph, with pagination support via offset and limit. </p>
        <p>Use <a href="#a9debdae46b9cb8ce19f782d73a958c51">showGraph</a> to obtain the total number of nodes and edges.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>graphName</td>
                <td>Name of the graph from which to retrieve entities. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>offset</td>
                <td>Starting index of the entities to retrieve (0-based). The default value is 0. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>limit</td>
                <td>Number of entities to retrieve starting from <span>offset</span>. A value of -1 returns all entities from the offset to the end. Note: the <a href="/content/api/cpp/structgpudb_1_1GetGraphEntitiesResponse#a44bf7d173a8d88f14d3589ab46f37b65">entitiesInt</a> or <a href="/content/api/cpp/structgpudb_1_1GetGraphEntitiesResponse#aeb990f1a1e8c5d3b326cd9a25e72278e">entitiesString</a> array size will be 2x this value for nodes (stride 2) or 4x for edges (stride 4). The default value is 10000. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a2345820580392f2dbccc1b28d215e5a0">get\_graph\_entities\_entity\_type</a>: The type of entity to retrieve. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a4d16381ec71a2d7f4feee2369f21802b">get\_graph\_entities\_edge</a>: Retrieve edge entities (default). </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a696aae2efa2ebe46637e98aefe09237c">get\_graph\_entities\_node</a>: Retrieve node entities. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a4d16381ec71a2d7f4feee2369f21802b">get\_graph\_entities\_edge</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#ab50ee21961f648d580d24453c91ff2da">get\_graph\_entities\_server\_id</a>: Indicates which graph server to send the request to. Required when the graph is distributed across multiple servers. The default value is '0'. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a0f68beb9ed8678c5c7f481da0d3e3301">get\_graph\_entities\_concise\_edge\_connectivity</a>: When true, edges are emitted in a compact connectivity form regardless of the graph's identifier type: <a href="/content/api/cpp/structgpudb_1_1GetGraphEntitiesResponse#a44bf7d173a8d88f14d3589ab46f37b65">entitiesInt</a> contains stride-4 records \[edge\_id, node1\_index, node2\_index, edge\_label\_index] where node1\_index/node2\_index are 0-based positions into the node array (obtained from a node-entity call on the same graph). When requesting nodes with this option, the response includes tombstoned (deleted) slots in order to keep position indices stable so edge indices resolve correctly; deleted slots carry id=0 for integer graphs or an empty identifier for string/WKT graphs. For paginated node calls, subtract <span>offset</span> from an edge endpoint index to locate it within the returned page. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a86324b9933191bf4884d7861a71493e3">get\_graph\_entities\_true</a>: Compact integer connectivity for edges; deleted node slots included in node output. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aa0a47c74aba42ebff1ec88a0567f0a01">get\_graph\_entities\_false</a>: Default: edges emit node identifiers (int/string/WKT) matching the graph; deleted nodes are skipped. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#aa0a47c74aba42ebff1ec88a0567f0a01">get\_graph\_entities\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a0a4c968d1f2d30f7b826f7ea60a2dbd2">get\_graph\_entities\_include\_weights</a>: When true and <span>options</span> entityType is 'edge', the response <a href="/content/api/cpp/structgpudb_1_1GetGraphEntitiesResponse#acddf7d172e34c1d5dba5970ebfd1501a">entitiesWeight</a> array is populated with one float weight per emitted edge (aligned 1:1 with the edge records in <a href="/content/api/cpp/structgpudb_1_1GetGraphEntitiesResponse#a44bf7d173a8d88f14d3589ab46f37b65">entitiesInt</a> or <a href="/content/api/cpp/structgpudb_1_1GetGraphEntitiesResponse#aeb990f1a1e8c5d3b326cd9a25e72278e">entitiesString</a>). Empty when the graph has no weights component or when requesting nodes. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a86324b9933191bf4884d7861a71493e3">get\_graph\_entities\_true</a>: Populate <a href="/content/api/cpp/structgpudb_1_1GetGraphEntitiesResponse#acddf7d172e34c1d5dba5970ebfd1501a">entitiesWeight</a> with per-edge weights (edge requests only). </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aa0a47c74aba42ebff1ec88a0567f0a01">get\_graph\_entities\_false</a>: Default: <a href="/content/api/cpp/structgpudb_1_1GetGraphEntitiesResponse#acddf7d172e34c1d5dba5970ebfd1501a">entitiesWeight</a> is empty. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#aa0a47c74aba42ebff1ec88a0567f0a01">get\_graph\_entities\_false</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GetGraphEntitiesResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1GetGraphEntitiesResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ad9006419e63adde29e746b4bbcdbb662">◆ </a></span>getHASyncMode()</h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="#a37626bfbd9c5e1decfcd08d7851e6719">HASynchronicityMode</a> gpudb::GPUdb::getHASyncMode </td>
            <td>(</td>

            <td>
              <span>
                <span />
              </span>
            </td>

            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#aedb94510d202af0e406e36048fe226b7">◆ </a></span>getHmUrl()</h2>

    <div>
      <div>
        <table>
          <tr>
            <td>const <a href="/content/api/cpp/classgpudb_1_1HttpUrl">HttpUrl</a> & gpudb::GPUdb::getHmUrl </td>
            <td>(</td>

            <td>
              <span>
                <span />
              </span>
            </td>

            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#ac9beb72065758f970cfa07103ebda14b">◆ </a></span>getHmUrls()</h2>

    <div>
      <div>
        <table>
          <tr>
            <td>const std::vector\< <a href="/content/api/cpp/classgpudb_1_1HttpUrl">HttpUrl</a> > & gpudb::GPUdb::getHmUrls </td>
            <td>(</td>

            <td>
              <span>
                <span />
              </span>
            </td>

            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#a9a05888d893e2ca984609b1a836ae5ba">◆ </a></span>getHttpHeaders()</h2>

    <div>
      <div>
        <table>
          <tr>
            <td>const std::map\< std::string, std::string > & gpudb::GPUdb::getHttpHeaders </td>
            <td>(</td>

            <td>
              <span>
                <span />
              </span>
            </td>

            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#a0ff78cb10848a739067c5dbd0a052e05">◆ </a></span>getJob() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1GetJobResponse">GetJobResponse</a> gpudb::GPUdb::getJob </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1GetJobRequest">GetJobRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Get the status and result of asynchronously running job. </p>
        <p>See the <a href="#a02ef4c58e395bbf2c83325cf592397af">createJob</a> for starting an asynchronous job. Some fields of the response are filled only after the submitted job has finished execution.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GetJobRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1GetJobResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a3075e357878ca48139bfc2c938ea7ea6">◆ </a></span>getJob() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1GetJobResponse">GetJobResponse</a> & gpudb::GPUdb::getJob </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1GetJobRequest">GetJobRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1GetJobResponse">GetJobResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Get the status and result of asynchronously running job. </p>
        <p>See the <a href="#a02ef4c58e395bbf2c83325cf592397af">createJob</a> for starting an asynchronous job. Some fields of the response are filled only after the submitted job has finished execution.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GetJobRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GetJobResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1GetJobResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a8f46b312a6700634204dec278fe18b98">◆ </a></span>getJob() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1GetJobResponse">GetJobResponse</a> gpudb::GPUdb::getJob </td>
            <td>(</td>
            <td>const int64\_t</td>
            <td><span><span>jobId</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Get the status and result of asynchronously running job. </p>
        <p>See the <a href="#a2807b0831529b2f2e6fb554339670763">createJob</a> for starting an asynchronous job. Some fields of the response are filled only after the submitted job has finished execution.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>jobId</td>
                <td>A unique identifier for the job whose status and result is to be fetched. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a6b2cf934b6bb6c44e5528261e911206b">get\_job\_job\_tag</a>: Job tag returned in call to create the job. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1GetJobResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ab851aa12144cb49427033f0331b10391">◆ </a></span>getJob() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1GetJobResponse">GetJobResponse</a> & gpudb::GPUdb::getJob </td>
            <td>(</td>
            <td>const int64\_t</td>
            <td><span><span>jobId</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1GetJobResponse">GetJobResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Get the status and result of asynchronously running job. </p>
        <p>See the <a href="#a2807b0831529b2f2e6fb554339670763">createJob</a> for starting an asynchronous job. Some fields of the response are filled only after the submitted job has finished execution.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>jobId</td>
                <td>A unique identifier for the job whose status and result is to be fetched. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a6b2cf934b6bb6c44e5528261e911206b">get\_job\_job\_tag</a>: Job tag returned in call to create the job. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GetJobResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1GetJobResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#aaf15e54f08d002b4b1dfa570918526d3">◆ </a></span>getOauthToken()</h2>

    <div>
      <div>
        <table>
          <tr>
            <td>const std::string & gpudb::GPUdb::getOauthToken </td>
            <td>(</td>

            <td>
              <span>
                <span />
              </span>
            </td>

            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#a1408de75febd5b6a75600bdf21dcb40e">◆ </a></span>getPassword()</h2>

    <div>
      <div>
        <table>
          <tr>
            <td>const std::string & gpudb::GPUdb::getPassword </td>
            <td>(</td>

            <td>
              <span>
                <span />
              </span>
            </td>

            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#a8b68c97b6284dcf9de059343f79feee7">◆ </a></span>getPrimaryURL()</h2>

    <div>
      <div>
        <table>
          <tr>
            <td>const std::string & gpudb::GPUdb::getPrimaryURL </td>
            <td>(</td>

            <td>
              <span>
                <span />
              </span>
            </td>

            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Return a string containing the URL for the primary cluster; empty string otherwise. </p>
      </div>
    </div>

    <h2><span><a href="#a107efac13be55b48d53e2d96a3bdff7a">◆ </a></span>getRecords() <span>\[1/20]</span></h2>

    <div>
      <div>
        <div> template\<typename TResponse> </div>

        <table>
          <tr>
            <td>
              <table>
                <tr>
                  <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsResponse">GetRecordsResponse</a>\< TResponse > gpudb::GPUdb::getRecords </td>
                  <td>(</td>
                  <td>const ::avro::ValidSchema &</td>
                  <td><span><span>schema\_</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const <a href="/content/api/cpp/structgpudb_1_1GetRecordsRequest">GetRecordsRequest</a> &</td>
                  <td><span><span>request\_</span></span> ) const</td>
                </tr>
              </table>
            </td>

            <td> <span><span>inline</span></span> </td>
          </tr>
        </table>
      </div>

      <div>
        <p>Retrieves records from a given table, optionally filtered by an expression and/or sorted by a column. </p>
        <p>This operation can be performed on tables and views. Records can be returned encoded as binary, json, or geojson.</p>
        <p>This operation supports paging through the data via the <a href="/content/api/cpp/structgpudb_1_1GetRecordsRequest#a6f8fde526abfe2adc4845bd4582f96a5">offset</a> and <a href="/content/api/cpp/structgpudb_1_1GetRecordsRequest#a88646356abf331176d438e0e435cae79">limit</a> parameters. Note that when paging through a table, if the table (or the underlying table in case of a view) is updated (records are inserted, deleted or modified) the records retrieved may differ between calls based on the updates applied.</p>

        <div>
          <div>Template Parameters</div>

          <div>
            <table>
              <tr>
                <td>TResponse</td>
                <td>The type of object being retrieved.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>schema\_</td>
                <td>Avro schema object used for decoding returned objects. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1GetRecordsResponse">Response</a> object containing the result of the operation. </div>
        </div>

        <p>Definition at line <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">32295</a> of file <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">GPUdb.hpp</a>.</p>
      </div>
    </div>

    <h2><span><a href="#a82359502778b3d1f8f107021bea19eb0">◆ </a></span>getRecords() <span>\[2/20]</span></h2>

    <div>
      <div>
        <div> template\<typename TResponse> </div>

        <table>
          <tr>
            <td>
              <table>
                <tr>
                  <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsResponse">GetRecordsResponse</a>\< TResponse > & gpudb::GPUdb::getRecords </td>
                  <td>(</td>
                  <td>const ::avro::ValidSchema &</td>
                  <td><span><span>schema\_</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const <a href="/content/api/cpp/structgpudb_1_1GetRecordsRequest">GetRecordsRequest</a> &</td>
                  <td><span><span>request\_</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsResponse">GetRecordsResponse</a>\< TResponse > &</td>
                  <td><span><span>response\_</span></span> ) const</td>
                </tr>
              </table>
            </td>

            <td> <span><span>inline</span></span> </td>
          </tr>
        </table>
      </div>

      <div>
        <p>Retrieves records from a given table, optionally filtered by an expression and/or sorted by a column. </p>
        <p>This operation can be performed on tables and views. Records can be returned encoded as binary, json, or geojson.</p>
        <p>This operation supports paging through the data via the <a href="/content/api/cpp/structgpudb_1_1GetRecordsRequest#a6f8fde526abfe2adc4845bd4582f96a5">offset</a> and <a href="/content/api/cpp/structgpudb_1_1GetRecordsRequest#a88646356abf331176d438e0e435cae79">limit</a> parameters. Note that when paging through a table, if the table (or the underlying table in case of a view) is updated (records are inserted, deleted or modified) the records retrieved may differ between calls based on the updates applied.</p>

        <div>
          <div>Template Parameters</div>

          <div>
            <table>
              <tr>
                <td>TResponse</td>
                <td>The type of object being retrieved.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>schema\_</td>
                <td>Avro schema object used for decoding returned objects. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1GetRecordsResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>

        <p>Definition at line <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">32381</a> of file <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">GPUdb.hpp</a>.</p>
      </div>
    </div>

    <h2><span><a href="#a2343e4363db89e8d9af6c93984e17dd9">◆ </a></span>getRecords() <span>\[3/20]</span></h2>

    <div>
      <div>
        <div> template\<typename TResponse> </div>

        <table>
          <tr>
            <td>
              <table>
                <tr>
                  <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsResponse">GetRecordsResponse</a>\< TResponse > gpudb::GPUdb::getRecords </td>
                  <td>(</td>
                  <td>const ::avro::ValidSchema &</td>
                  <td><span><span>schema\_</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const std::string &</td>
                  <td><span><span>tableName</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const int64\_t</td>
                  <td><span><span>offset</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const int64\_t</td>
                  <td><span><span>limit</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const std::map\< std::string, std::string > &</td>
                  <td><span><span>options</span></span> ) const</td>
                </tr>
              </table>
            </td>

            <td> <span><span>inline</span></span> </td>
          </tr>
        </table>
      </div>

      <div>
        <p>Retrieves records from a given table, optionally filtered by an expression and/or sorted by a column. </p>
        <p>This operation can be performed on tables and views. Records can be returned encoded as binary, json, or geojson.</p>
        <p>This operation supports paging through the data via the <span>offset</span> and <span>limit</span> parameters. Note that when paging through a table, if the table (or the underlying table in case of a view) is updated (records are inserted, deleted or modified) the records retrieved may differ between calls based on the updates applied.</p>

        <div>
          <div>Template Parameters</div>

          <div>
            <table>
              <tr>
                <td>TResponse</td>
                <td>The type of object being retrieved.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>schema\_</td>
                <td>Avro schema object used for decoding returned objects. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of the table or view from which the records will be fetched, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>offset</td>
                <td>A positive integer indicating the number of initial results to skip (this can be useful for paging through the results). The default value is 0. The minimum allowed value is 0. The maximum allowed value is MAX\_INT. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>limit</td>
                <td>A positive integer indicating the maximum number of results to be returned, or END\_OF\_SET (-9999) to indicate that the maximum number of results allowed by the server should be returned. The number of records returned will never exceed the server's own limit, defined by the <a href="/content/config/#config-main-general">max\_get\_records\_size</a> parameter in the server configuration. Use <a href="/content/api/cpp/structgpudb_1_1RawGetRecordsResponse#addc876a47152c62651f0ea49a111aa01">hasMoreRecords</a> to see if more records exist in the result to be fetched, and <span>offset</span> and <span>limit</span> to request subsequent pages of results. The default value is -9999. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#aa8ba8bada1e52234e73e49baae769873">get\_records\_expression</a>: Filter expression to apply to the table. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a9c995a38a96b7de5d4226fa88f1f2db1">get\_records\_fast\_index\_lookup</a>: Indicates if indexes should be used to perform the lookup for a given expression if possible. Only applicable if there is no sorting, the expression contains only equivalence comparisons based on existing tables indexes and the range of requested values is from \[0 to END\_OF\_SET]. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a6cfed3eb927ab25c3d84e9bc0f397fa7">get\_records\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a0871a7dadb765359372fbf2092aa6aa9">get\_records\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a6cfed3eb927ab25c3d84e9bc0f397fa7">get\_records\_true</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a6d56a39a602bbd41f34dd180c79b7861">get\_records\_sort\_by</a>: Column that the data should be sorted by. Empty by default (i.e. no sorting is applied). </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a3c6e717cdfc28d37c01f81ec1d4b3644">get\_records\_sort\_order</a>: String indicating how the returned values should be sorted - ascending or descending. If sort\_order is provided, sort\_by has to be provided. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a252c2b87591ffcea13037694610628da">get\_records\_ascending</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a20834c9af1c9f43ff9c6fd9f9695fb17">get\_records\_descending</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a252c2b87591ffcea13037694610628da">get\_records\_ascending</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1GetRecordsResponse">Response</a> object containing the result of the operation. </div>
        </div>

        <p>Definition at line <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">32528</a> of file <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">GPUdb.hpp</a>.</p>
      </div>
    </div>

    <h2><span><a href="#a64e3d2d06072159f665db02159b1e1ca">◆ </a></span>getRecords() <span>\[4/20]</span></h2>

    <div>
      <div>
        <div> template\<typename TResponse> </div>

        <table>
          <tr>
            <td>
              <table>
                <tr>
                  <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsResponse">GetRecordsResponse</a>\< TResponse > & gpudb::GPUdb::getRecords </td>
                  <td>(</td>
                  <td>const ::avro::ValidSchema &</td>
                  <td><span><span>schema\_</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const std::string &</td>
                  <td><span><span>tableName</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const int64\_t</td>
                  <td><span><span>offset</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const int64\_t</td>
                  <td><span><span>limit</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const std::map\< std::string, std::string > &</td>
                  <td><span><span>options</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsResponse">GetRecordsResponse</a>\< TResponse > &</td>
                  <td><span><span>response\_</span></span> ) const</td>
                </tr>
              </table>
            </td>

            <td> <span><span>inline</span></span> </td>
          </tr>
        </table>
      </div>

      <div>
        <p>Retrieves records from a given table, optionally filtered by an expression and/or sorted by a column. </p>
        <p>This operation can be performed on tables and views. Records can be returned encoded as binary, json, or geojson.</p>
        <p>This operation supports paging through the data via the <span>offset</span> and <span>limit</span> parameters. Note that when paging through a table, if the table (or the underlying table in case of a view) is updated (records are inserted, deleted or modified) the records retrieved may differ between calls based on the updates applied.</p>

        <div>
          <div>Template Parameters</div>

          <div>
            <table>
              <tr>
                <td>TResponse</td>
                <td>The type of object being retrieved.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>schema\_</td>
                <td>Avro schema object used for decoding returned objects. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of the table or view from which the records will be fetched, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>offset</td>
                <td>A positive integer indicating the number of initial results to skip (this can be useful for paging through the results). The default value is 0. The minimum allowed value is 0. The maximum allowed value is MAX\_INT. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>limit</td>
                <td>A positive integer indicating the maximum number of results to be returned, or END\_OF\_SET (-9999) to indicate that the maximum number of results allowed by the server should be returned. The number of records returned will never exceed the server's own limit, defined by the <a href="/content/config/#config-main-general">max\_get\_records\_size</a> parameter in the server configuration. Use <a href="/content/api/cpp/structgpudb_1_1RawGetRecordsResponse#addc876a47152c62651f0ea49a111aa01">hasMoreRecords</a> to see if more records exist in the result to be fetched, and <span>offset</span> and <span>limit</span> to request subsequent pages of results. The default value is -9999. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#aa8ba8bada1e52234e73e49baae769873">get\_records\_expression</a>: Filter expression to apply to the table. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a9c995a38a96b7de5d4226fa88f1f2db1">get\_records\_fast\_index\_lookup</a>: Indicates if indexes should be used to perform the lookup for a given expression if possible. Only applicable if there is no sorting, the expression contains only equivalence comparisons based on existing tables indexes and the range of requested values is from \[0 to END\_OF\_SET]. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a6cfed3eb927ab25c3d84e9bc0f397fa7">get\_records\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a0871a7dadb765359372fbf2092aa6aa9">get\_records\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a6cfed3eb927ab25c3d84e9bc0f397fa7">get\_records\_true</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a6d56a39a602bbd41f34dd180c79b7861">get\_records\_sort\_by</a>: Column that the data should be sorted by. Empty by default (i.e. no sorting is applied). </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a3c6e717cdfc28d37c01f81ec1d4b3644">get\_records\_sort\_order</a>: String indicating how the returned values should be sorted - ascending or descending. If sort\_order is provided, sort\_by has to be provided. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a252c2b87591ffcea13037694610628da">get\_records\_ascending</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a20834c9af1c9f43ff9c6fd9f9695fb17">get\_records\_descending</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a252c2b87591ffcea13037694610628da">get\_records\_ascending</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1GetRecordsResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>

        <p>Definition at line <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">32746</a> of file <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">GPUdb.hpp</a>.</p>
      </div>
    </div>

    <h2><span><a href="#a32de6c3fa89b56e5c573cf04bbbafabb">◆ </a></span>getRecords() <span>\[5/20]</span></h2>

    <div>
      <div>
        <div> template\<typename TResponse> </div>

        <table>
          <tr>
            <td>
              <table>
                <tr>
                  <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsResponse">GetRecordsResponse</a>\< TResponse > gpudb::GPUdb::getRecords </td>
                  <td>(</td>
                  <td>const <a href="/content/api/cpp/structgpudb_1_1GetRecordsRequest">GetRecordsRequest</a> &</td>
                  <td><span><span>request\_</span></span></td>
                  <td>)</td>
                  <td> const</td>
                </tr>
              </table>
            </td>

            <td> <span><span>inline</span></span> </td>
          </tr>
        </table>
      </div>

      <div>
        <p>Retrieves records from a given table, optionally filtered by an expression and/or sorted by a column. </p>
        <p>This operation can be performed on tables and views. Records can be returned encoded as binary, json, or geojson.</p>
        <p>This operation supports paging through the data via the <a href="/content/api/cpp/structgpudb_1_1GetRecordsRequest#a6f8fde526abfe2adc4845bd4582f96a5">offset</a> and <a href="/content/api/cpp/structgpudb_1_1GetRecordsRequest#a88646356abf331176d438e0e435cae79">limit</a> parameters. Note that when paging through a table, if the table (or the underlying table in case of a view) is updated (records are inserted, deleted or modified) the records retrieved may differ between calls based on the updates applied.</p>

        <div>
          <div>Template Parameters</div>

          <div>
            <table>
              <tr>
                <td>TResponse</td>
                <td>The type of object being retrieved.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1GetRecordsResponse">Response</a> object containing the result of the operation. </div>
        </div>

        <p>Definition at line <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">31998</a> of file <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">GPUdb.hpp</a>.</p>
      </div>
    </div>

    <h2><span><a href="#a204d2b665c241c66b952293d9d65ec38">◆ </a></span>getRecords() <span>\[6/20]</span></h2>

    <div>
      <div>
        <div> template\<> </div>

        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsResponse">GetRecordsResponse</a>\< boost::any > gpudb::GPUdb::getRecords </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1GetRecordsRequest">GetRecordsRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Retrieves records from a given table, optionally filtered by an expression and/or sorted by a column. </p>
        <p>This operation can be performed on tables and views. Records can be returned encoded as binary, json, or geojson.</p>
        <p>This operation supports paging through the data via the <a href="/content/api/cpp/structgpudb_1_1GetRecordsRequest#a6f8fde526abfe2adc4845bd4582f96a5">offset</a> and <a href="/content/api/cpp/structgpudb_1_1GetRecordsRequest#a88646356abf331176d438e0e435cae79">limit</a> parameters. Note that when paging through a table, if the table (or the underlying table in case of a view) is updated (records are inserted, deleted or modified) the records retrieved may differ between calls based on the updates applied.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1GetRecordsResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a204d2b665c241c66b952293d9d65ec38">◆ </a></span>getRecords() <span>\[7/20]</span></h2>

    <div>
      <div>
        <div> template\<> </div>

        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsResponse">GetRecordsResponse</a>\< boost::any > gpudb::GPUdb::getRecords </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1GetRecordsRequest">GetRecordsRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Retrieves records from a given table, optionally filtered by an expression and/or sorted by a column. </p>
        <p>This operation can be performed on tables and views. Records can be returned encoded as binary, json, or geojson.</p>
        <p>This operation supports paging through the data via the <a href="/content/api/cpp/structgpudb_1_1GetRecordsRequest#a6f8fde526abfe2adc4845bd4582f96a5">offset</a> and <a href="/content/api/cpp/structgpudb_1_1GetRecordsRequest#a88646356abf331176d438e0e435cae79">limit</a> parameters. Note that when paging through a table, if the table (or the underlying table in case of a view) is updated (records are inserted, deleted or modified) the records retrieved may differ between calls based on the updates applied.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1GetRecordsResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#afc3176fa3a92ad385f38d919715c66f8">◆ </a></span>getRecords() <span>\[8/20]</span></h2>

    <div>
      <div>
        <div> template\<> </div>

        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsResponse">GetRecordsResponse</a>\< boost::any > & gpudb::GPUdb::getRecords </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1GetRecordsRequest">GetRecordsRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsResponse">GetRecordsResponse</a>\< boost::any > &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Retrieves records from a given table, optionally filtered by an expression and/or sorted by a column. </p>
        <p>This operation can be performed on tables and views. Records can be returned encoded as binary, json, or geojson.</p>
        <p>This operation supports paging through the data via the <a href="/content/api/cpp/structgpudb_1_1GetRecordsRequest#a6f8fde526abfe2adc4845bd4582f96a5">offset</a> and <a href="/content/api/cpp/structgpudb_1_1GetRecordsRequest#a88646356abf331176d438e0e435cae79">limit</a> parameters. Note that when paging through a table, if the table (or the underlying table in case of a view) is updated (records are inserted, deleted or modified) the records retrieved may differ between calls based on the updates applied.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1GetRecordsResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#afc3176fa3a92ad385f38d919715c66f8">◆ </a></span>getRecords() <span>\[9/20]</span></h2>

    <div>
      <div>
        <div> template\<> </div>

        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsResponse">GetRecordsResponse</a>\< boost::any > & gpudb::GPUdb::getRecords </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1GetRecordsRequest">GetRecordsRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsResponse">GetRecordsResponse</a>\< boost::any > &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Retrieves records from a given table, optionally filtered by an expression and/or sorted by a column. </p>
        <p>This operation can be performed on tables and views. Records can be returned encoded as binary, json, or geojson.</p>
        <p>This operation supports paging through the data via the <a href="/content/api/cpp/structgpudb_1_1GetRecordsRequest#a6f8fde526abfe2adc4845bd4582f96a5">offset</a> and <a href="/content/api/cpp/structgpudb_1_1GetRecordsRequest#a88646356abf331176d438e0e435cae79">limit</a> parameters. Note that when paging through a table, if the table (or the underlying table in case of a view) is updated (records are inserted, deleted or modified) the records retrieved may differ between calls based on the updates applied.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1GetRecordsResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a2c704c2004c307792fd6883a1b6d7503">◆ </a></span>getRecords() <span>\[10/20]</span></h2>

    <div>
      <div>
        <div> template\<typename TResponse> </div>

        <table>
          <tr>
            <td>
              <table>
                <tr>
                  <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsResponse">GetRecordsResponse</a>\< TResponse > & gpudb::GPUdb::getRecords </td>
                  <td>(</td>
                  <td>const <a href="/content/api/cpp/structgpudb_1_1GetRecordsRequest">GetRecordsRequest</a> &</td>
                  <td><span><span>request\_</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsResponse">GetRecordsResponse</a>\< TResponse > &</td>
                  <td><span><span>response\_</span></span> ) const</td>
                </tr>
              </table>
            </td>

            <td> <span><span>inline</span></span> </td>
          </tr>
        </table>
      </div>

      <div>
        <p>Retrieves records from a given table, optionally filtered by an expression and/or sorted by a column. </p>
        <p>This operation can be performed on tables and views. Records can be returned encoded as binary, json, or geojson.</p>
        <p>This operation supports paging through the data via the <a href="/content/api/cpp/structgpudb_1_1GetRecordsRequest#a6f8fde526abfe2adc4845bd4582f96a5">offset</a> and <a href="/content/api/cpp/structgpudb_1_1GetRecordsRequest#a88646356abf331176d438e0e435cae79">limit</a> parameters. Note that when paging through a table, if the table (or the underlying table in case of a view) is updated (records are inserted, deleted or modified) the records retrieved may differ between calls based on the updates applied.</p>

        <div>
          <div>Template Parameters</div>

          <div>
            <table>
              <tr>
                <td>TResponse</td>
                <td>The type of object being retrieved.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1GetRecordsResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>

        <p>Definition at line <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">32040</a> of file <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">GPUdb.hpp</a>.</p>
      </div>
    </div>

    <h2><span><a href="#a6b39d1540501defd2bdb03feed7928f8">◆ </a></span>getRecords() <span>\[11/20]</span></h2>

    <div>
      <div>
        <div> template\<typename TResponse> </div>

        <table>
          <tr>
            <td>
              <table>
                <tr>
                  <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsResponse">GetRecordsResponse</a>\< TResponse > gpudb::GPUdb::getRecords </td>
                  <td>(</td>
                  <td>const std::string &</td>
                  <td><span><span>tableName</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const int64\_t</td>
                  <td><span><span>offset</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const int64\_t</td>
                  <td><span><span>limit</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const std::map\< std::string, std::string > &</td>
                  <td><span><span>options</span></span> ) const</td>
                </tr>
              </table>
            </td>

            <td> <span><span>inline</span></span> </td>
          </tr>
        </table>
      </div>

      <div>
        <p>Retrieves records from a given table, optionally filtered by an expression and/or sorted by a column. </p>
        <p>This operation can be performed on tables and views. Records can be returned encoded as binary, json, or geojson.</p>
        <p>This operation supports paging through the data via the <span>offset</span> and <span>limit</span> parameters. Note that when paging through a table, if the table (or the underlying table in case of a view) is updated (records are inserted, deleted or modified) the records retrieved may differ between calls based on the updates applied.</p>

        <div>
          <div>Template Parameters</div>

          <div>
            <table>
              <tr>
                <td>TResponse</td>
                <td>The type of object being retrieved.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of the table or view from which the records will be fetched, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>offset</td>
                <td>A positive integer indicating the number of initial results to skip (this can be useful for paging through the results). The default value is 0. The minimum allowed value is 0. The maximum allowed value is MAX\_INT. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>limit</td>
                <td>A positive integer indicating the maximum number of results to be returned, or END\_OF\_SET (-9999) to indicate that the maximum number of results allowed by the server should be returned. The number of records returned will never exceed the server's own limit, defined by the <a href="/content/config/#config-main-general">max\_get\_records\_size</a> parameter in the server configuration. Use <a href="/content/api/cpp/structgpudb_1_1RawGetRecordsResponse#addc876a47152c62651f0ea49a111aa01">hasMoreRecords</a> to see if more records exist in the result to be fetched, and <span>offset</span> and <span>limit</span> to request subsequent pages of results. The default value is -9999. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#aa8ba8bada1e52234e73e49baae769873">get\_records\_expression</a>: Filter expression to apply to the table. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a9c995a38a96b7de5d4226fa88f1f2db1">get\_records\_fast\_index\_lookup</a>: Indicates if indexes should be used to perform the lookup for a given expression if possible. Only applicable if there is no sorting, the expression contains only equivalence comparisons based on existing tables indexes and the range of requested values is from \[0 to END\_OF\_SET]. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a6cfed3eb927ab25c3d84e9bc0f397fa7">get\_records\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a0871a7dadb765359372fbf2092aa6aa9">get\_records\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a6cfed3eb927ab25c3d84e9bc0f397fa7">get\_records\_true</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a6d56a39a602bbd41f34dd180c79b7861">get\_records\_sort\_by</a>: Column that the data should be sorted by. Empty by default (i.e. no sorting is applied). </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a3c6e717cdfc28d37c01f81ec1d4b3644">get\_records\_sort\_order</a>: String indicating how the returned values should be sorted - ascending or descending. If sort\_order is provided, sort\_by has to be provided. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a252c2b87591ffcea13037694610628da">get\_records\_ascending</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a20834c9af1c9f43ff9c6fd9f9695fb17">get\_records\_descending</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a252c2b87591ffcea13037694610628da">get\_records\_ascending</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1GetRecordsResponse">Response</a> object containing the result of the operation. </div>
        </div>

        <p>Definition at line <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">32141</a> of file <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">GPUdb.hpp</a>.</p>
      </div>
    </div>

    <h2><span><a href="#a107ec3b0e2c145dfa5d270a6b33e84dd">◆ </a></span>getRecords() <span>\[12/20]</span></h2>

    <div>
      <div>
        <div> template\<> </div>

        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsResponse">GetRecordsResponse</a>\< boost::any > gpudb::GPUdb::getRecords </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const int64\_t</td>
            <td><span><span>offset</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const int64\_t</td>
            <td><span><span>limit</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Retrieves records from a given table, optionally filtered by an expression and/or sorted by a column. </p>
        <p>This operation can be performed on tables and views. Records can be returned encoded as binary, json, or geojson.</p>
        <p>This operation supports paging through the data via the <span>offset</span> and <span>limit</span> parameters. Note that when paging through a table, if the table (or the underlying table in case of a view) is updated (records are inserted, deleted or modified) the records retrieved may differ between calls based on the updates applied.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of the table or view from which the records will be fetched, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>offset</td>
                <td>A positive integer indicating the number of initial results to skip (this can be useful for paging through the results). The default value is 0. The minimum allowed value is 0. The maximum allowed value is MAX\_INT. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>limit</td>
                <td>A positive integer indicating the maximum number of results to be returned, or END\_OF\_SET (-9999) to indicate that the maximum number of results allowed by the server should be returned. The number of records returned will never exceed the server's own limit, defined by the <a href="/content/config/#config-main-general">max\_get\_records\_size</a> parameter in the server configuration. Use <a href="/content/api/cpp/structgpudb_1_1RawGetRecordsResponse#addc876a47152c62651f0ea49a111aa01">hasMoreRecords</a> to see if more records exist in the result to be fetched, and <span>offset</span> and <span>limit</span> to request subsequent pages of results. The default value is -9999. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#aa8ba8bada1e52234e73e49baae769873">get\_records\_expression</a>: Filter expression to apply to the table. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a9c995a38a96b7de5d4226fa88f1f2db1">get\_records\_fast\_index\_lookup</a>: Indicates if indexes should be used to perform the lookup for a given expression if possible. Only applicable if there is no sorting, the expression contains only equivalence comparisons based on existing tables indexes and the range of requested values is from \[0 to END\_OF\_SET]. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a6cfed3eb927ab25c3d84e9bc0f397fa7">get\_records\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a0871a7dadb765359372fbf2092aa6aa9">get\_records\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a6cfed3eb927ab25c3d84e9bc0f397fa7">get\_records\_true</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a6d56a39a602bbd41f34dd180c79b7861">get\_records\_sort\_by</a>: Column that the data should be sorted by. Empty by default (i.e. no sorting is applied). </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a3c6e717cdfc28d37c01f81ec1d4b3644">get\_records\_sort\_order</a>: String indicating how the returned values should be sorted - ascending or descending. If sort\_order is provided, sort\_by has to be provided. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a252c2b87591ffcea13037694610628da">get\_records\_ascending</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a20834c9af1c9f43ff9c6fd9f9695fb17">get\_records\_descending</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a252c2b87591ffcea13037694610628da">get\_records\_ascending</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1GetRecordsResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a107ec3b0e2c145dfa5d270a6b33e84dd">◆ </a></span>getRecords() <span>\[13/20]</span></h2>

    <div>
      <div>
        <div> template\<> </div>

        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsResponse">GetRecordsResponse</a>\< boost::any > gpudb::GPUdb::getRecords </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const int64\_t</td>
            <td><span><span>offset</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const int64\_t</td>
            <td><span><span>limit</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Retrieves records from a given table, optionally filtered by an expression and/or sorted by a column. </p>
        <p>This operation can be performed on tables and views. Records can be returned encoded as binary, json, or geojson.</p>
        <p>This operation supports paging through the data via the <span>offset</span> and <span>limit</span> parameters. Note that when paging through a table, if the table (or the underlying table in case of a view) is updated (records are inserted, deleted or modified) the records retrieved may differ between calls based on the updates applied.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of the table or view from which the records will be fetched, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>offset</td>
                <td>A positive integer indicating the number of initial results to skip (this can be useful for paging through the results). The default value is 0. The minimum allowed value is 0. The maximum allowed value is MAX\_INT. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>limit</td>
                <td>A positive integer indicating the maximum number of results to be returned, or END\_OF\_SET (-9999) to indicate that the maximum number of results allowed by the server should be returned. The number of records returned will never exceed the server's own limit, defined by the <a href="/content/config/#config-main-general">max\_get\_records\_size</a> parameter in the server configuration. Use <a href="/content/api/cpp/structgpudb_1_1RawGetRecordsResponse#addc876a47152c62651f0ea49a111aa01">hasMoreRecords</a> to see if more records exist in the result to be fetched, and <span>offset</span> and <span>limit</span> to request subsequent pages of results. The default value is -9999. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#aa8ba8bada1e52234e73e49baae769873">get\_records\_expression</a>: Filter expression to apply to the table. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a9c995a38a96b7de5d4226fa88f1f2db1">get\_records\_fast\_index\_lookup</a>: Indicates if indexes should be used to perform the lookup for a given expression if possible. Only applicable if there is no sorting, the expression contains only equivalence comparisons based on existing tables indexes and the range of requested values is from \[0 to END\_OF\_SET]. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a6cfed3eb927ab25c3d84e9bc0f397fa7">get\_records\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a0871a7dadb765359372fbf2092aa6aa9">get\_records\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a6cfed3eb927ab25c3d84e9bc0f397fa7">get\_records\_true</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a6d56a39a602bbd41f34dd180c79b7861">get\_records\_sort\_by</a>: Column that the data should be sorted by. Empty by default (i.e. no sorting is applied). </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a3c6e717cdfc28d37c01f81ec1d4b3644">get\_records\_sort\_order</a>: String indicating how the returned values should be sorted - ascending or descending. If sort\_order is provided, sort\_by has to be provided. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a252c2b87591ffcea13037694610628da">get\_records\_ascending</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a20834c9af1c9f43ff9c6fd9f9695fb17">get\_records\_descending</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a252c2b87591ffcea13037694610628da">get\_records\_ascending</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1GetRecordsResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a8f7abc694bbb4922746cc565234cbe08">◆ </a></span>getRecords() <span>\[14/20]</span></h2>

    <div>
      <div>
        <div> template\<> </div>

        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsResponse">GetRecordsResponse</a>\< boost::any > & gpudb::GPUdb::getRecords </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const int64\_t</td>
            <td><span><span>offset</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const int64\_t</td>
            <td><span><span>limit</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsResponse">GetRecordsResponse</a>\< boost::any > &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Retrieves records from a given table, optionally filtered by an expression and/or sorted by a column. </p>
        <p>This operation can be performed on tables and views. Records can be returned encoded as binary, json, or geojson.</p>
        <p>This operation supports paging through the data via the <span>offset</span> and <span>limit</span> parameters. Note that when paging through a table, if the table (or the underlying table in case of a view) is updated (records are inserted, deleted or modified) the records retrieved may differ between calls based on the updates applied.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of the table or view from which the records will be fetched, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>offset</td>
                <td>A positive integer indicating the number of initial results to skip (this can be useful for paging through the results). The default value is 0. The minimum allowed value is 0. The maximum allowed value is MAX\_INT. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>limit</td>
                <td>A positive integer indicating the maximum number of results to be returned, or END\_OF\_SET (-9999) to indicate that the maximum number of results allowed by the server should be returned. The number of records returned will never exceed the server's own limit, defined by the <a href="/content/config/#config-main-general">max\_get\_records\_size</a> parameter in the server configuration. Use <a href="/content/api/cpp/structgpudb_1_1RawGetRecordsResponse#addc876a47152c62651f0ea49a111aa01">hasMoreRecords</a> to see if more records exist in the result to be fetched, and <span>offset</span> and <span>limit</span> to request subsequent pages of results. The default value is -9999. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#aa8ba8bada1e52234e73e49baae769873">get\_records\_expression</a>: Filter expression to apply to the table. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a9c995a38a96b7de5d4226fa88f1f2db1">get\_records\_fast\_index\_lookup</a>: Indicates if indexes should be used to perform the lookup for a given expression if possible. Only applicable if there is no sorting, the expression contains only equivalence comparisons based on existing tables indexes and the range of requested values is from \[0 to END\_OF\_SET]. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a6cfed3eb927ab25c3d84e9bc0f397fa7">get\_records\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a0871a7dadb765359372fbf2092aa6aa9">get\_records\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a6cfed3eb927ab25c3d84e9bc0f397fa7">get\_records\_true</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a6d56a39a602bbd41f34dd180c79b7861">get\_records\_sort\_by</a>: Column that the data should be sorted by. Empty by default (i.e. no sorting is applied). </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a3c6e717cdfc28d37c01f81ec1d4b3644">get\_records\_sort\_order</a>: String indicating how the returned values should be sorted - ascending or descending. If sort\_order is provided, sort\_by has to be provided. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a252c2b87591ffcea13037694610628da">get\_records\_ascending</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a20834c9af1c9f43ff9c6fd9f9695fb17">get\_records\_descending</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a252c2b87591ffcea13037694610628da">get\_records\_ascending</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1GetRecordsResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a8f7abc694bbb4922746cc565234cbe08">◆ </a></span>getRecords() <span>\[15/20]</span></h2>

    <div>
      <div>
        <div> template\<> </div>

        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsResponse">GetRecordsResponse</a>\< boost::any > & gpudb::GPUdb::getRecords </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const int64\_t</td>
            <td><span><span>offset</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const int64\_t</td>
            <td><span><span>limit</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsResponse">GetRecordsResponse</a>\< boost::any > &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Retrieves records from a given table, optionally filtered by an expression and/or sorted by a column. </p>
        <p>This operation can be performed on tables and views. Records can be returned encoded as binary, json, or geojson.</p>
        <p>This operation supports paging through the data via the <span>offset</span> and <span>limit</span> parameters. Note that when paging through a table, if the table (or the underlying table in case of a view) is updated (records are inserted, deleted or modified) the records retrieved may differ between calls based on the updates applied.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of the table or view from which the records will be fetched, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>offset</td>
                <td>A positive integer indicating the number of initial results to skip (this can be useful for paging through the results). The default value is 0. The minimum allowed value is 0. The maximum allowed value is MAX\_INT. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>limit</td>
                <td>A positive integer indicating the maximum number of results to be returned, or END\_OF\_SET (-9999) to indicate that the maximum number of results allowed by the server should be returned. The number of records returned will never exceed the server's own limit, defined by the <a href="/content/config/#config-main-general">max\_get\_records\_size</a> parameter in the server configuration. Use <a href="/content/api/cpp/structgpudb_1_1RawGetRecordsResponse#addc876a47152c62651f0ea49a111aa01">hasMoreRecords</a> to see if more records exist in the result to be fetched, and <span>offset</span> and <span>limit</span> to request subsequent pages of results. The default value is -9999. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#aa8ba8bada1e52234e73e49baae769873">get\_records\_expression</a>: Filter expression to apply to the table. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a9c995a38a96b7de5d4226fa88f1f2db1">get\_records\_fast\_index\_lookup</a>: Indicates if indexes should be used to perform the lookup for a given expression if possible. Only applicable if there is no sorting, the expression contains only equivalence comparisons based on existing tables indexes and the range of requested values is from \[0 to END\_OF\_SET]. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a6cfed3eb927ab25c3d84e9bc0f397fa7">get\_records\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a0871a7dadb765359372fbf2092aa6aa9">get\_records\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a6cfed3eb927ab25c3d84e9bc0f397fa7">get\_records\_true</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a6d56a39a602bbd41f34dd180c79b7861">get\_records\_sort\_by</a>: Column that the data should be sorted by. Empty by default (i.e. no sorting is applied). </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a3c6e717cdfc28d37c01f81ec1d4b3644">get\_records\_sort\_order</a>: String indicating how the returned values should be sorted - ascending or descending. If sort\_order is provided, sort\_by has to be provided. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a252c2b87591ffcea13037694610628da">get\_records\_ascending</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a20834c9af1c9f43ff9c6fd9f9695fb17">get\_records\_descending</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a252c2b87591ffcea13037694610628da">get\_records\_ascending</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1GetRecordsResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a91126344a584c907b7265fb5048af6cc">◆ </a></span>getRecords() <span>\[16/20]</span></h2>

    <div>
      <div>
        <div> template\<typename TResponse> </div>

        <table>
          <tr>
            <td>
              <table>
                <tr>
                  <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsResponse">GetRecordsResponse</a>\< TResponse > & gpudb::GPUdb::getRecords </td>
                  <td>(</td>
                  <td>const std::string &</td>
                  <td><span><span>tableName</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const int64\_t</td>
                  <td><span><span>offset</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const int64\_t</td>
                  <td><span><span>limit</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const std::map\< std::string, std::string > &</td>
                  <td><span><span>options</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsResponse">GetRecordsResponse</a>\< TResponse > &</td>
                  <td><span><span>response\_</span></span> ) const</td>
                </tr>
              </table>
            </td>

            <td> <span><span>inline</span></span> </td>
          </tr>
        </table>
      </div>

      <div>
        <p>Retrieves records from a given table, optionally filtered by an expression and/or sorted by a column. </p>
        <p>This operation can be performed on tables and views. Records can be returned encoded as binary, json, or geojson.</p>
        <p>This operation supports paging through the data via the <span>offset</span> and <span>limit</span> parameters. Note that when paging through a table, if the table (or the underlying table in case of a view) is updated (records are inserted, deleted or modified) the records retrieved may differ between calls based on the updates applied.</p>

        <div>
          <div>Template Parameters</div>

          <div>
            <table>
              <tr>
                <td>TResponse</td>
                <td>The type of object being retrieved.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of the table or view from which the records will be fetched, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>offset</td>
                <td>A positive integer indicating the number of initial results to skip (this can be useful for paging through the results). The default value is 0. The minimum allowed value is 0. The maximum allowed value is MAX\_INT. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>limit</td>
                <td>A positive integer indicating the maximum number of results to be returned, or END\_OF\_SET (-9999) to indicate that the maximum number of results allowed by the server should be returned. The number of records returned will never exceed the server's own limit, defined by the <a href="/content/config/#config-main-general">max\_get\_records\_size</a> parameter in the server configuration. Use <a href="/content/api/cpp/structgpudb_1_1RawGetRecordsResponse#addc876a47152c62651f0ea49a111aa01">hasMoreRecords</a> to see if more records exist in the result to be fetched, and <span>offset</span> and <span>limit</span> to request subsequent pages of results. The default value is -9999. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#aa8ba8bada1e52234e73e49baae769873">get\_records\_expression</a>: Filter expression to apply to the table. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a9c995a38a96b7de5d4226fa88f1f2db1">get\_records\_fast\_index\_lookup</a>: Indicates if indexes should be used to perform the lookup for a given expression if possible. Only applicable if there is no sorting, the expression contains only equivalence comparisons based on existing tables indexes and the range of requested values is from \[0 to END\_OF\_SET]. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a6cfed3eb927ab25c3d84e9bc0f397fa7">get\_records\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a0871a7dadb765359372fbf2092aa6aa9">get\_records\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a6cfed3eb927ab25c3d84e9bc0f397fa7">get\_records\_true</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a6d56a39a602bbd41f34dd180c79b7861">get\_records\_sort\_by</a>: Column that the data should be sorted by. Empty by default (i.e. no sorting is applied). </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a3c6e717cdfc28d37c01f81ec1d4b3644">get\_records\_sort\_order</a>: String indicating how the returned values should be sorted - ascending or descending. If sort\_order is provided, sort\_by has to be provided. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a252c2b87591ffcea13037694610628da">get\_records\_ascending</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a20834c9af1c9f43ff9c6fd9f9695fb17">get\_records\_descending</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a252c2b87591ffcea13037694610628da">get\_records\_ascending</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1GetRecordsResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>

        <p>Definition at line <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">32249</a> of file <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">GPUdb.hpp</a>.</p>
      </div>
    </div>

    <h2><span><a href="#a65a981945189ac5191f6ef8236736b18">◆ </a></span>getRecords() <span>\[17/20]</span></h2>

    <div>
      <div>
        <div> template\<typename TResponse> </div>

        <table>
          <tr>
            <td>
              <table>
                <tr>
                  <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsResponse">GetRecordsResponse</a>\< TResponse > gpudb::GPUdb::getRecords </td>
                  <td>(</td>
                  <td>const <a href="/content/api/cpp/classgpudb_1_1Type">Type</a> &</td>
                  <td><span><span>type\_</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const <a href="/content/api/cpp/structgpudb_1_1GetRecordsRequest">GetRecordsRequest</a> &</td>
                  <td><span><span>request\_</span></span> ) const</td>
                </tr>
              </table>
            </td>

            <td> <span><span>inline</span></span> </td>
          </tr>
        </table>
      </div>

      <div>
        <p>Retrieves records from a given table, optionally filtered by an expression and/or sorted by a column. </p>
        <p>This operation can be performed on tables and views. Records can be returned encoded as binary, json, or geojson.</p>
        <p>This operation supports paging through the data via the <a href="/content/api/cpp/structgpudb_1_1GetRecordsRequest#a6f8fde526abfe2adc4845bd4582f96a5">offset</a> and <a href="/content/api/cpp/structgpudb_1_1GetRecordsRequest#a88646356abf331176d438e0e435cae79">limit</a> parameters. Note that when paging through a table, if the table (or the underlying table in case of a view) is updated (records are inserted, deleted or modified) the records retrieved may differ between calls based on the updates applied.</p>

        <div>
          <div>Template Parameters</div>

          <div>
            <table>
              <tr>
                <td>TResponse</td>
                <td>The type of object being retrieved.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>type\_</td>
                <td><a href="/content/api/cpp/classgpudb_1_1Type">Type</a> object used for decoding returned objects. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1GetRecordsResponse">Response</a> object containing the result of the operation. </div>
        </div>

        <p>Definition at line <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">32337</a> of file <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">GPUdb.hpp</a>.</p>
      </div>
    </div>

    <h2><span><a href="#aac3d1e38fb24597f0576eaf224d0d843">◆ </a></span>getRecords() <span>\[18/20]</span></h2>

    <div>
      <div>
        <div> template\<typename TResponse> </div>

        <table>
          <tr>
            <td>
              <table>
                <tr>
                  <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsResponse">GetRecordsResponse</a>\< TResponse > & gpudb::GPUdb::getRecords </td>
                  <td>(</td>
                  <td>const <a href="/content/api/cpp/classgpudb_1_1Type">Type</a> &</td>
                  <td><span><span>type\_</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const <a href="/content/api/cpp/structgpudb_1_1GetRecordsRequest">GetRecordsRequest</a> &</td>
                  <td><span><span>request\_</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsResponse">GetRecordsResponse</a>\< TResponse > &</td>
                  <td><span><span>response\_</span></span> ) const</td>
                </tr>
              </table>
            </td>

            <td> <span><span>inline</span></span> </td>
          </tr>
        </table>
      </div>

      <div>
        <p>Retrieves records from a given table, optionally filtered by an expression and/or sorted by a column. </p>
        <p>This operation can be performed on tables and views. Records can be returned encoded as binary, json, or geojson.</p>
        <p>This operation supports paging through the data via the <a href="/content/api/cpp/structgpudb_1_1GetRecordsRequest#a6f8fde526abfe2adc4845bd4582f96a5">offset</a> and <a href="/content/api/cpp/structgpudb_1_1GetRecordsRequest#a88646356abf331176d438e0e435cae79">limit</a> parameters. Note that when paging through a table, if the table (or the underlying table in case of a view) is updated (records are inserted, deleted or modified) the records retrieved may differ between calls based on the updates applied.</p>

        <div>
          <div>Template Parameters</div>

          <div>
            <table>
              <tr>
                <td>TResponse</td>
                <td>The type of object being retrieved.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>type\_</td>
                <td><a href="/content/api/cpp/classgpudb_1_1Type">Type</a> object used for decoding returned objects. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1GetRecordsResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>

        <p>Definition at line <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">32425</a> of file <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">GPUdb.hpp</a>.</p>
      </div>
    </div>

    <h2><span><a href="#a7f3ab43aa42646aec1a2ac7bea148f9d">◆ </a></span>getRecords() <span>\[19/20]</span></h2>

    <div>
      <div>
        <div> template\<typename TResponse> </div>

        <table>
          <tr>
            <td>
              <table>
                <tr>
                  <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsResponse">GetRecordsResponse</a>\< TResponse > gpudb::GPUdb::getRecords </td>
                  <td>(</td>
                  <td>const <a href="/content/api/cpp/classgpudb_1_1Type">Type</a> &</td>
                  <td><span><span>type\_</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const std::string &</td>
                  <td><span><span>tableName</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const int64\_t</td>
                  <td><span><span>offset</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const int64\_t</td>
                  <td><span><span>limit</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const std::map\< std::string, std::string > &</td>
                  <td><span><span>options</span></span> ) const</td>
                </tr>
              </table>
            </td>

            <td> <span><span>inline</span></span> </td>
          </tr>
        </table>
      </div>

      <div>
        <p>Retrieves records from a given table, optionally filtered by an expression and/or sorted by a column. </p>
        <p>This operation can be performed on tables and views. Records can be returned encoded as binary, json, or geojson.</p>
        <p>This operation supports paging through the data via the <span>offset</span> and <span>limit</span> parameters. Note that when paging through a table, if the table (or the underlying table in case of a view) is updated (records are inserted, deleted or modified) the records retrieved may differ between calls based on the updates applied.</p>

        <div>
          <div>Template Parameters</div>

          <div>
            <table>
              <tr>
                <td>TResponse</td>
                <td>The type of object being retrieved.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>type\_</td>
                <td><a href="/content/api/cpp/classgpudb_1_1Type">Type</a> object used for decoding returned objects. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of the table or view from which the records will be fetched, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>offset</td>
                <td>A positive integer indicating the number of initial results to skip (this can be useful for paging through the results). The default value is 0. The minimum allowed value is 0. The maximum allowed value is MAX\_INT. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>limit</td>
                <td>A positive integer indicating the maximum number of results to be returned, or END\_OF\_SET (-9999) to indicate that the maximum number of results allowed by the server should be returned. The number of records returned will never exceed the server's own limit, defined by the <a href="/content/config/#config-main-general">max\_get\_records\_size</a> parameter in the server configuration. Use <a href="/content/api/cpp/structgpudb_1_1RawGetRecordsResponse#addc876a47152c62651f0ea49a111aa01">hasMoreRecords</a> to see if more records exist in the result to be fetched, and <span>offset</span> and <span>limit</span> to request subsequent pages of results. The default value is -9999. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#aa8ba8bada1e52234e73e49baae769873">get\_records\_expression</a>: Filter expression to apply to the table. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a9c995a38a96b7de5d4226fa88f1f2db1">get\_records\_fast\_index\_lookup</a>: Indicates if indexes should be used to perform the lookup for a given expression if possible. Only applicable if there is no sorting, the expression contains only equivalence comparisons based on existing tables indexes and the range of requested values is from \[0 to END\_OF\_SET]. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a6cfed3eb927ab25c3d84e9bc0f397fa7">get\_records\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a0871a7dadb765359372fbf2092aa6aa9">get\_records\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a6cfed3eb927ab25c3d84e9bc0f397fa7">get\_records\_true</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a6d56a39a602bbd41f34dd180c79b7861">get\_records\_sort\_by</a>: Column that the data should be sorted by. Empty by default (i.e. no sorting is applied). </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a3c6e717cdfc28d37c01f81ec1d4b3644">get\_records\_sort\_order</a>: String indicating how the returned values should be sorted - ascending or descending. If sort\_order is provided, sort\_by has to be provided. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a252c2b87591ffcea13037694610628da">get\_records\_ascending</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a20834c9af1c9f43ff9c6fd9f9695fb17">get\_records\_descending</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a252c2b87591ffcea13037694610628da">get\_records\_ascending</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1GetRecordsResponse">Response</a> object containing the result of the operation. </div>
        </div>

        <p>Definition at line <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">32636</a> of file <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">GPUdb.hpp</a>.</p>
      </div>
    </div>

    <h2><span><a href="#a99f0ecf8a11e028593aa7c9b222f94ce">◆ </a></span>getRecords() <span>\[20/20]</span></h2>

    <div>
      <div>
        <div> template\<typename TResponse> </div>

        <table>
          <tr>
            <td>
              <table>
                <tr>
                  <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsResponse">GetRecordsResponse</a>\< TResponse > & gpudb::GPUdb::getRecords </td>
                  <td>(</td>
                  <td>const <a href="/content/api/cpp/classgpudb_1_1Type">Type</a> &</td>
                  <td><span><span>type\_</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const std::string &</td>
                  <td><span><span>tableName</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const int64\_t</td>
                  <td><span><span>offset</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const int64\_t</td>
                  <td><span><span>limit</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const std::map\< std::string, std::string > &</td>
                  <td><span><span>options</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsResponse">GetRecordsResponse</a>\< TResponse > &</td>
                  <td><span><span>response\_</span></span> ) const</td>
                </tr>
              </table>
            </td>

            <td> <span><span>inline</span></span> </td>
          </tr>
        </table>
      </div>

      <div>
        <p>Retrieves records from a given table, optionally filtered by an expression and/or sorted by a column. </p>
        <p>This operation can be performed on tables and views. Records can be returned encoded as binary, json, or geojson.</p>
        <p>This operation supports paging through the data via the <span>offset</span> and <span>limit</span> parameters. Note that when paging through a table, if the table (or the underlying table in case of a view) is updated (records are inserted, deleted or modified) the records retrieved may differ between calls based on the updates applied.</p>

        <div>
          <div>Template Parameters</div>

          <div>
            <table>
              <tr>
                <td>TResponse</td>
                <td>The type of object being retrieved.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>type\_</td>
                <td><a href="/content/api/cpp/classgpudb_1_1Type">Type</a> object used for decoding returned objects. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of the table or view from which the records will be fetched, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>offset</td>
                <td>A positive integer indicating the number of initial results to skip (this can be useful for paging through the results). The default value is 0. The minimum allowed value is 0. The maximum allowed value is MAX\_INT. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>limit</td>
                <td>A positive integer indicating the maximum number of results to be returned, or END\_OF\_SET (-9999) to indicate that the maximum number of results allowed by the server should be returned. The number of records returned will never exceed the server's own limit, defined by the <a href="/content/config/#config-main-general">max\_get\_records\_size</a> parameter in the server configuration. Use <a href="/content/api/cpp/structgpudb_1_1RawGetRecordsResponse#addc876a47152c62651f0ea49a111aa01">hasMoreRecords</a> to see if more records exist in the result to be fetched, and <span>offset</span> and <span>limit</span> to request subsequent pages of results. The default value is -9999. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#aa8ba8bada1e52234e73e49baae769873">get\_records\_expression</a>: Filter expression to apply to the table. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a9c995a38a96b7de5d4226fa88f1f2db1">get\_records\_fast\_index\_lookup</a>: Indicates if indexes should be used to perform the lookup for a given expression if possible. Only applicable if there is no sorting, the expression contains only equivalence comparisons based on existing tables indexes and the range of requested values is from \[0 to END\_OF\_SET]. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a6cfed3eb927ab25c3d84e9bc0f397fa7">get\_records\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a0871a7dadb765359372fbf2092aa6aa9">get\_records\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a6cfed3eb927ab25c3d84e9bc0f397fa7">get\_records\_true</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a6d56a39a602bbd41f34dd180c79b7861">get\_records\_sort\_by</a>: Column that the data should be sorted by. Empty by default (i.e. no sorting is applied). </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a3c6e717cdfc28d37c01f81ec1d4b3644">get\_records\_sort\_order</a>: String indicating how the returned values should be sorted - ascending or descending. If sort\_order is provided, sort\_by has to be provided. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a252c2b87591ffcea13037694610628da">get\_records\_ascending</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a20834c9af1c9f43ff9c6fd9f9695fb17">get\_records\_descending</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a252c2b87591ffcea13037694610628da">get\_records\_ascending</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1GetRecordsResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>

        <p>Definition at line <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">32856</a> of file <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">GPUdb.hpp</a>.</p>
      </div>
    </div>

    <h2><span><a href="#aaf391f0f2e29974de30e9aa91dbed1ef">◆ </a></span>getRecordsByColumn() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsByColumnResponse">GetRecordsByColumnResponse</a> gpudb::GPUdb::getRecordsByColumn </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1GetRecordsByColumnRequest">GetRecordsByColumnRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>For a given table, retrieves the values from the requested column(s). </p>
        <p>Maps of column name to the array of values as well as the column data type are returned. This endpoint supports pagination with the <a href="/content/api/cpp/structgpudb_1_1GetRecordsByColumnRequest#a18191415826f865ec4f6a0d6dc6855ed">offset</a> and <a href="/content/api/cpp/structgpudb_1_1GetRecordsByColumnRequest#a036170d92eb383fc6d7870158671089d">limit</a> parameters.</p>
        <p><a href="/content/concepts/window/">Window functions</a>, which can perform operations like moving averages, are available through this endpoint as well as <a href="#aab22a8ee1b42ec6fa1acfc3b2f70cf4c">createProjection</a>.</p>
        <p>When using pagination, if the table (or the underlying table in the case of a view) is modified (records are inserted, updated, or deleted) during a call to the endpoint, the records or values retrieved may differ between calls based on the type of the update, e.g., the contiguity across pages cannot be relied upon.</p>
        <p>If <a href="/content/api/cpp/structgpudb_1_1GetRecordsByColumnRequest#a263821675907f32ae8da306a46c885f5">tableName</a> is empty, selection is performed against a single-row virtual table. This can be useful in executing temporal (<a href="/content/concepts/expressions/#date-time-functions">NOW()</a>), identity (<a href="/content/concepts/expressions/#user-security-functions">USER()</a>), or constant-based functions (<a href="/content/concepts/expressions/#scalar-functions">GEODIST(-77.11, 38.88, -71.06, 42.36)</a>).</p>
        <p>The response is returned as a dynamic schema. For details see: <a href="/content/api/concepts/#dynamic-schemas">dynamic schemas documentation</a>.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsByColumnRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1GetRecordsByColumnResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a2de02e5fe9cd6f92b139fd657a103a8b">◆ </a></span>getRecordsByColumn() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsByColumnResponse">GetRecordsByColumnResponse</a> & gpudb::GPUdb::getRecordsByColumn </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1GetRecordsByColumnRequest">GetRecordsByColumnRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsByColumnResponse">GetRecordsByColumnResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>For a given table, retrieves the values from the requested column(s). </p>
        <p>Maps of column name to the array of values as well as the column data type are returned. This endpoint supports pagination with the <a href="/content/api/cpp/structgpudb_1_1GetRecordsByColumnRequest#a18191415826f865ec4f6a0d6dc6855ed">offset</a> and <a href="/content/api/cpp/structgpudb_1_1GetRecordsByColumnRequest#a036170d92eb383fc6d7870158671089d">limit</a> parameters.</p>
        <p><a href="/content/concepts/window/">Window functions</a>, which can perform operations like moving averages, are available through this endpoint as well as <a href="#aab22a8ee1b42ec6fa1acfc3b2f70cf4c">createProjection</a>.</p>
        <p>When using pagination, if the table (or the underlying table in the case of a view) is modified (records are inserted, updated, or deleted) during a call to the endpoint, the records or values retrieved may differ between calls based on the type of the update, e.g., the contiguity across pages cannot be relied upon.</p>
        <p>If <a href="/content/api/cpp/structgpudb_1_1GetRecordsByColumnRequest#a263821675907f32ae8da306a46c885f5">tableName</a> is empty, selection is performed against a single-row virtual table. This can be useful in executing temporal (<a href="/content/concepts/expressions/#date-time-functions">NOW()</a>), identity (<a href="/content/concepts/expressions/#user-security-functions">USER()</a>), or constant-based functions (<a href="/content/concepts/expressions/#scalar-functions">GEODIST(-77.11, 38.88, -71.06, 42.36)</a>).</p>
        <p>The response is returned as a dynamic schema. For details see: <a href="/content/api/concepts/#dynamic-schemas">dynamic schemas documentation</a>.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsByColumnRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsByColumnResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1GetRecordsByColumnResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a5557e7cbe07004a0f754cf3bb5e5c62b">◆ </a></span>getRecordsByColumn() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsByColumnResponse">GetRecordsByColumnResponse</a> gpudb::GPUdb::getRecordsByColumn </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< std::string > &</td>
            <td><span><span>columnNames</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const int64\_t</td>
            <td><span><span>offset</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const int64\_t</td>
            <td><span><span>limit</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>For a given table, retrieves the values from the requested column(s). </p>
        <p>Maps of column name to the array of values as well as the column data type are returned. This endpoint supports pagination with the <span>offset</span> and <span>limit</span> parameters.</p>
        <p><a href="/content/concepts/window/">Window functions</a>, which can perform operations like moving averages, are available through this endpoint as well as <a href="#a8dd0f76ba727eed190f006f6d15d2e5b">createProjection</a>.</p>
        <p>When using pagination, if the table (or the underlying table in the case of a view) is modified (records are inserted, updated, or deleted) during a call to the endpoint, the records or values retrieved may differ between calls based on the type of the update, e.g., the contiguity across pages cannot be relied upon.</p>
        <p>If <span>tableName</span> is empty, selection is performed against a single-row virtual table. This can be useful in executing temporal (<a href="/content/concepts/expressions/#date-time-functions">NOW()</a>), identity (<a href="/content/concepts/expressions/#user-security-functions">USER()</a>), or constant-based functions (<a href="/content/concepts/expressions/#scalar-functions">GEODIST(-77.11, 38.88, -71.06, 42.36)</a>).</p>
        <p>The response is returned as a dynamic schema. For details see: <a href="/content/api/concepts/#dynamic-schemas">dynamic schemas documentation</a>.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of the table or view on which this operation will be performed, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. An empty table name retrieves one record from a single-row virtual table, where columns specified should be constants or constant expressions. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>columnNames</td>
                <td>The list of column values to retrieve. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>offset</td>
                <td>A positive integer indicating the number of initial results to skip (this can be useful for paging through the results). The default value is 0. The minimum allowed value is 0. The maximum allowed value is MAX\_INT. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>limit</td>
                <td>A positive integer indicating the maximum number of results to be returned, or END\_OF\_SET (-9999) to indicate that the maximum number of results allowed by the server should be returned. The number of records returned will never exceed the server's own limit, defined by the <a href="/content/config/#config-main-general">max\_get\_records\_size</a> parameter in the server configuration. Use <a href="/content/api/cpp/structgpudb_1_1RawGetRecordsByColumnResponse#aacb0ce76f7cd842a1a9cce15365b34cf">hasMoreRecords</a> to see if more records exist in the result to be fetched, and <span>offset</span> and <span>limit</span> to request subsequent pages of results. The default value is -9999. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a40c38c510dc7a5c6e33feeee54b47ce0">get\_records\_by\_column\_expression</a>: Filter expression to apply to the table. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ab655054cebcfd9067f7f35c9e2ec43b3">get\_records\_by\_column\_sort\_by</a>: Column that the data should be sorted by. Used in conjunction with <a href="/content/api/cpp/namespacegpudb#a3197c54c5d213d3aff66a728e54bff56">sort\_order</a>. The <a href="/content/api/cpp/namespacegpudb#af02eca012e8de80e8e38c2d4b70d4383">order\_by</a> option can be used in lieu of <a href="/content/api/cpp/namespacegpudb#ab655054cebcfd9067f7f35c9e2ec43b3">sort\_by</a> / <a href="/content/api/cpp/namespacegpudb#a3197c54c5d213d3aff66a728e54bff56">sort\_order</a>. The default value is ''. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a3197c54c5d213d3aff66a728e54bff56">get\_records\_by\_column\_sort\_order</a>: String indicating how the returned values should be sorted - <a href="/content/api/cpp/namespacegpudb#afc9919fed190f2c386350b030eb40566">ascending</a> or <a href="/content/api/cpp/namespacegpudb#a73b3c1a06c6708264e0585c3e1b0c89a">descending</a>. If <a href="/content/api/cpp/namespacegpudb#a3197c54c5d213d3aff66a728e54bff56">sort\_order</a> is provided, <a href="/content/api/cpp/namespacegpudb#ab655054cebcfd9067f7f35c9e2ec43b3">sort\_by</a> has to be provided. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#afc9919fed190f2c386350b030eb40566">get\_records\_by\_column\_ascending</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a73b3c1a06c6708264e0585c3e1b0c89a">get\_records\_by\_column\_descending</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#afc9919fed190f2c386350b030eb40566">get\_records\_by\_column\_ascending</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#af02eca012e8de80e8e38c2d4b70d4383">get\_records\_by\_column\_order\_by</a>: Comma-separated list of the columns to be sorted by as well as the sort direction, e.g., 'timestamp asc, x desc'. The default value is ''. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a314c60906c01b5d513374b32e935ca66">get\_records\_by\_column\_convert\_wkts\_to\_wkbs</a>: If <a href="/content/api/cpp/namespacegpudb#a10b5be6900c28fc88d28ecc89ed5a67c">true</a>, then WKT string columns will be returned as WKB bytes. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a10b5be6900c28fc88d28ecc89ed5a67c">get\_records\_by\_column\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a18a75ed4471dedf3f337fafccd529e68">get\_records\_by\_column\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a18a75ed4471dedf3f337fafccd529e68">get\_records\_by\_column\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a57f1bbd4459c912dbc0ad2b23ae58fb9">get\_records\_by\_column\_route\_to\_tom</a>: For multihead record retrieval without shard key expression - specifies from which tom to retrieve data. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1GetRecordsByColumnResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a7985e0b6c1423c738ae4922714d20404">◆ </a></span>getRecordsByColumn() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsByColumnResponse">GetRecordsByColumnResponse</a> & gpudb::GPUdb::getRecordsByColumn </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< std::string > &</td>
            <td><span><span>columnNames</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const int64\_t</td>
            <td><span><span>offset</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const int64\_t</td>
            <td><span><span>limit</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsByColumnResponse">GetRecordsByColumnResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>For a given table, retrieves the values from the requested column(s). </p>
        <p>Maps of column name to the array of values as well as the column data type are returned. This endpoint supports pagination with the <span>offset</span> and <span>limit</span> parameters.</p>
        <p><a href="/content/concepts/window/">Window functions</a>, which can perform operations like moving averages, are available through this endpoint as well as <a href="#a8dd0f76ba727eed190f006f6d15d2e5b">createProjection</a>.</p>
        <p>When using pagination, if the table (or the underlying table in the case of a view) is modified (records are inserted, updated, or deleted) during a call to the endpoint, the records or values retrieved may differ between calls based on the type of the update, e.g., the contiguity across pages cannot be relied upon.</p>
        <p>If <span>tableName</span> is empty, selection is performed against a single-row virtual table. This can be useful in executing temporal (<a href="/content/concepts/expressions/#date-time-functions">NOW()</a>), identity (<a href="/content/concepts/expressions/#user-security-functions">USER()</a>), or constant-based functions (<a href="/content/concepts/expressions/#scalar-functions">GEODIST(-77.11, 38.88, -71.06, 42.36)</a>).</p>
        <p>The response is returned as a dynamic schema. For details see: <a href="/content/api/concepts/#dynamic-schemas">dynamic schemas documentation</a>.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of the table or view on which this operation will be performed, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. An empty table name retrieves one record from a single-row virtual table, where columns specified should be constants or constant expressions. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>columnNames</td>
                <td>The list of column values to retrieve. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>offset</td>
                <td>A positive integer indicating the number of initial results to skip (this can be useful for paging through the results). The default value is 0. The minimum allowed value is 0. The maximum allowed value is MAX\_INT. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>limit</td>
                <td>A positive integer indicating the maximum number of results to be returned, or END\_OF\_SET (-9999) to indicate that the maximum number of results allowed by the server should be returned. The number of records returned will never exceed the server's own limit, defined by the <a href="/content/config/#config-main-general">max\_get\_records\_size</a> parameter in the server configuration. Use <a href="/content/api/cpp/structgpudb_1_1RawGetRecordsByColumnResponse#aacb0ce76f7cd842a1a9cce15365b34cf">hasMoreRecords</a> to see if more records exist in the result to be fetched, and <span>offset</span> and <span>limit</span> to request subsequent pages of results. The default value is -9999. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a40c38c510dc7a5c6e33feeee54b47ce0">get\_records\_by\_column\_expression</a>: Filter expression to apply to the table. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ab655054cebcfd9067f7f35c9e2ec43b3">get\_records\_by\_column\_sort\_by</a>: Column that the data should be sorted by. Used in conjunction with <a href="/content/api/cpp/namespacegpudb#a3197c54c5d213d3aff66a728e54bff56">sort\_order</a>. The <a href="/content/api/cpp/namespacegpudb#af02eca012e8de80e8e38c2d4b70d4383">order\_by</a> option can be used in lieu of <a href="/content/api/cpp/namespacegpudb#ab655054cebcfd9067f7f35c9e2ec43b3">sort\_by</a> / <a href="/content/api/cpp/namespacegpudb#a3197c54c5d213d3aff66a728e54bff56">sort\_order</a>. The default value is ''. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a3197c54c5d213d3aff66a728e54bff56">get\_records\_by\_column\_sort\_order</a>: String indicating how the returned values should be sorted - <a href="/content/api/cpp/namespacegpudb#afc9919fed190f2c386350b030eb40566">ascending</a> or <a href="/content/api/cpp/namespacegpudb#a73b3c1a06c6708264e0585c3e1b0c89a">descending</a>. If <a href="/content/api/cpp/namespacegpudb#a3197c54c5d213d3aff66a728e54bff56">sort\_order</a> is provided, <a href="/content/api/cpp/namespacegpudb#ab655054cebcfd9067f7f35c9e2ec43b3">sort\_by</a> has to be provided. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#afc9919fed190f2c386350b030eb40566">get\_records\_by\_column\_ascending</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a73b3c1a06c6708264e0585c3e1b0c89a">get\_records\_by\_column\_descending</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#afc9919fed190f2c386350b030eb40566">get\_records\_by\_column\_ascending</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#af02eca012e8de80e8e38c2d4b70d4383">get\_records\_by\_column\_order\_by</a>: Comma-separated list of the columns to be sorted by as well as the sort direction, e.g., 'timestamp asc, x desc'. The default value is ''. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a314c60906c01b5d513374b32e935ca66">get\_records\_by\_column\_convert\_wkts\_to\_wkbs</a>: If <a href="/content/api/cpp/namespacegpudb#a10b5be6900c28fc88d28ecc89ed5a67c">true</a>, then WKT string columns will be returned as WKB bytes. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a10b5be6900c28fc88d28ecc89ed5a67c">get\_records\_by\_column\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a18a75ed4471dedf3f337fafccd529e68">get\_records\_by\_column\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a18a75ed4471dedf3f337fafccd529e68">get\_records\_by\_column\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a57f1bbd4459c912dbc0ad2b23ae58fb9">get\_records\_by\_column\_route\_to\_tom</a>: For multihead record retrieval without shard key expression - specifies from which tom to retrieve data. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsByColumnResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1GetRecordsByColumnResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ab27ed9c87017701489bd2e2d8d9bdbc7">◆ </a></span>getRecordsByColumnRaw() <span>\[1/2]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1RawGetRecordsByColumnResponse">RawGetRecordsByColumnResponse</a> gpudb::GPUdb::getRecordsByColumnRaw </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1GetRecordsByColumnRequest">GetRecordsByColumnRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>For a given table, retrieves the values from the requested column(s). </p>
        <p>Maps of column name to the array of values as well as the column data type are returned. This endpoint supports pagination with the <a href="/content/api/cpp/structgpudb_1_1GetRecordsByColumnRequest#a18191415826f865ec4f6a0d6dc6855ed">offset</a> and <a href="/content/api/cpp/structgpudb_1_1GetRecordsByColumnRequest#a036170d92eb383fc6d7870158671089d">limit</a> parameters.</p>
        <p><a href="/content/concepts/window/">Window functions</a>, which can perform operations like moving averages, are available through this endpoint as well as <a href="#aab22a8ee1b42ec6fa1acfc3b2f70cf4c">createProjection</a>.</p>
        <p>When using pagination, if the table (or the underlying table in the case of a view) is modified (records are inserted, updated, or deleted) during a call to the endpoint, the records or values retrieved may differ between calls based on the type of the update, e.g., the contiguity across pages cannot be relied upon.</p>
        <p>If <a href="/content/api/cpp/structgpudb_1_1GetRecordsByColumnRequest#a263821675907f32ae8da306a46c885f5">tableName</a> is empty, selection is performed against a single-row virtual table. This can be useful in executing temporal (<a href="/content/concepts/expressions/#date-time-functions">NOW()</a>), identity (<a href="/content/concepts/expressions/#user-security-functions">USER()</a>), or constant-based functions (<a href="/content/concepts/expressions/#scalar-functions">GEODIST(-77.11, 38.88, -71.06, 42.36)</a>).</p>
        <p>The response is returned as a dynamic schema. For details see: <a href="/content/api/concepts/#dynamic-schemas">dynamic schemas documentation</a>.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsByColumnRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1RawGetRecordsByColumnResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ad3f6fcdabf549c813352cae5e37112ca">◆ </a></span>getRecordsByColumnRaw() <span>\[2/2]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1RawGetRecordsByColumnResponse">RawGetRecordsByColumnResponse</a> & gpudb::GPUdb::getRecordsByColumnRaw </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1GetRecordsByColumnRequest">GetRecordsByColumnRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1RawGetRecordsByColumnResponse">RawGetRecordsByColumnResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>For a given table, retrieves the values from the requested column(s). </p>
        <p>Maps of column name to the array of values as well as the column data type are returned. This endpoint supports pagination with the <a href="/content/api/cpp/structgpudb_1_1GetRecordsByColumnRequest#a18191415826f865ec4f6a0d6dc6855ed">offset</a> and <a href="/content/api/cpp/structgpudb_1_1GetRecordsByColumnRequest#a036170d92eb383fc6d7870158671089d">limit</a> parameters.</p>
        <p><a href="/content/concepts/window/">Window functions</a>, which can perform operations like moving averages, are available through this endpoint as well as <a href="#aab22a8ee1b42ec6fa1acfc3b2f70cf4c">createProjection</a>.</p>
        <p>When using pagination, if the table (or the underlying table in the case of a view) is modified (records are inserted, updated, or deleted) during a call to the endpoint, the records or values retrieved may differ between calls based on the type of the update, e.g., the contiguity across pages cannot be relied upon.</p>
        <p>If <a href="/content/api/cpp/structgpudb_1_1GetRecordsByColumnRequest#a263821675907f32ae8da306a46c885f5">tableName</a> is empty, selection is performed against a single-row virtual table. This can be useful in executing temporal (<a href="/content/concepts/expressions/#date-time-functions">NOW()</a>), identity (<a href="/content/concepts/expressions/#user-security-functions">USER()</a>), or constant-based functions (<a href="/content/concepts/expressions/#scalar-functions">GEODIST(-77.11, 38.88, -71.06, 42.36)</a>).</p>
        <p>The response is returned as a dynamic schema. For details see: <a href="/content/api/concepts/#dynamic-schemas">dynamic schemas documentation</a>.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsByColumnRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1RawGetRecordsByColumnResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1RawGetRecordsByColumnResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a1e347a748f650f5fcd765a317767211c">◆ </a></span>getRecordsBySeries() <span>\[1/20]</span></h2>

    <div>
      <div>
        <div> template\<typename TResponse> </div>

        <table>
          <tr>
            <td>
              <table>
                <tr>
                  <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesResponse">GetRecordsBySeriesResponse</a>\< TResponse > gpudb::GPUdb::getRecordsBySeries </td>
                  <td>(</td>
                  <td>const ::avro::ValidSchema &</td>
                  <td><span><span>schema\_</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest">GetRecordsBySeriesRequest</a> &</td>
                  <td><span><span>request\_</span></span> ) const</td>
                </tr>
              </table>
            </td>

            <td> <span><span>inline</span></span> </td>
          </tr>
        </table>
      </div>

      <div>
        <p>Retrieves the complete series/track records from the given <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest#a95d1e31e27c1d040de81b0ac7bd0d5ea">worldTableName</a> based on the partial track information contained in the <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest#a841767ddf7d2fe03d6531fd9cc1e48f0">tableName</a>. </p>
        <p>This operation supports paging through the data via the <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest#a6ec0f48f1904b02d01e51d1b463fee0e">offset</a> and <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest#acded0bdebbfdd0ae0e503e767ec156cb">limit</a> parameters.</p>
        <p>In contrast to <a href="#a107efac13be55b48d53e2d96a3bdff7a">getRecords</a> this returns records grouped by series/track. So if <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest#a6ec0f48f1904b02d01e51d1b463fee0e">offset</a> is 0 and <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest#acded0bdebbfdd0ae0e503e767ec156cb">limit</a> is 5 this operation would return the first 5 series/tracks in <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest#a841767ddf7d2fe03d6531fd9cc1e48f0">tableName</a>. Each series/track will be returned sorted by their TIMESTAMP column.</p>

        <div>
          <div>Template Parameters</div>

          <div>
            <table>
              <tr>
                <td>TResponse</td>
                <td>The type of object being retrieved.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>schema\_</td>
                <td>Avro schema object used for decoding returned objects. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesResponse">Response</a> object containing the result of the operation. </div>
        </div>

        <p>Definition at line <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">33662</a> of file <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">GPUdb.hpp</a>.</p>
      </div>
    </div>

    <h2><span><a href="#a1f41c29a6f7612526b10b5f4b4016005">◆ </a></span>getRecordsBySeries() <span>\[2/20]</span></h2>

    <div>
      <div>
        <div> template\<typename TResponse> </div>

        <table>
          <tr>
            <td>
              <table>
                <tr>
                  <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesResponse">GetRecordsBySeriesResponse</a>\< TResponse > & gpudb::GPUdb::getRecordsBySeries </td>
                  <td>(</td>
                  <td>const ::avro::ValidSchema &</td>
                  <td><span><span>schema\_</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest">GetRecordsBySeriesRequest</a> &</td>
                  <td><span><span>request\_</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesResponse">GetRecordsBySeriesResponse</a>\< TResponse > &</td>
                  <td><span><span>response\_</span></span> ) const</td>
                </tr>
              </table>
            </td>

            <td> <span><span>inline</span></span> </td>
          </tr>
        </table>
      </div>

      <div>
        <p>Retrieves the complete series/track records from the given <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest#a95d1e31e27c1d040de81b0ac7bd0d5ea">worldTableName</a> based on the partial track information contained in the <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest#a841767ddf7d2fe03d6531fd9cc1e48f0">tableName</a>. </p>
        <p>This operation supports paging through the data via the <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest#a6ec0f48f1904b02d01e51d1b463fee0e">offset</a> and <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest#acded0bdebbfdd0ae0e503e767ec156cb">limit</a> parameters.</p>
        <p>In contrast to <a href="#a107efac13be55b48d53e2d96a3bdff7a">getRecords</a> this returns records grouped by series/track. So if <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest#a6ec0f48f1904b02d01e51d1b463fee0e">offset</a> is 0 and <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest#acded0bdebbfdd0ae0e503e767ec156cb">limit</a> is 5 this operation would return the first 5 series/tracks in <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest#a841767ddf7d2fe03d6531fd9cc1e48f0">tableName</a>. Each series/track will be returned sorted by their TIMESTAMP column.</p>

        <div>
          <div>Template Parameters</div>

          <div>
            <table>
              <tr>
                <td>TResponse</td>
                <td>The type of object being retrieved.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>schema\_</td>
                <td>Avro schema object used for decoding returned objects. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>

        <p>Definition at line <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">33769</a> of file <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">GPUdb.hpp</a>.</p>
      </div>
    </div>

    <h2><span><a href="#adbadeef2e1699ea4e5724e438c5efec9">◆ </a></span>getRecordsBySeries() <span>\[3/20]</span></h2>

    <div>
      <div>
        <div> template\<typename TResponse> </div>

        <table>
          <tr>
            <td>
              <table>
                <tr>
                  <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesResponse">GetRecordsBySeriesResponse</a>\< TResponse > gpudb::GPUdb::getRecordsBySeries </td>
                  <td>(</td>
                  <td>const ::avro::ValidSchema &</td>
                  <td><span><span>schema\_</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const std::string &</td>
                  <td><span><span>tableName</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const std::string &</td>
                  <td><span><span>worldTableName</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const int32\_t</td>
                  <td><span><span>offset</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const int32\_t</td>
                  <td><span><span>limit</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const std::map\< std::string, std::string > &</td>
                  <td><span><span>options</span></span> ) const</td>
                </tr>
              </table>
            </td>

            <td> <span><span>inline</span></span> </td>
          </tr>
        </table>
      </div>

      <div>
        <p>Retrieves the complete series/track records from the given <span>worldTableName</span> based on the partial track information contained in the <span>tableName</span>. </p>
        <p>This operation supports paging through the data via the <span>offset</span> and <span>limit</span> parameters.</p>
        <p>In contrast to <a href="#a2343e4363db89e8d9af6c93984e17dd9">getRecords</a> this returns records grouped by series/track. So if <span>offset</span> is 0 and <span>limit</span> is 5 this operation would return the first 5 series/tracks in <span>tableName</span>. Each series/track will be returned sorted by their TIMESTAMP column.</p>

        <div>
          <div>Template Parameters</div>

          <div>
            <table>
              <tr>
                <td>TResponse</td>
                <td>The type of object being retrieved.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>schema\_</td>
                <td>Avro schema object used for decoding returned objects. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of the table or view for which series/tracks will be fetched, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>worldTableName</td>
                <td>Name of the table containing the complete series/track information to be returned for the tracks present in the <span>tableName</span>, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. Typically this is used when retrieving series/tracks from a view (which contains partial series/tracks) but the user wants to retrieve the entire original series/tracks. Can be blank. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>offset</td>
                <td>A positive integer indicating the number of initial series/tracks to skip (useful for paging through the results). The default value is 0. The minimum allowed value is 0. The maximum allowed value is MAX\_INT. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>limit</td>
                <td>A positive integer indicating the maximum number of series/tracks to be returned. Or END\_OF\_SET (-9999) to indicate that the max number of results should be returned. The default value is 250. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesResponse">Response</a> object containing the result of the operation. </div>
        </div>

        <p>Definition at line <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">33894</a> of file <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">GPUdb.hpp</a>.</p>
      </div>
    </div>

    <h2><span><a href="#a648995d977040e1fd4634461ad398050">◆ </a></span>getRecordsBySeries() <span>\[4/20]</span></h2>

    <div>
      <div>
        <div> template\<typename TResponse> </div>

        <table>
          <tr>
            <td>
              <table>
                <tr>
                  <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesResponse">GetRecordsBySeriesResponse</a>\< TResponse > & gpudb::GPUdb::getRecordsBySeries </td>
                  <td>(</td>
                  <td>const ::avro::ValidSchema &</td>
                  <td><span><span>schema\_</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const std::string &</td>
                  <td><span><span>tableName</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const std::string &</td>
                  <td><span><span>worldTableName</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const int32\_t</td>
                  <td><span><span>offset</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const int32\_t</td>
                  <td><span><span>limit</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const std::map\< std::string, std::string > &</td>
                  <td><span><span>options</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesResponse">GetRecordsBySeriesResponse</a>\< TResponse > &</td>
                  <td><span><span>response\_</span></span> ) const</td>
                </tr>
              </table>
            </td>

            <td> <span><span>inline</span></span> </td>
          </tr>
        </table>
      </div>

      <div>
        <p>Retrieves the complete series/track records from the given <span>worldTableName</span> based on the partial track information contained in the <span>tableName</span>. </p>
        <p>This operation supports paging through the data via the <span>offset</span> and <span>limit</span> parameters.</p>
        <p>In contrast to <a href="#a2343e4363db89e8d9af6c93984e17dd9">getRecords</a> this returns records grouped by series/track. So if <span>offset</span> is 0 and <span>limit</span> is 5 this operation would return the first 5 series/tracks in <span>tableName</span>. Each series/track will be returned sorted by their TIMESTAMP column.</p>

        <div>
          <div>Template Parameters</div>

          <div>
            <table>
              <tr>
                <td>TResponse</td>
                <td>The type of object being retrieved.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>schema\_</td>
                <td>Avro schema object used for decoding returned objects. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of the table or view for which series/tracks will be fetched, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>worldTableName</td>
                <td>Name of the table containing the complete series/track information to be returned for the tracks present in the <span>tableName</span>, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. Typically this is used when retrieving series/tracks from a view (which contains partial series/tracks) but the user wants to retrieve the entire original series/tracks. Can be blank. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>offset</td>
                <td>A positive integer indicating the number of initial series/tracks to skip (useful for paging through the results). The default value is 0. The minimum allowed value is 0. The maximum allowed value is MAX\_INT. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>limit</td>
                <td>A positive integer indicating the maximum number of series/tracks to be returned. Or END\_OF\_SET (-9999) to indicate that the max number of results should be returned. The default value is 250. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>

        <p>Definition at line <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">34052</a> of file <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">GPUdb.hpp</a>.</p>
      </div>
    </div>

    <h2><span><a href="#aa961a79a8cd249ffe176b84eae64b232">◆ </a></span>getRecordsBySeries() <span>\[5/20]</span></h2>

    <div>
      <div>
        <div> template\<typename TResponse> </div>

        <table>
          <tr>
            <td>
              <table>
                <tr>
                  <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesResponse">GetRecordsBySeriesResponse</a>\< TResponse > gpudb::GPUdb::getRecordsBySeries </td>
                  <td>(</td>
                  <td>const <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest">GetRecordsBySeriesRequest</a> &</td>
                  <td><span><span>request\_</span></span></td>
                  <td>)</td>
                  <td> const</td>
                </tr>
              </table>
            </td>

            <td> <span><span>inline</span></span> </td>
          </tr>
        </table>
      </div>

      <div>
        <p>Retrieves the complete series/track records from the given <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest#a95d1e31e27c1d040de81b0ac7bd0d5ea">worldTableName</a> based on the partial track information contained in the <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest#a841767ddf7d2fe03d6531fd9cc1e48f0">tableName</a>. </p>
        <p>This operation supports paging through the data via the <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest#a6ec0f48f1904b02d01e51d1b463fee0e">offset</a> and <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest#acded0bdebbfdd0ae0e503e767ec156cb">limit</a> parameters.</p>
        <p>In contrast to <a href="#a32de6c3fa89b56e5c573cf04bbbafabb">getRecords</a> this returns records grouped by series/track. So if <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest#a6ec0f48f1904b02d01e51d1b463fee0e">offset</a> is 0 and <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest#acded0bdebbfdd0ae0e503e767ec156cb">limit</a> is 5 this operation would return the first 5 series/tracks in <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest#a841767ddf7d2fe03d6531fd9cc1e48f0">tableName</a>. Each series/track will be returned sorted by their TIMESTAMP column.</p>

        <div>
          <div>Template Parameters</div>

          <div>
            <table>
              <tr>
                <td>TResponse</td>
                <td>The type of object being retrieved.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesResponse">Response</a> object containing the result of the operation. </div>
        </div>

        <p>Definition at line <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">33404</a> of file <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">GPUdb.hpp</a>.</p>
      </div>
    </div>

    <h2><span><a href="#a5448180a122ebb057c93818e361042f2">◆ </a></span>getRecordsBySeries() <span>\[6/20]</span></h2>

    <div>
      <div>
        <div> template\<> </div>

        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesResponse">GetRecordsBySeriesResponse</a>\< boost::any > gpudb::GPUdb::getRecordsBySeries </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest">GetRecordsBySeriesRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Retrieves the complete series/track records from the given <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest#a95d1e31e27c1d040de81b0ac7bd0d5ea">worldTableName</a> based on the partial track information contained in the <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest#a841767ddf7d2fe03d6531fd9cc1e48f0">tableName</a>. </p>
        <p>This operation supports paging through the data via the <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest#a6ec0f48f1904b02d01e51d1b463fee0e">offset</a> and <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest#acded0bdebbfdd0ae0e503e767ec156cb">limit</a> parameters.</p>
        <p>In contrast to <a href="#a32de6c3fa89b56e5c573cf04bbbafabb">getRecords</a> this returns records grouped by series/track. So if <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest#a6ec0f48f1904b02d01e51d1b463fee0e">offset</a> is 0 and <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest#acded0bdebbfdd0ae0e503e767ec156cb">limit</a> is 5 this operation would return the first 5 series/tracks in <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest#a841767ddf7d2fe03d6531fd9cc1e48f0">tableName</a>. Each series/track will be returned sorted by their TIMESTAMP column.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a5448180a122ebb057c93818e361042f2">◆ </a></span>getRecordsBySeries() <span>\[7/20]</span></h2>

    <div>
      <div>
        <div> template\<> </div>

        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesResponse">GetRecordsBySeriesResponse</a>\< boost::any > gpudb::GPUdb::getRecordsBySeries </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest">GetRecordsBySeriesRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Retrieves the complete series/track records from the given <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest#a95d1e31e27c1d040de81b0ac7bd0d5ea">worldTableName</a> based on the partial track information contained in the <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest#a841767ddf7d2fe03d6531fd9cc1e48f0">tableName</a>. </p>
        <p>This operation supports paging through the data via the <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest#a6ec0f48f1904b02d01e51d1b463fee0e">offset</a> and <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest#acded0bdebbfdd0ae0e503e767ec156cb">limit</a> parameters.</p>
        <p>In contrast to <a href="#a32de6c3fa89b56e5c573cf04bbbafabb">getRecords</a> this returns records grouped by series/track. So if <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest#a6ec0f48f1904b02d01e51d1b463fee0e">offset</a> is 0 and <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest#acded0bdebbfdd0ae0e503e767ec156cb">limit</a> is 5 this operation would return the first 5 series/tracks in <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest#a841767ddf7d2fe03d6531fd9cc1e48f0">tableName</a>. Each series/track will be returned sorted by their TIMESTAMP column.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a4472cedbdb7c41b76b7469d845cf89bb">◆ </a></span>getRecordsBySeries() <span>\[8/20]</span></h2>

    <div>
      <div>
        <div> template\<> </div>

        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesResponse">GetRecordsBySeriesResponse</a>\< boost::any > & gpudb::GPUdb::getRecordsBySeries </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest">GetRecordsBySeriesRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesResponse">GetRecordsBySeriesResponse</a>\< boost::any > &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Retrieves the complete series/track records from the given <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest#a95d1e31e27c1d040de81b0ac7bd0d5ea">worldTableName</a> based on the partial track information contained in the <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest#a841767ddf7d2fe03d6531fd9cc1e48f0">tableName</a>. </p>
        <p>This operation supports paging through the data via the <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest#a6ec0f48f1904b02d01e51d1b463fee0e">offset</a> and <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest#acded0bdebbfdd0ae0e503e767ec156cb">limit</a> parameters.</p>
        <p>In contrast to <a href="#a32de6c3fa89b56e5c573cf04bbbafabb">getRecords</a> this returns records grouped by series/track. So if <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest#a6ec0f48f1904b02d01e51d1b463fee0e">offset</a> is 0 and <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest#acded0bdebbfdd0ae0e503e767ec156cb">limit</a> is 5 this operation would return the first 5 series/tracks in <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest#a841767ddf7d2fe03d6531fd9cc1e48f0">tableName</a>. Each series/track will be returned sorted by their TIMESTAMP column.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a4472cedbdb7c41b76b7469d845cf89bb">◆ </a></span>getRecordsBySeries() <span>\[9/20]</span></h2>

    <div>
      <div>
        <div> template\<> </div>

        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesResponse">GetRecordsBySeriesResponse</a>\< boost::any > & gpudb::GPUdb::getRecordsBySeries </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest">GetRecordsBySeriesRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesResponse">GetRecordsBySeriesResponse</a>\< boost::any > &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Retrieves the complete series/track records from the given <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest#a95d1e31e27c1d040de81b0ac7bd0d5ea">worldTableName</a> based on the partial track information contained in the <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest#a841767ddf7d2fe03d6531fd9cc1e48f0">tableName</a>. </p>
        <p>This operation supports paging through the data via the <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest#a6ec0f48f1904b02d01e51d1b463fee0e">offset</a> and <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest#acded0bdebbfdd0ae0e503e767ec156cb">limit</a> parameters.</p>
        <p>In contrast to <a href="#a32de6c3fa89b56e5c573cf04bbbafabb">getRecords</a> this returns records grouped by series/track. So if <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest#a6ec0f48f1904b02d01e51d1b463fee0e">offset</a> is 0 and <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest#acded0bdebbfdd0ae0e503e767ec156cb">limit</a> is 5 this operation would return the first 5 series/tracks in <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest#a841767ddf7d2fe03d6531fd9cc1e48f0">tableName</a>. Each series/track will be returned sorted by their TIMESTAMP column.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a84b5e781d7c9bb6df27e18783077961c">◆ </a></span>getRecordsBySeries() <span>\[10/20]</span></h2>

    <div>
      <div>
        <div> template\<typename TResponse> </div>

        <table>
          <tr>
            <td>
              <table>
                <tr>
                  <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesResponse">GetRecordsBySeriesResponse</a>\< TResponse > & gpudb::GPUdb::getRecordsBySeries </td>
                  <td>(</td>
                  <td>const <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest">GetRecordsBySeriesRequest</a> &</td>
                  <td><span><span>request\_</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesResponse">GetRecordsBySeriesResponse</a>\< TResponse > &</td>
                  <td><span><span>response\_</span></span> ) const</td>
                </tr>
              </table>
            </td>

            <td> <span><span>inline</span></span> </td>
          </tr>
        </table>
      </div>

      <div>
        <p>Retrieves the complete series/track records from the given <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest#a95d1e31e27c1d040de81b0ac7bd0d5ea">worldTableName</a> based on the partial track information contained in the <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest#a841767ddf7d2fe03d6531fd9cc1e48f0">tableName</a>. </p>
        <p>This operation supports paging through the data via the <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest#a6ec0f48f1904b02d01e51d1b463fee0e">offset</a> and <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest#acded0bdebbfdd0ae0e503e767ec156cb">limit</a> parameters.</p>
        <p>In contrast to <a href="#a32de6c3fa89b56e5c573cf04bbbafabb">getRecords</a> this returns records grouped by series/track. So if <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest#a6ec0f48f1904b02d01e51d1b463fee0e">offset</a> is 0 and <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest#acded0bdebbfdd0ae0e503e767ec156cb">limit</a> is 5 this operation would return the first 5 series/tracks in <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest#a841767ddf7d2fe03d6531fd9cc1e48f0">tableName</a>. Each series/track will be returned sorted by their TIMESTAMP column.</p>

        <div>
          <div>Template Parameters</div>

          <div>
            <table>
              <tr>
                <td>TResponse</td>
                <td>The type of object being retrieved.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>

        <p>Definition at line <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">33456</a> of file <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">GPUdb.hpp</a>.</p>
      </div>
    </div>

    <h2><span><a href="#a9ba2f4912ef6f4cc2f52e93850de4824">◆ </a></span>getRecordsBySeries() <span>\[11/20]</span></h2>

    <div>
      <div>
        <div> template\<typename TResponse> </div>

        <table>
          <tr>
            <td>
              <table>
                <tr>
                  <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesResponse">GetRecordsBySeriesResponse</a>\< TResponse > gpudb::GPUdb::getRecordsBySeries </td>
                  <td>(</td>
                  <td>const std::string &</td>
                  <td><span><span>tableName</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const std::string &</td>
                  <td><span><span>worldTableName</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const int32\_t</td>
                  <td><span><span>offset</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const int32\_t</td>
                  <td><span><span>limit</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const std::map\< std::string, std::string > &</td>
                  <td><span><span>options</span></span> ) const</td>
                </tr>
              </table>
            </td>

            <td> <span><span>inline</span></span> </td>
          </tr>
        </table>
      </div>

      <div>
        <p>Retrieves the complete series/track records from the given <span>worldTableName</span> based on the partial track information contained in the <span>tableName</span>. </p>
        <p>This operation supports paging through the data via the <span>offset</span> and <span>limit</span> parameters.</p>
        <p>In contrast to <a href="#a6b39d1540501defd2bdb03feed7928f8">getRecords</a> this returns records grouped by series/track. So if <span>offset</span> is 0 and <span>limit</span> is 5 this operation would return the first 5 series/tracks in <span>tableName</span>. Each series/track will be returned sorted by their TIMESTAMP column.</p>

        <div>
          <div>Template Parameters</div>

          <div>
            <table>
              <tr>
                <td>TResponse</td>
                <td>The type of object being retrieved.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of the table or view for which series/tracks will be fetched, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>worldTableName</td>
                <td>Name of the table containing the complete series/track information to be returned for the tracks present in the <span>tableName</span>, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. Typically this is used when retrieving series/tracks from a view (which contains partial series/tracks) but the user wants to retrieve the entire original series/tracks. Can be blank. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>offset</td>
                <td>A positive integer indicating the number of initial series/tracks to skip (useful for paging through the results). The default value is 0. The minimum allowed value is 0. The maximum allowed value is MAX\_INT. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>limit</td>
                <td>A positive integer indicating the maximum number of series/tracks to be returned. Or END\_OF\_SET (-9999) to indicate that the max number of results should be returned. The default value is 250. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesResponse">Response</a> object containing the result of the operation. </div>
        </div>

        <p>Definition at line <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">33525</a> of file <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">GPUdb.hpp</a>.</p>
      </div>
    </div>

    <h2><span><a href="#a8b19920b585e87bcc6cfe6468f2eddb2">◆ </a></span>getRecordsBySeries() <span>\[12/20]</span></h2>

    <div>
      <div>
        <div> template\<> </div>

        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesResponse">GetRecordsBySeriesResponse</a>\< boost::any > gpudb::GPUdb::getRecordsBySeries </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>worldTableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const int32\_t</td>
            <td><span><span>offset</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const int32\_t</td>
            <td><span><span>limit</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Retrieves the complete series/track records from the given <span>worldTableName</span> based on the partial track information contained in the <span>tableName</span>. </p>
        <p>This operation supports paging through the data via the <span>offset</span> and <span>limit</span> parameters.</p>
        <p>In contrast to <a href="#a6b39d1540501defd2bdb03feed7928f8">getRecords</a> this returns records grouped by series/track. So if <span>offset</span> is 0 and <span>limit</span> is 5 this operation would return the first 5 series/tracks in <span>tableName</span>. Each series/track will be returned sorted by their TIMESTAMP column.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of the table or view for which series/tracks will be fetched, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>worldTableName</td>
                <td>Name of the table containing the complete series/track information to be returned for the tracks present in the <span>tableName</span>, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. Typically this is used when retrieving series/tracks from a view (which contains partial series/tracks) but the user wants to retrieve the entire original series/tracks. Can be blank. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>offset</td>
                <td>A positive integer indicating the number of initial series/tracks to skip (useful for paging through the results). The default value is 0. The minimum allowed value is 0. The maximum allowed value is MAX\_INT. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>limit</td>
                <td>A positive integer indicating the maximum number of series/tracks to be returned. Or END\_OF\_SET (-9999) to indicate that the max number of results should be returned. The default value is 250. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a8b19920b585e87bcc6cfe6468f2eddb2">◆ </a></span>getRecordsBySeries() <span>\[13/20]</span></h2>

    <div>
      <div>
        <div> template\<> </div>

        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesResponse">GetRecordsBySeriesResponse</a>\< boost::any > gpudb::GPUdb::getRecordsBySeries </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>worldTableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const int32\_t</td>
            <td><span><span>offset</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const int32\_t</td>
            <td><span><span>limit</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Retrieves the complete series/track records from the given <span>worldTableName</span> based on the partial track information contained in the <span>tableName</span>. </p>
        <p>This operation supports paging through the data via the <span>offset</span> and <span>limit</span> parameters.</p>
        <p>In contrast to <a href="#a6b39d1540501defd2bdb03feed7928f8">getRecords</a> this returns records grouped by series/track. So if <span>offset</span> is 0 and <span>limit</span> is 5 this operation would return the first 5 series/tracks in <span>tableName</span>. Each series/track will be returned sorted by their TIMESTAMP column.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of the table or view for which series/tracks will be fetched, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>worldTableName</td>
                <td>Name of the table containing the complete series/track information to be returned for the tracks present in the <span>tableName</span>, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. Typically this is used when retrieving series/tracks from a view (which contains partial series/tracks) but the user wants to retrieve the entire original series/tracks. Can be blank. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>offset</td>
                <td>A positive integer indicating the number of initial series/tracks to skip (useful for paging through the results). The default value is 0. The minimum allowed value is 0. The maximum allowed value is MAX\_INT. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>limit</td>
                <td>A positive integer indicating the maximum number of series/tracks to be returned. Or END\_OF\_SET (-9999) to indicate that the max number of results should be returned. The default value is 250. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#aa7203f56d0aa4580270a3b957d80701f">◆ </a></span>getRecordsBySeries() <span>\[14/20]</span></h2>

    <div>
      <div>
        <div> template\<> </div>

        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesResponse">GetRecordsBySeriesResponse</a>\< boost::any > & gpudb::GPUdb::getRecordsBySeries </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>worldTableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const int32\_t</td>
            <td><span><span>offset</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const int32\_t</td>
            <td><span><span>limit</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesResponse">GetRecordsBySeriesResponse</a>\< boost::any > &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Retrieves the complete series/track records from the given <span>worldTableName</span> based on the partial track information contained in the <span>tableName</span>. </p>
        <p>This operation supports paging through the data via the <span>offset</span> and <span>limit</span> parameters.</p>
        <p>In contrast to <a href="#a6b39d1540501defd2bdb03feed7928f8">getRecords</a> this returns records grouped by series/track. So if <span>offset</span> is 0 and <span>limit</span> is 5 this operation would return the first 5 series/tracks in <span>tableName</span>. Each series/track will be returned sorted by their TIMESTAMP column.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of the table or view for which series/tracks will be fetched, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>worldTableName</td>
                <td>Name of the table containing the complete series/track information to be returned for the tracks present in the <span>tableName</span>, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. Typically this is used when retrieving series/tracks from a view (which contains partial series/tracks) but the user wants to retrieve the entire original series/tracks. Can be blank. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>offset</td>
                <td>A positive integer indicating the number of initial series/tracks to skip (useful for paging through the results). The default value is 0. The minimum allowed value is 0. The maximum allowed value is MAX\_INT. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>limit</td>
                <td>A positive integer indicating the maximum number of series/tracks to be returned. Or END\_OF\_SET (-9999) to indicate that the max number of results should be returned. The default value is 250. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#aa7203f56d0aa4580270a3b957d80701f">◆ </a></span>getRecordsBySeries() <span>\[15/20]</span></h2>

    <div>
      <div>
        <div> template\<> </div>

        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesResponse">GetRecordsBySeriesResponse</a>\< boost::any > & gpudb::GPUdb::getRecordsBySeries </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>worldTableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const int32\_t</td>
            <td><span><span>offset</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const int32\_t</td>
            <td><span><span>limit</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesResponse">GetRecordsBySeriesResponse</a>\< boost::any > &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Retrieves the complete series/track records from the given <span>worldTableName</span> based on the partial track information contained in the <span>tableName</span>. </p>
        <p>This operation supports paging through the data via the <span>offset</span> and <span>limit</span> parameters.</p>
        <p>In contrast to <a href="#a6b39d1540501defd2bdb03feed7928f8">getRecords</a> this returns records grouped by series/track. So if <span>offset</span> is 0 and <span>limit</span> is 5 this operation would return the first 5 series/tracks in <span>tableName</span>. Each series/track will be returned sorted by their TIMESTAMP column.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of the table or view for which series/tracks will be fetched, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>worldTableName</td>
                <td>Name of the table containing the complete series/track information to be returned for the tracks present in the <span>tableName</span>, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. Typically this is used when retrieving series/tracks from a view (which contains partial series/tracks) but the user wants to retrieve the entire original series/tracks. Can be blank. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>offset</td>
                <td>A positive integer indicating the number of initial series/tracks to skip (useful for paging through the results). The default value is 0. The minimum allowed value is 0. The maximum allowed value is MAX\_INT. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>limit</td>
                <td>A positive integer indicating the maximum number of series/tracks to be returned. Or END\_OF\_SET (-9999) to indicate that the max number of results should be returned. The default value is 250. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a0421cd2f9891fff85f049e76c93faf53">◆ </a></span>getRecordsBySeries() <span>\[16/20]</span></h2>

    <div>
      <div>
        <div> template\<typename TResponse> </div>

        <table>
          <tr>
            <td>
              <table>
                <tr>
                  <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesResponse">GetRecordsBySeriesResponse</a>\< TResponse > & gpudb::GPUdb::getRecordsBySeries </td>
                  <td>(</td>
                  <td>const std::string &</td>
                  <td><span><span>tableName</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const std::string &</td>
                  <td><span><span>worldTableName</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const int32\_t</td>
                  <td><span><span>offset</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const int32\_t</td>
                  <td><span><span>limit</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const std::map\< std::string, std::string > &</td>
                  <td><span><span>options</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesResponse">GetRecordsBySeriesResponse</a>\< TResponse > &</td>
                  <td><span><span>response\_</span></span> ) const</td>
                </tr>
              </table>
            </td>

            <td> <span><span>inline</span></span> </td>
          </tr>
        </table>
      </div>

      <div>
        <p>Retrieves the complete series/track records from the given <span>worldTableName</span> based on the partial track information contained in the <span>tableName</span>. </p>
        <p>This operation supports paging through the data via the <span>offset</span> and <span>limit</span> parameters.</p>
        <p>In contrast to <a href="#a6b39d1540501defd2bdb03feed7928f8">getRecords</a> this returns records grouped by series/track. So if <span>offset</span> is 0 and <span>limit</span> is 5 this operation would return the first 5 series/tracks in <span>tableName</span>. Each series/track will be returned sorted by their TIMESTAMP column.</p>

        <div>
          <div>Template Parameters</div>

          <div>
            <table>
              <tr>
                <td>TResponse</td>
                <td>The type of object being retrieved.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of the table or view for which series/tracks will be fetched, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>worldTableName</td>
                <td>Name of the table containing the complete series/track information to be returned for the tracks present in the <span>tableName</span>, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. Typically this is used when retrieving series/tracks from a view (which contains partial series/tracks) but the user wants to retrieve the entire original series/tracks. Can be blank. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>offset</td>
                <td>A positive integer indicating the number of initial series/tracks to skip (useful for paging through the results). The default value is 0. The minimum allowed value is 0. The maximum allowed value is MAX\_INT. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>limit</td>
                <td>A positive integer indicating the maximum number of series/tracks to be returned. Or END\_OF\_SET (-9999) to indicate that the max number of results should be returned. The default value is 250. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>

        <p>Definition at line <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">33603</a> of file <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">GPUdb.hpp</a>.</p>
      </div>
    </div>

    <h2><span><a href="#a259ec9a4402b0e87b8556722fdf803bb">◆ </a></span>getRecordsBySeries() <span>\[17/20]</span></h2>

    <div>
      <div>
        <div> template\<typename TResponse> </div>

        <table>
          <tr>
            <td>
              <table>
                <tr>
                  <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesResponse">GetRecordsBySeriesResponse</a>\< TResponse > gpudb::GPUdb::getRecordsBySeries </td>
                  <td>(</td>
                  <td>const <a href="/content/api/cpp/classgpudb_1_1Type">Type</a> &</td>
                  <td><span><span>type\_</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest">GetRecordsBySeriesRequest</a> &</td>
                  <td><span><span>request\_</span></span> ) const</td>
                </tr>
              </table>
            </td>

            <td> <span><span>inline</span></span> </td>
          </tr>
        </table>
      </div>

      <div>
        <p>Retrieves the complete series/track records from the given <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest#a95d1e31e27c1d040de81b0ac7bd0d5ea">worldTableName</a> based on the partial track information contained in the <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest#a841767ddf7d2fe03d6531fd9cc1e48f0">tableName</a>. </p>
        <p>This operation supports paging through the data via the <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest#a6ec0f48f1904b02d01e51d1b463fee0e">offset</a> and <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest#acded0bdebbfdd0ae0e503e767ec156cb">limit</a> parameters.</p>
        <p>In contrast to <a href="#a65a981945189ac5191f6ef8236736b18">getRecords</a> this returns records grouped by series/track. So if <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest#a6ec0f48f1904b02d01e51d1b463fee0e">offset</a> is 0 and <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest#acded0bdebbfdd0ae0e503e767ec156cb">limit</a> is 5 this operation would return the first 5 series/tracks in <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest#a841767ddf7d2fe03d6531fd9cc1e48f0">tableName</a>. Each series/track will be returned sorted by their TIMESTAMP column.</p>

        <div>
          <div>Template Parameters</div>

          <div>
            <table>
              <tr>
                <td>TResponse</td>
                <td>The type of object being retrieved.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>type\_</td>
                <td><a href="/content/api/cpp/classgpudb_1_1Type">Type</a> object used for decoding returned objects. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesResponse">Response</a> object containing the result of the operation. </div>
        </div>

        <p>Definition at line <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">33714</a> of file <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">GPUdb.hpp</a>.</p>
      </div>
    </div>

    <h2><span><a href="#a5028b0c27cc919a440c81c036e3ddf41">◆ </a></span>getRecordsBySeries() <span>\[18/20]</span></h2>

    <div>
      <div>
        <div> template\<typename TResponse> </div>

        <table>
          <tr>
            <td>
              <table>
                <tr>
                  <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesResponse">GetRecordsBySeriesResponse</a>\< TResponse > & gpudb::GPUdb::getRecordsBySeries </td>
                  <td>(</td>
                  <td>const <a href="/content/api/cpp/classgpudb_1_1Type">Type</a> &</td>
                  <td><span><span>type\_</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest">GetRecordsBySeriesRequest</a> &</td>
                  <td><span><span>request\_</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesResponse">GetRecordsBySeriesResponse</a>\< TResponse > &</td>
                  <td><span><span>response\_</span></span> ) const</td>
                </tr>
              </table>
            </td>

            <td> <span><span>inline</span></span> </td>
          </tr>
        </table>
      </div>

      <div>
        <p>Retrieves the complete series/track records from the given <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest#a95d1e31e27c1d040de81b0ac7bd0d5ea">worldTableName</a> based on the partial track information contained in the <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest#a841767ddf7d2fe03d6531fd9cc1e48f0">tableName</a>. </p>
        <p>This operation supports paging through the data via the <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest#a6ec0f48f1904b02d01e51d1b463fee0e">offset</a> and <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest#acded0bdebbfdd0ae0e503e767ec156cb">limit</a> parameters.</p>
        <p>In contrast to <a href="#a65a981945189ac5191f6ef8236736b18">getRecords</a> this returns records grouped by series/track. So if <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest#a6ec0f48f1904b02d01e51d1b463fee0e">offset</a> is 0 and <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest#acded0bdebbfdd0ae0e503e767ec156cb">limit</a> is 5 this operation would return the first 5 series/tracks in <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest#a841767ddf7d2fe03d6531fd9cc1e48f0">tableName</a>. Each series/track will be returned sorted by their TIMESTAMP column.</p>

        <div>
          <div>Template Parameters</div>

          <div>
            <table>
              <tr>
                <td>TResponse</td>
                <td>The type of object being retrieved.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>type\_</td>
                <td><a href="/content/api/cpp/classgpudb_1_1Type">Type</a> object used for decoding returned objects. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>

        <p>Definition at line <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">33823</a> of file <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">GPUdb.hpp</a>.</p>
      </div>
    </div>

    <h2><span><a href="#a9c776cbfb140d5a261926d7082e84c1d">◆ </a></span>getRecordsBySeries() <span>\[19/20]</span></h2>

    <div>
      <div>
        <div> template\<typename TResponse> </div>

        <table>
          <tr>
            <td>
              <table>
                <tr>
                  <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesResponse">GetRecordsBySeriesResponse</a>\< TResponse > gpudb::GPUdb::getRecordsBySeries </td>
                  <td>(</td>
                  <td>const <a href="/content/api/cpp/classgpudb_1_1Type">Type</a> &</td>
                  <td><span><span>type\_</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const std::string &</td>
                  <td><span><span>tableName</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const std::string &</td>
                  <td><span><span>worldTableName</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const int32\_t</td>
                  <td><span><span>offset</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const int32\_t</td>
                  <td><span><span>limit</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const std::map\< std::string, std::string > &</td>
                  <td><span><span>options</span></span> ) const</td>
                </tr>
              </table>
            </td>

            <td> <span><span>inline</span></span> </td>
          </tr>
        </table>
      </div>

      <div>
        <p>Retrieves the complete series/track records from the given <span>worldTableName</span> based on the partial track information contained in the <span>tableName</span>. </p>
        <p>This operation supports paging through the data via the <span>offset</span> and <span>limit</span> parameters.</p>
        <p>In contrast to <a href="#a7f3ab43aa42646aec1a2ac7bea148f9d">getRecords</a> this returns records grouped by series/track. So if <span>offset</span> is 0 and <span>limit</span> is 5 this operation would return the first 5 series/tracks in <span>tableName</span>. Each series/track will be returned sorted by their TIMESTAMP column.</p>

        <div>
          <div>Template Parameters</div>

          <div>
            <table>
              <tr>
                <td>TResponse</td>
                <td>The type of object being retrieved.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>type\_</td>
                <td><a href="/content/api/cpp/classgpudb_1_1Type">Type</a> object used for decoding returned objects. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of the table or view for which series/tracks will be fetched, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>worldTableName</td>
                <td>Name of the table containing the complete series/track information to be returned for the tracks present in the <span>tableName</span>, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. Typically this is used when retrieving series/tracks from a view (which contains partial series/tracks) but the user wants to retrieve the entire original series/tracks. Can be blank. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>offset</td>
                <td>A positive integer indicating the number of initial series/tracks to skip (useful for paging through the results). The default value is 0. The minimum allowed value is 0. The maximum allowed value is MAX\_INT. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>limit</td>
                <td>A positive integer indicating the maximum number of series/tracks to be returned. Or END\_OF\_SET (-9999) to indicate that the max number of results should be returned. The default value is 250. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesResponse">Response</a> object containing the result of the operation. </div>
        </div>

        <p>Definition at line <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">33972</a> of file <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">GPUdb.hpp</a>.</p>
      </div>
    </div>

    <h2><span><a href="#a41ccbfa4677bbce9629b3d8f793884d4">◆ </a></span>getRecordsBySeries() <span>\[20/20]</span></h2>

    <div>
      <div>
        <div> template\<typename TResponse> </div>

        <table>
          <tr>
            <td>
              <table>
                <tr>
                  <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesResponse">GetRecordsBySeriesResponse</a>\< TResponse > & gpudb::GPUdb::getRecordsBySeries </td>
                  <td>(</td>
                  <td>const <a href="/content/api/cpp/classgpudb_1_1Type">Type</a> &</td>
                  <td><span><span>type\_</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const std::string &</td>
                  <td><span><span>tableName</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const std::string &</td>
                  <td><span><span>worldTableName</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const int32\_t</td>
                  <td><span><span>offset</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const int32\_t</td>
                  <td><span><span>limit</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const std::map\< std::string, std::string > &</td>
                  <td><span><span>options</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesResponse">GetRecordsBySeriesResponse</a>\< TResponse > &</td>
                  <td><span><span>response\_</span></span> ) const</td>
                </tr>
              </table>
            </td>

            <td> <span><span>inline</span></span> </td>
          </tr>
        </table>
      </div>

      <div>
        <p>Retrieves the complete series/track records from the given <span>worldTableName</span> based on the partial track information contained in the <span>tableName</span>. </p>
        <p>This operation supports paging through the data via the <span>offset</span> and <span>limit</span> parameters.</p>
        <p>In contrast to <a href="#a7f3ab43aa42646aec1a2ac7bea148f9d">getRecords</a> this returns records grouped by series/track. So if <span>offset</span> is 0 and <span>limit</span> is 5 this operation would return the first 5 series/tracks in <span>tableName</span>. Each series/track will be returned sorted by their TIMESTAMP column.</p>

        <div>
          <div>Template Parameters</div>

          <div>
            <table>
              <tr>
                <td>TResponse</td>
                <td>The type of object being retrieved.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>type\_</td>
                <td><a href="/content/api/cpp/classgpudb_1_1Type">Type</a> object used for decoding returned objects. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of the table or view for which series/tracks will be fetched, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>worldTableName</td>
                <td>Name of the table containing the complete series/track information to be returned for the tracks present in the <span>tableName</span>, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. Typically this is used when retrieving series/tracks from a view (which contains partial series/tracks) but the user wants to retrieve the entire original series/tracks. Can be blank. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>offset</td>
                <td>A positive integer indicating the number of initial series/tracks to skip (useful for paging through the results). The default value is 0. The minimum allowed value is 0. The maximum allowed value is MAX\_INT. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>limit</td>
                <td>A positive integer indicating the maximum number of series/tracks to be returned. Or END\_OF\_SET (-9999) to indicate that the max number of results should be returned. The default value is 250. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>

        <p>Definition at line <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">34132</a> of file <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">GPUdb.hpp</a>.</p>
      </div>
    </div>

    <h2><span><a href="#ad755a200d4461a7f999906a2a4695fa9">◆ </a></span>getRecordsBySeriesRaw() <span>\[1/2]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1RawGetRecordsBySeriesResponse">RawGetRecordsBySeriesResponse</a> gpudb::GPUdb::getRecordsBySeriesRaw </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest">GetRecordsBySeriesRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Retrieves the complete series/track records from the given <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest#a95d1e31e27c1d040de81b0ac7bd0d5ea">worldTableName</a> based on the partial track information contained in the <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest#a841767ddf7d2fe03d6531fd9cc1e48f0">tableName</a>. </p>
        <p>This operation supports paging through the data via the <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest#a6ec0f48f1904b02d01e51d1b463fee0e">offset</a> and <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest#acded0bdebbfdd0ae0e503e767ec156cb">limit</a> parameters.</p>
        <p>In contrast to <a href="#afefae2f48831c864d2f19e27fbb2ad65">getRecordsRaw</a> this returns records grouped by series/track. So if <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest#a6ec0f48f1904b02d01e51d1b463fee0e">offset</a> is 0 and <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest#acded0bdebbfdd0ae0e503e767ec156cb">limit</a> is 5 this operation would return the first 5 series/tracks in <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest#a841767ddf7d2fe03d6531fd9cc1e48f0">tableName</a>. Each series/track will be returned sorted by their TIMESTAMP column.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1RawGetRecordsBySeriesResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a05f9b2f364e233b9c1f7fbb8080aeb09">◆ </a></span>getRecordsBySeriesRaw() <span>\[2/2]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1RawGetRecordsBySeriesResponse">RawGetRecordsBySeriesResponse</a> & gpudb::GPUdb::getRecordsBySeriesRaw </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest">GetRecordsBySeriesRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1RawGetRecordsBySeriesResponse">RawGetRecordsBySeriesResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Retrieves the complete series/track records from the given <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest#a95d1e31e27c1d040de81b0ac7bd0d5ea">worldTableName</a> based on the partial track information contained in the <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest#a841767ddf7d2fe03d6531fd9cc1e48f0">tableName</a>. </p>
        <p>This operation supports paging through the data via the <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest#a6ec0f48f1904b02d01e51d1b463fee0e">offset</a> and <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest#acded0bdebbfdd0ae0e503e767ec156cb">limit</a> parameters.</p>
        <p>In contrast to <a href="#afefae2f48831c864d2f19e27fbb2ad65">getRecordsRaw</a> this returns records grouped by series/track. So if <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest#a6ec0f48f1904b02d01e51d1b463fee0e">offset</a> is 0 and <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest#acded0bdebbfdd0ae0e503e767ec156cb">limit</a> is 5 this operation would return the first 5 series/tracks in <a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest#a841767ddf7d2fe03d6531fd9cc1e48f0">tableName</a>. Each series/track will be returned sorted by their TIMESTAMP column.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsBySeriesRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1RawGetRecordsBySeriesResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1RawGetRecordsBySeriesResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a1ba5c0e420cec6f8947cd6dcd2fd815f">◆ </a></span>getRecordsFromCollection() <span>\[1/20]</span></h2>

    <div>
      <div>
        <div> template\<typename TResponse> </div>

        <table>
          <tr>
            <td>
              <table>
                <tr>
                  <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionResponse">GetRecordsFromCollectionResponse</a>\< TResponse > gpudb::GPUdb::getRecordsFromCollection </td>
                  <td>(</td>
                  <td>const ::avro::ValidSchema &</td>
                  <td><span><span>schema\_</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const <a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionRequest">GetRecordsFromCollectionRequest</a> &</td>
                  <td><span><span>request\_</span></span> ) const</td>
                </tr>
              </table>
            </td>

            <td> <span><span>inline</span></span> </td>
          </tr>
        </table>
      </div>

      <div>
        <p>Retrieves records from a collection. </p>
        <p>The operation can optionally return the record IDs which can be used in certain queries such as <a href="#a8f916f1513778ef51cfb294659f452ae">deleteRecords</a>.</p>
        <p>This operation supports paging through the data via the <a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionRequest#a80af610012202241c80bcc0a23466f76">offset</a> and <a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionRequest#af08501c9b67fbbee5a8195313d7e7120">limit</a> parameters.</p>
        <p>Note that when using the Java API, it is not possible to retrieve records from join views using this operation. (DEPRECATED)</p>

        <div>
          <div>Template Parameters</div>

          <div>
            <table>
              <tr>
                <td>TResponse</td>
                <td>The type of object being retrieved.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>schema\_</td>
                <td>Avro schema object used for decoding returned objects. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionResponse">Response</a> object containing the result of the operation. </div>
        </div>

        <p>Definition at line <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">34496</a> of file <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">GPUdb.hpp</a>.</p>
      </div>
    </div>

    <h2><span><a href="#aacfa6bf43de67a468d40a0c6aa8b0f9e">◆ </a></span>getRecordsFromCollection() <span>\[2/20]</span></h2>

    <div>
      <div>
        <div> template\<typename TResponse> </div>

        <table>
          <tr>
            <td>
              <table>
                <tr>
                  <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionResponse">GetRecordsFromCollectionResponse</a>\< TResponse > & gpudb::GPUdb::getRecordsFromCollection </td>
                  <td>(</td>
                  <td>const ::avro::ValidSchema &</td>
                  <td><span><span>schema\_</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const <a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionRequest">GetRecordsFromCollectionRequest</a> &</td>
                  <td><span><span>request\_</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionResponse">GetRecordsFromCollectionResponse</a>\< TResponse > &</td>
                  <td><span><span>response\_</span></span> ) const</td>
                </tr>
              </table>
            </td>

            <td> <span><span>inline</span></span> </td>
          </tr>
        </table>
      </div>

      <div>
        <p>Retrieves records from a collection. </p>
        <p>The operation can optionally return the record IDs which can be used in certain queries such as <a href="#a8f916f1513778ef51cfb294659f452ae">deleteRecords</a>.</p>
        <p>This operation supports paging through the data via the <a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionRequest#a80af610012202241c80bcc0a23466f76">offset</a> and <a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionRequest#af08501c9b67fbbee5a8195313d7e7120">limit</a> parameters.</p>
        <p>Note that when using the Java API, it is not possible to retrieve records from join views using this operation. (DEPRECATED)</p>

        <div>
          <div>Template Parameters</div>

          <div>
            <table>
              <tr>
                <td>TResponse</td>
                <td>The type of object being retrieved.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>schema\_</td>
                <td>Avro schema object used for decoding returned objects. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>

        <p>Definition at line <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">34584</a> of file <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">GPUdb.hpp</a>.</p>
      </div>
    </div>

    <h2><span><a href="#ab6e252847329faf291bc90d214718650">◆ </a></span>getRecordsFromCollection() <span>\[3/20]</span></h2>

    <div>
      <div>
        <div> template\<typename TResponse> </div>

        <table>
          <tr>
            <td>
              <table>
                <tr>
                  <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionResponse">GetRecordsFromCollectionResponse</a>\< TResponse > gpudb::GPUdb::getRecordsFromCollection </td>
                  <td>(</td>
                  <td>const ::avro::ValidSchema &</td>
                  <td><span><span>schema\_</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const std::string &</td>
                  <td><span><span>tableName</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const int64\_t</td>
                  <td><span><span>offset</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const int64\_t</td>
                  <td><span><span>limit</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const std::map\< std::string, std::string > &</td>
                  <td><span><span>options</span></span> ) const</td>
                </tr>
              </table>
            </td>

            <td> <span><span>inline</span></span> </td>
          </tr>
        </table>
      </div>

      <div>
        <p>Retrieves records from a collection. </p>
        <p>The operation can optionally return the record IDs which can be used in certain queries such as <a href="#a8f916f1513778ef51cfb294659f452ae">deleteRecords</a>.</p>
        <p>This operation supports paging through the data via the <span>offset</span> and <span>limit</span> parameters.</p>
        <p>Note that when using the Java API, it is not possible to retrieve records from join views using this operation. (DEPRECATED)</p>

        <div>
          <div>Template Parameters</div>

          <div>
            <table>
              <tr>
                <td>TResponse</td>
                <td>The type of object being retrieved.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>schema\_</td>
                <td>Avro schema object used for decoding returned objects. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of the collection or table from which records are to be retrieved, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. Must be an existing collection or table. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>offset</td>
                <td>A positive integer indicating the number of initial results to skip (this can be useful for paging through the results). The default value is 0. The minimum allowed value is 0. The maximum allowed value is MAX\_INT. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>limit</td>
                <td>A positive integer indicating the maximum number of results to be returned, or END\_OF\_SET (-9999) to indicate that the maximum number of results allowed by the server should be returned. The number of records returned will never exceed the server's own limit, defined by the <a href="/content/config/#config-main-general">max\_get\_records\_size</a> parameter in the server configuration. Use <span>offset</span> and <span>limit</span> to request subsequent pages of results. The default value is -9999. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ac6da5094c030db5012a21b0b4a8aca2b">get\_records\_from\_collection\_return\_record\_ids</a>: If <a href="/content/api/cpp/namespacegpudb#a335c36c8beee7ace6f681927cce8e277">true</a> then return the internal record ID along with each returned record. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a335c36c8beee7ace6f681927cce8e277">get\_records\_from\_collection\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a6f96653f15171fb8f903b09c84db00e8">get\_records\_from\_collection\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a6f96653f15171fb8f903b09c84db00e8">get\_records\_from\_collection\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a606a950809142651cd4f726d43c5ee4d">get\_records\_from\_collection\_expression</a>: Filter expression to apply to the table. The default value is ''. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionResponse">Response</a> object containing the result of the operation. </div>
        </div>

        <p>Definition at line <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">34715</a> of file <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">GPUdb.hpp</a>.</p>
      </div>
    </div>

    <h2><span><a href="#a3297c7c58cca0a4e2b8cc76b1ffa18ad">◆ </a></span>getRecordsFromCollection() <span>\[4/20]</span></h2>

    <div>
      <div>
        <div> template\<typename TResponse> </div>

        <table>
          <tr>
            <td>
              <table>
                <tr>
                  <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionResponse">GetRecordsFromCollectionResponse</a>\< TResponse > & gpudb::GPUdb::getRecordsFromCollection </td>
                  <td>(</td>
                  <td>const ::avro::ValidSchema &</td>
                  <td><span><span>schema\_</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const std::string &</td>
                  <td><span><span>tableName</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const int64\_t</td>
                  <td><span><span>offset</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const int64\_t</td>
                  <td><span><span>limit</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const std::map\< std::string, std::string > &</td>
                  <td><span><span>options</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionResponse">GetRecordsFromCollectionResponse</a>\< TResponse > &</td>
                  <td><span><span>response\_</span></span> ) const</td>
                </tr>
              </table>
            </td>

            <td> <span><span>inline</span></span> </td>
          </tr>
        </table>
      </div>

      <div>
        <p>Retrieves records from a collection. </p>
        <p>The operation can optionally return the record IDs which can be used in certain queries such as <a href="#a8f916f1513778ef51cfb294659f452ae">deleteRecords</a>.</p>
        <p>This operation supports paging through the data via the <span>offset</span> and <span>limit</span> parameters.</p>
        <p>Note that when using the Java API, it is not possible to retrieve records from join views using this operation. (DEPRECATED)</p>

        <div>
          <div>Template Parameters</div>

          <div>
            <table>
              <tr>
                <td>TResponse</td>
                <td>The type of object being retrieved.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>schema\_</td>
                <td>Avro schema object used for decoding returned objects. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of the collection or table from which records are to be retrieved, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. Must be an existing collection or table. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>offset</td>
                <td>A positive integer indicating the number of initial results to skip (this can be useful for paging through the results). The default value is 0. The minimum allowed value is 0. The maximum allowed value is MAX\_INT. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>limit</td>
                <td>A positive integer indicating the maximum number of results to be returned, or END\_OF\_SET (-9999) to indicate that the maximum number of results allowed by the server should be returned. The number of records returned will never exceed the server's own limit, defined by the <a href="/content/config/#config-main-general">max\_get\_records\_size</a> parameter in the server configuration. Use <span>offset</span> and <span>limit</span> to request subsequent pages of results. The default value is -9999. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ac6da5094c030db5012a21b0b4a8aca2b">get\_records\_from\_collection\_return\_record\_ids</a>: If <a href="/content/api/cpp/namespacegpudb#a335c36c8beee7ace6f681927cce8e277">true</a> then return the internal record ID along with each returned record. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a335c36c8beee7ace6f681927cce8e277">get\_records\_from\_collection\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a6f96653f15171fb8f903b09c84db00e8">get\_records\_from\_collection\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a6f96653f15171fb8f903b09c84db00e8">get\_records\_from\_collection\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a606a950809142651cd4f726d43c5ee4d">get\_records\_from\_collection\_expression</a>: Filter expression to apply to the table. The default value is ''. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>

        <p>Definition at line <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">34899</a> of file <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">GPUdb.hpp</a>.</p>
      </div>
    </div>

    <h2><span><a href="#ae32bea3bdbfef60b21d2fb7506439ca5">◆ </a></span>getRecordsFromCollection() <span>\[5/20]</span></h2>

    <div>
      <div>
        <div> template\<typename TResponse> </div>

        <table>
          <tr>
            <td>
              <table>
                <tr>
                  <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionResponse">GetRecordsFromCollectionResponse</a>\< TResponse > gpudb::GPUdb::getRecordsFromCollection </td>
                  <td>(</td>
                  <td>const <a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionRequest">GetRecordsFromCollectionRequest</a> &</td>
                  <td><span><span>request\_</span></span></td>
                  <td>)</td>
                  <td> const</td>
                </tr>
              </table>
            </td>

            <td> <span><span>inline</span></span> </td>
          </tr>
        </table>
      </div>

      <div>
        <p>Retrieves records from a collection. </p>
        <p>The operation can optionally return the record IDs which can be used in certain queries such as <a href="#a737a76b0c9fdd8d091dc6d02e9fcac78">deleteRecords</a>.</p>
        <p>This operation supports paging through the data via the <a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionRequest#a80af610012202241c80bcc0a23466f76">offset</a> and <a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionRequest#af08501c9b67fbbee5a8195313d7e7120">limit</a> parameters.</p>
        <p>Note that when using the Java API, it is not possible to retrieve records from join views using this operation. (DEPRECATED)</p>

        <div>
          <div>Template Parameters</div>

          <div>
            <table>
              <tr>
                <td>TResponse</td>
                <td>The type of object being retrieved.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionResponse">Response</a> object containing the result of the operation. </div>
        </div>

        <p>Definition at line <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">34232</a> of file <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">GPUdb.hpp</a>.</p>
      </div>
    </div>

    <h2><span><a href="#aaa7b31e43eaf534a9a0965f5984d43ff">◆ </a></span>getRecordsFromCollection() <span>\[6/20]</span></h2>

    <div>
      <div>
        <div> template\<> </div>

        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionResponse">GetRecordsFromCollectionResponse</a>\< boost::any > gpudb::GPUdb::getRecordsFromCollection </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionRequest">GetRecordsFromCollectionRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Retrieves records from a collection. </p>
        <p>The operation can optionally return the record IDs which can be used in certain queries such as <a href="#a737a76b0c9fdd8d091dc6d02e9fcac78">deleteRecords</a>.</p>
        <p>This operation supports paging through the data via the <a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionRequest#a80af610012202241c80bcc0a23466f76">offset</a> and <a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionRequest#af08501c9b67fbbee5a8195313d7e7120">limit</a> parameters.</p>
        <p>Note that when using the Java API, it is not possible to retrieve records from join views using this operation. (DEPRECATED)</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#aaa7b31e43eaf534a9a0965f5984d43ff">◆ </a></span>getRecordsFromCollection() <span>\[7/20]</span></h2>

    <div>
      <div>
        <div> template\<> </div>

        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionResponse">GetRecordsFromCollectionResponse</a>\< boost::any > gpudb::GPUdb::getRecordsFromCollection </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionRequest">GetRecordsFromCollectionRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Retrieves records from a collection. </p>
        <p>The operation can optionally return the record IDs which can be used in certain queries such as <a href="#a737a76b0c9fdd8d091dc6d02e9fcac78">deleteRecords</a>.</p>
        <p>This operation supports paging through the data via the <a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionRequest#a80af610012202241c80bcc0a23466f76">offset</a> and <a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionRequest#af08501c9b67fbbee5a8195313d7e7120">limit</a> parameters.</p>
        <p>Note that when using the Java API, it is not possible to retrieve records from join views using this operation. (DEPRECATED)</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a7425d039e0e34fca7b910bcd958a30e5">◆ </a></span>getRecordsFromCollection() <span>\[8/20]</span></h2>

    <div>
      <div>
        <div> template\<> </div>

        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionResponse">GetRecordsFromCollectionResponse</a>\< boost::any > & gpudb::GPUdb::getRecordsFromCollection </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionRequest">GetRecordsFromCollectionRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionResponse">GetRecordsFromCollectionResponse</a>\< boost::any > &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Retrieves records from a collection. </p>
        <p>The operation can optionally return the record IDs which can be used in certain queries such as <a href="#a737a76b0c9fdd8d091dc6d02e9fcac78">deleteRecords</a>.</p>
        <p>This operation supports paging through the data via the <a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionRequest#a80af610012202241c80bcc0a23466f76">offset</a> and <a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionRequest#af08501c9b67fbbee5a8195313d7e7120">limit</a> parameters.</p>
        <p>Note that when using the Java API, it is not possible to retrieve records from join views using this operation. (DEPRECATED)</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a7425d039e0e34fca7b910bcd958a30e5">◆ </a></span>getRecordsFromCollection() <span>\[9/20]</span></h2>

    <div>
      <div>
        <div> template\<> </div>

        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionResponse">GetRecordsFromCollectionResponse</a>\< boost::any > & gpudb::GPUdb::getRecordsFromCollection </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionRequest">GetRecordsFromCollectionRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionResponse">GetRecordsFromCollectionResponse</a>\< boost::any > &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Retrieves records from a collection. </p>
        <p>The operation can optionally return the record IDs which can be used in certain queries such as <a href="#a737a76b0c9fdd8d091dc6d02e9fcac78">deleteRecords</a>.</p>
        <p>This operation supports paging through the data via the <a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionRequest#a80af610012202241c80bcc0a23466f76">offset</a> and <a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionRequest#af08501c9b67fbbee5a8195313d7e7120">limit</a> parameters.</p>
        <p>Note that when using the Java API, it is not possible to retrieve records from join views using this operation. (DEPRECATED)</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a15bca10aa1488dac3494f994c2ca5753">◆ </a></span>getRecordsFromCollection() <span>\[10/20]</span></h2>

    <div>
      <div>
        <div> template\<typename TResponse> </div>

        <table>
          <tr>
            <td>
              <table>
                <tr>
                  <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionResponse">GetRecordsFromCollectionResponse</a>\< TResponse > & gpudb::GPUdb::getRecordsFromCollection </td>
                  <td>(</td>
                  <td>const <a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionRequest">GetRecordsFromCollectionRequest</a> &</td>
                  <td><span><span>request\_</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionResponse">GetRecordsFromCollectionResponse</a>\< TResponse > &</td>
                  <td><span><span>response\_</span></span> ) const</td>
                </tr>
              </table>
            </td>

            <td> <span><span>inline</span></span> </td>
          </tr>
        </table>
      </div>

      <div>
        <p>Retrieves records from a collection. </p>
        <p>The operation can optionally return the record IDs which can be used in certain queries such as <a href="#a737a76b0c9fdd8d091dc6d02e9fcac78">deleteRecords</a>.</p>
        <p>This operation supports paging through the data via the <a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionRequest#a80af610012202241c80bcc0a23466f76">offset</a> and <a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionRequest#af08501c9b67fbbee5a8195313d7e7120">limit</a> parameters.</p>
        <p>Note that when using the Java API, it is not possible to retrieve records from join views using this operation. (DEPRECATED)</p>

        <div>
          <div>Template Parameters</div>

          <div>
            <table>
              <tr>
                <td>TResponse</td>
                <td>The type of object being retrieved.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>

        <p>Definition at line <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">34275</a> of file <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">GPUdb.hpp</a>.</p>
      </div>
    </div>

    <h2><span><a href="#ad07e8ca5da326049590fc62762c630a1">◆ </a></span>getRecordsFromCollection() <span>\[11/20]</span></h2>

    <div>
      <div>
        <div> template\<typename TResponse> </div>

        <table>
          <tr>
            <td>
              <table>
                <tr>
                  <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionResponse">GetRecordsFromCollectionResponse</a>\< TResponse > gpudb::GPUdb::getRecordsFromCollection </td>
                  <td>(</td>
                  <td>const std::string &</td>
                  <td><span><span>tableName</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const int64\_t</td>
                  <td><span><span>offset</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const int64\_t</td>
                  <td><span><span>limit</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const std::map\< std::string, std::string > &</td>
                  <td><span><span>options</span></span> ) const</td>
                </tr>
              </table>
            </td>

            <td> <span><span>inline</span></span> </td>
          </tr>
        </table>
      </div>

      <div>
        <p>Retrieves records from a collection. </p>
        <p>The operation can optionally return the record IDs which can be used in certain queries such as <a href="#a8f916f1513778ef51cfb294659f452ae">deleteRecords</a>.</p>
        <p>This operation supports paging through the data via the <span>offset</span> and <span>limit</span> parameters.</p>
        <p>Note that when using the Java API, it is not possible to retrieve records from join views using this operation. (DEPRECATED)</p>

        <div>
          <div>Template Parameters</div>

          <div>
            <table>
              <tr>
                <td>TResponse</td>
                <td>The type of object being retrieved.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of the collection or table from which records are to be retrieved, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. Must be an existing collection or table. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>offset</td>
                <td>A positive integer indicating the number of initial results to skip (this can be useful for paging through the results). The default value is 0. The minimum allowed value is 0. The maximum allowed value is MAX\_INT. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>limit</td>
                <td>A positive integer indicating the maximum number of results to be returned, or END\_OF\_SET (-9999) to indicate that the maximum number of results allowed by the server should be returned. The number of records returned will never exceed the server's own limit, defined by the <a href="/content/config/#config-main-general">max\_get\_records\_size</a> parameter in the server configuration. Use <span>offset</span> and <span>limit</span> to request subsequent pages of results. The default value is -9999. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ac6da5094c030db5012a21b0b4a8aca2b">get\_records\_from\_collection\_return\_record\_ids</a>: If <a href="/content/api/cpp/namespacegpudb#a335c36c8beee7ace6f681927cce8e277">true</a> then return the internal record ID along with each returned record. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a335c36c8beee7ace6f681927cce8e277">get\_records\_from\_collection\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a6f96653f15171fb8f903b09c84db00e8">get\_records\_from\_collection\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a6f96653f15171fb8f903b09c84db00e8">get\_records\_from\_collection\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a606a950809142651cd4f726d43c5ee4d">get\_records\_from\_collection\_expression</a>: Filter expression to apply to the table. The default value is ''. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionResponse">Response</a> object containing the result of the operation. </div>
        </div>

        <p>Definition at line <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">34358</a> of file <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">GPUdb.hpp</a>.</p>
      </div>
    </div>

    <h2><span><a href="#a2981090225cf80548a10e8d35ed3d8a4">◆ </a></span>getRecordsFromCollection() <span>\[12/20]</span></h2>

    <div>
      <div>
        <div> template\<> </div>

        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionResponse">GetRecordsFromCollectionResponse</a>\< boost::any > gpudb::GPUdb::getRecordsFromCollection </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const int64\_t</td>
            <td><span><span>offset</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const int64\_t</td>
            <td><span><span>limit</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Retrieves records from a collection. </p>
        <p>The operation can optionally return the record IDs which can be used in certain queries such as <a href="#a8f916f1513778ef51cfb294659f452ae">deleteRecords</a>.</p>
        <p>This operation supports paging through the data via the <span>offset</span> and <span>limit</span> parameters.</p>
        <p>Note that when using the Java API, it is not possible to retrieve records from join views using this operation. (DEPRECATED)</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of the collection or table from which records are to be retrieved, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. Must be an existing collection or table. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>offset</td>
                <td>A positive integer indicating the number of initial results to skip (this can be useful for paging through the results). The default value is 0. The minimum allowed value is 0. The maximum allowed value is MAX\_INT. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>limit</td>
                <td>A positive integer indicating the maximum number of results to be returned, or END\_OF\_SET (-9999) to indicate that the maximum number of results allowed by the server should be returned. The number of records returned will never exceed the server's own limit, defined by the <a href="/content/config/#config-main-general">max\_get\_records\_size</a> parameter in the server configuration. Use <span>offset</span> and <span>limit</span> to request subsequent pages of results. The default value is -9999. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ac6da5094c030db5012a21b0b4a8aca2b">get\_records\_from\_collection\_return\_record\_ids</a>: If <a href="/content/api/cpp/namespacegpudb#a335c36c8beee7ace6f681927cce8e277">true</a> then return the internal record ID along with each returned record. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a335c36c8beee7ace6f681927cce8e277">get\_records\_from\_collection\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a6f96653f15171fb8f903b09c84db00e8">get\_records\_from\_collection\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a6f96653f15171fb8f903b09c84db00e8">get\_records\_from\_collection\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a606a950809142651cd4f726d43c5ee4d">get\_records\_from\_collection\_expression</a>: Filter expression to apply to the table. The default value is ''. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a2981090225cf80548a10e8d35ed3d8a4">◆ </a></span>getRecordsFromCollection() <span>\[13/20]</span></h2>

    <div>
      <div>
        <div> template\<> </div>

        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionResponse">GetRecordsFromCollectionResponse</a>\< boost::any > gpudb::GPUdb::getRecordsFromCollection </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const int64\_t</td>
            <td><span><span>offset</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const int64\_t</td>
            <td><span><span>limit</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Retrieves records from a collection. </p>
        <p>The operation can optionally return the record IDs which can be used in certain queries such as <a href="#a8f916f1513778ef51cfb294659f452ae">deleteRecords</a>.</p>
        <p>This operation supports paging through the data via the <span>offset</span> and <span>limit</span> parameters.</p>
        <p>Note that when using the Java API, it is not possible to retrieve records from join views using this operation. (DEPRECATED)</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of the collection or table from which records are to be retrieved, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. Must be an existing collection or table. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>offset</td>
                <td>A positive integer indicating the number of initial results to skip (this can be useful for paging through the results). The default value is 0. The minimum allowed value is 0. The maximum allowed value is MAX\_INT. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>limit</td>
                <td>A positive integer indicating the maximum number of results to be returned, or END\_OF\_SET (-9999) to indicate that the maximum number of results allowed by the server should be returned. The number of records returned will never exceed the server's own limit, defined by the <a href="/content/config/#config-main-general">max\_get\_records\_size</a> parameter in the server configuration. Use <span>offset</span> and <span>limit</span> to request subsequent pages of results. The default value is -9999. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ac6da5094c030db5012a21b0b4a8aca2b">get\_records\_from\_collection\_return\_record\_ids</a>: If <a href="/content/api/cpp/namespacegpudb#a335c36c8beee7ace6f681927cce8e277">true</a> then return the internal record ID along with each returned record. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a335c36c8beee7ace6f681927cce8e277">get\_records\_from\_collection\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a6f96653f15171fb8f903b09c84db00e8">get\_records\_from\_collection\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a6f96653f15171fb8f903b09c84db00e8">get\_records\_from\_collection\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a606a950809142651cd4f726d43c5ee4d">get\_records\_from\_collection\_expression</a>: Filter expression to apply to the table. The default value is ''. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a551401d018ca79303a27b3b504d2288a">◆ </a></span>getRecordsFromCollection() <span>\[14/20]</span></h2>

    <div>
      <div>
        <div> template\<> </div>

        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionResponse">GetRecordsFromCollectionResponse</a>\< boost::any > & gpudb::GPUdb::getRecordsFromCollection </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const int64\_t</td>
            <td><span><span>offset</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const int64\_t</td>
            <td><span><span>limit</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionResponse">GetRecordsFromCollectionResponse</a>\< boost::any > &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Retrieves records from a collection. </p>
        <p>The operation can optionally return the record IDs which can be used in certain queries such as <a href="#a8f916f1513778ef51cfb294659f452ae">deleteRecords</a>.</p>
        <p>This operation supports paging through the data via the <span>offset</span> and <span>limit</span> parameters.</p>
        <p>Note that when using the Java API, it is not possible to retrieve records from join views using this operation. (DEPRECATED)</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of the collection or table from which records are to be retrieved, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. Must be an existing collection or table. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>offset</td>
                <td>A positive integer indicating the number of initial results to skip (this can be useful for paging through the results). The default value is 0. The minimum allowed value is 0. The maximum allowed value is MAX\_INT. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>limit</td>
                <td>A positive integer indicating the maximum number of results to be returned, or END\_OF\_SET (-9999) to indicate that the maximum number of results allowed by the server should be returned. The number of records returned will never exceed the server's own limit, defined by the <a href="/content/config/#config-main-general">max\_get\_records\_size</a> parameter in the server configuration. Use <span>offset</span> and <span>limit</span> to request subsequent pages of results. The default value is -9999. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ac6da5094c030db5012a21b0b4a8aca2b">get\_records\_from\_collection\_return\_record\_ids</a>: If <a href="/content/api/cpp/namespacegpudb#a335c36c8beee7ace6f681927cce8e277">true</a> then return the internal record ID along with each returned record. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a335c36c8beee7ace6f681927cce8e277">get\_records\_from\_collection\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a6f96653f15171fb8f903b09c84db00e8">get\_records\_from\_collection\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a6f96653f15171fb8f903b09c84db00e8">get\_records\_from\_collection\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a606a950809142651cd4f726d43c5ee4d">get\_records\_from\_collection\_expression</a>: Filter expression to apply to the table. The default value is ''. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a551401d018ca79303a27b3b504d2288a">◆ </a></span>getRecordsFromCollection() <span>\[15/20]</span></h2>

    <div>
      <div>
        <div> template\<> </div>

        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionResponse">GetRecordsFromCollectionResponse</a>\< boost::any > & gpudb::GPUdb::getRecordsFromCollection </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const int64\_t</td>
            <td><span><span>offset</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const int64\_t</td>
            <td><span><span>limit</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionResponse">GetRecordsFromCollectionResponse</a>\< boost::any > &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Retrieves records from a collection. </p>
        <p>The operation can optionally return the record IDs which can be used in certain queries such as <a href="#a8f916f1513778ef51cfb294659f452ae">deleteRecords</a>.</p>
        <p>This operation supports paging through the data via the <span>offset</span> and <span>limit</span> parameters.</p>
        <p>Note that when using the Java API, it is not possible to retrieve records from join views using this operation. (DEPRECATED)</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of the collection or table from which records are to be retrieved, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. Must be an existing collection or table. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>offset</td>
                <td>A positive integer indicating the number of initial results to skip (this can be useful for paging through the results). The default value is 0. The minimum allowed value is 0. The maximum allowed value is MAX\_INT. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>limit</td>
                <td>A positive integer indicating the maximum number of results to be returned, or END\_OF\_SET (-9999) to indicate that the maximum number of results allowed by the server should be returned. The number of records returned will never exceed the server's own limit, defined by the <a href="/content/config/#config-main-general">max\_get\_records\_size</a> parameter in the server configuration. Use <span>offset</span> and <span>limit</span> to request subsequent pages of results. The default value is -9999. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ac6da5094c030db5012a21b0b4a8aca2b">get\_records\_from\_collection\_return\_record\_ids</a>: If <a href="/content/api/cpp/namespacegpudb#a335c36c8beee7ace6f681927cce8e277">true</a> then return the internal record ID along with each returned record. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a335c36c8beee7ace6f681927cce8e277">get\_records\_from\_collection\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a6f96653f15171fb8f903b09c84db00e8">get\_records\_from\_collection\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a6f96653f15171fb8f903b09c84db00e8">get\_records\_from\_collection\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a606a950809142651cd4f726d43c5ee4d">get\_records\_from\_collection\_expression</a>: Filter expression to apply to the table. The default value is ''. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ac438b7fefc4616a82a996f7597be53cd">◆ </a></span>getRecordsFromCollection() <span>\[16/20]</span></h2>

    <div>
      <div>
        <div> template\<typename TResponse> </div>

        <table>
          <tr>
            <td>
              <table>
                <tr>
                  <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionResponse">GetRecordsFromCollectionResponse</a>\< TResponse > & gpudb::GPUdb::getRecordsFromCollection </td>
                  <td>(</td>
                  <td>const std::string &</td>
                  <td><span><span>tableName</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const int64\_t</td>
                  <td><span><span>offset</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const int64\_t</td>
                  <td><span><span>limit</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const std::map\< std::string, std::string > &</td>
                  <td><span><span>options</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionResponse">GetRecordsFromCollectionResponse</a>\< TResponse > &</td>
                  <td><span><span>response\_</span></span> ) const</td>
                </tr>
              </table>
            </td>

            <td> <span><span>inline</span></span> </td>
          </tr>
        </table>
      </div>

      <div>
        <p>Retrieves records from a collection. </p>
        <p>The operation can optionally return the record IDs which can be used in certain queries such as <a href="#a8f916f1513778ef51cfb294659f452ae">deleteRecords</a>.</p>
        <p>This operation supports paging through the data via the <span>offset</span> and <span>limit</span> parameters.</p>
        <p>Note that when using the Java API, it is not possible to retrieve records from join views using this operation. (DEPRECATED)</p>

        <div>
          <div>Template Parameters</div>

          <div>
            <table>
              <tr>
                <td>TResponse</td>
                <td>The type of object being retrieved.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of the collection or table from which records are to be retrieved, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. Must be an existing collection or table. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>offset</td>
                <td>A positive integer indicating the number of initial results to skip (this can be useful for paging through the results). The default value is 0. The minimum allowed value is 0. The maximum allowed value is MAX\_INT. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>limit</td>
                <td>A positive integer indicating the maximum number of results to be returned, or END\_OF\_SET (-9999) to indicate that the maximum number of results allowed by the server should be returned. The number of records returned will never exceed the server's own limit, defined by the <a href="/content/config/#config-main-general">max\_get\_records\_size</a> parameter in the server configuration. Use <span>offset</span> and <span>limit</span> to request subsequent pages of results. The default value is -9999. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ac6da5094c030db5012a21b0b4a8aca2b">get\_records\_from\_collection\_return\_record\_ids</a>: If <a href="/content/api/cpp/namespacegpudb#a335c36c8beee7ace6f681927cce8e277">true</a> then return the internal record ID along with each returned record. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a335c36c8beee7ace6f681927cce8e277">get\_records\_from\_collection\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a6f96653f15171fb8f903b09c84db00e8">get\_records\_from\_collection\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a6f96653f15171fb8f903b09c84db00e8">get\_records\_from\_collection\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a606a950809142651cd4f726d43c5ee4d">get\_records\_from\_collection\_expression</a>: Filter expression to apply to the table. The default value is ''. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>

        <p>Definition at line <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">34450</a> of file <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">GPUdb.hpp</a>.</p>
      </div>
    </div>

    <h2><span><a href="#a36d0a8b40fe139b5889367a6cd4fb52e">◆ </a></span>getRecordsFromCollection() <span>\[17/20]</span></h2>

    <div>
      <div>
        <div> template\<typename TResponse> </div>

        <table>
          <tr>
            <td>
              <table>
                <tr>
                  <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionResponse">GetRecordsFromCollectionResponse</a>\< TResponse > gpudb::GPUdb::getRecordsFromCollection </td>
                  <td>(</td>
                  <td>const <a href="/content/api/cpp/classgpudb_1_1Type">Type</a> &</td>
                  <td><span><span>type\_</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const <a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionRequest">GetRecordsFromCollectionRequest</a> &</td>
                  <td><span><span>request\_</span></span> ) const</td>
                </tr>
              </table>
            </td>

            <td> <span><span>inline</span></span> </td>
          </tr>
        </table>
      </div>

      <div>
        <p>Retrieves records from a collection. </p>
        <p>The operation can optionally return the record IDs which can be used in certain queries such as <a href="#a8f916f1513778ef51cfb294659f452ae">deleteRecords</a>.</p>
        <p>This operation supports paging through the data via the <a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionRequest#a80af610012202241c80bcc0a23466f76">offset</a> and <a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionRequest#af08501c9b67fbbee5a8195313d7e7120">limit</a> parameters.</p>
        <p>Note that when using the Java API, it is not possible to retrieve records from join views using this operation. (DEPRECATED)</p>

        <div>
          <div>Template Parameters</div>

          <div>
            <table>
              <tr>
                <td>TResponse</td>
                <td>The type of object being retrieved.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>type\_</td>
                <td><a href="/content/api/cpp/classgpudb_1_1Type">Type</a> object used for decoding returned objects. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionResponse">Response</a> object containing the result of the operation. </div>
        </div>

        <p>Definition at line <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">34538</a> of file <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">GPUdb.hpp</a>.</p>
      </div>
    </div>

    <h2><span><a href="#aca16e6eb9cd2c12afdd910b778cc8b25">◆ </a></span>getRecordsFromCollection() <span>\[18/20]</span></h2>

    <div>
      <div>
        <div> template\<typename TResponse> </div>

        <table>
          <tr>
            <td>
              <table>
                <tr>
                  <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionResponse">GetRecordsFromCollectionResponse</a>\< TResponse > & gpudb::GPUdb::getRecordsFromCollection </td>
                  <td>(</td>
                  <td>const <a href="/content/api/cpp/classgpudb_1_1Type">Type</a> &</td>
                  <td><span><span>type\_</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const <a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionRequest">GetRecordsFromCollectionRequest</a> &</td>
                  <td><span><span>request\_</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionResponse">GetRecordsFromCollectionResponse</a>\< TResponse > &</td>
                  <td><span><span>response\_</span></span> ) const</td>
                </tr>
              </table>
            </td>

            <td> <span><span>inline</span></span> </td>
          </tr>
        </table>
      </div>

      <div>
        <p>Retrieves records from a collection. </p>
        <p>The operation can optionally return the record IDs which can be used in certain queries such as <a href="#a8f916f1513778ef51cfb294659f452ae">deleteRecords</a>.</p>
        <p>This operation supports paging through the data via the <a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionRequest#a80af610012202241c80bcc0a23466f76">offset</a> and <a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionRequest#af08501c9b67fbbee5a8195313d7e7120">limit</a> parameters.</p>
        <p>Note that when using the Java API, it is not possible to retrieve records from join views using this operation. (DEPRECATED)</p>

        <div>
          <div>Template Parameters</div>

          <div>
            <table>
              <tr>
                <td>TResponse</td>
                <td>The type of object being retrieved.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>type\_</td>
                <td><a href="/content/api/cpp/classgpudb_1_1Type">Type</a> object used for decoding returned objects. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>

        <p>Definition at line <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">34630</a> of file <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">GPUdb.hpp</a>.</p>
      </div>
    </div>

    <h2><span><a href="#a1459d3d7015e72a3d8b783a7984e737b">◆ </a></span>getRecordsFromCollection() <span>\[19/20]</span></h2>

    <div>
      <div>
        <div> template\<typename TResponse> </div>

        <table>
          <tr>
            <td>
              <table>
                <tr>
                  <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionResponse">GetRecordsFromCollectionResponse</a>\< TResponse > gpudb::GPUdb::getRecordsFromCollection </td>
                  <td>(</td>
                  <td>const <a href="/content/api/cpp/classgpudb_1_1Type">Type</a> &</td>
                  <td><span><span>type\_</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const std::string &</td>
                  <td><span><span>tableName</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const int64\_t</td>
                  <td><span><span>offset</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const int64\_t</td>
                  <td><span><span>limit</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const std::map\< std::string, std::string > &</td>
                  <td><span><span>options</span></span> ) const</td>
                </tr>
              </table>
            </td>

            <td> <span><span>inline</span></span> </td>
          </tr>
        </table>
      </div>

      <div>
        <p>Retrieves records from a collection. </p>
        <p>The operation can optionally return the record IDs which can be used in certain queries such as <a href="#a8f916f1513778ef51cfb294659f452ae">deleteRecords</a>.</p>
        <p>This operation supports paging through the data via the <span>offset</span> and <span>limit</span> parameters.</p>
        <p>Note that when using the Java API, it is not possible to retrieve records from join views using this operation. (DEPRECATED)</p>

        <div>
          <div>Template Parameters</div>

          <div>
            <table>
              <tr>
                <td>TResponse</td>
                <td>The type of object being retrieved.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>type\_</td>
                <td><a href="/content/api/cpp/classgpudb_1_1Type">Type</a> object used for decoding returned objects. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of the collection or table from which records are to be retrieved, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. Must be an existing collection or table. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>offset</td>
                <td>A positive integer indicating the number of initial results to skip (this can be useful for paging through the results). The default value is 0. The minimum allowed value is 0. The maximum allowed value is MAX\_INT. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>limit</td>
                <td>A positive integer indicating the maximum number of results to be returned, or END\_OF\_SET (-9999) to indicate that the maximum number of results allowed by the server should be returned. The number of records returned will never exceed the server's own limit, defined by the <a href="/content/config/#config-main-general">max\_get\_records\_size</a> parameter in the server configuration. Use <span>offset</span> and <span>limit</span> to request subsequent pages of results. The default value is -9999. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ac6da5094c030db5012a21b0b4a8aca2b">get\_records\_from\_collection\_return\_record\_ids</a>: If <a href="/content/api/cpp/namespacegpudb#a335c36c8beee7ace6f681927cce8e277">true</a> then return the internal record ID along with each returned record. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a335c36c8beee7ace6f681927cce8e277">get\_records\_from\_collection\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a6f96653f15171fb8f903b09c84db00e8">get\_records\_from\_collection\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a6f96653f15171fb8f903b09c84db00e8">get\_records\_from\_collection\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a606a950809142651cd4f726d43c5ee4d">get\_records\_from\_collection\_expression</a>: Filter expression to apply to the table. The default value is ''. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionResponse">Response</a> object containing the result of the operation. </div>
        </div>

        <p>Definition at line <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">34805</a> of file <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">GPUdb.hpp</a>.</p>
      </div>
    </div>

    <h2><span><a href="#abd901e4bd4f9e2f1a4e54503b8fd44b2">◆ </a></span>getRecordsFromCollection() <span>\[20/20]</span></h2>

    <div>
      <div>
        <div> template\<typename TResponse> </div>

        <table>
          <tr>
            <td>
              <table>
                <tr>
                  <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionResponse">GetRecordsFromCollectionResponse</a>\< TResponse > & gpudb::GPUdb::getRecordsFromCollection </td>
                  <td>(</td>
                  <td>const <a href="/content/api/cpp/classgpudb_1_1Type">Type</a> &</td>
                  <td><span><span>type\_</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const std::string &</td>
                  <td><span><span>tableName</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const int64\_t</td>
                  <td><span><span>offset</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const int64\_t</td>
                  <td><span><span>limit</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const std::map\< std::string, std::string > &</td>
                  <td><span><span>options</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionResponse">GetRecordsFromCollectionResponse</a>\< TResponse > &</td>
                  <td><span><span>response\_</span></span> ) const</td>
                </tr>
              </table>
            </td>

            <td> <span><span>inline</span></span> </td>
          </tr>
        </table>
      </div>

      <div>
        <p>Retrieves records from a collection. </p>
        <p>The operation can optionally return the record IDs which can be used in certain queries such as <a href="#a8f916f1513778ef51cfb294659f452ae">deleteRecords</a>.</p>
        <p>This operation supports paging through the data via the <span>offset</span> and <span>limit</span> parameters.</p>
        <p>Note that when using the Java API, it is not possible to retrieve records from join views using this operation. (DEPRECATED)</p>

        <div>
          <div>Template Parameters</div>

          <div>
            <table>
              <tr>
                <td>TResponse</td>
                <td>The type of object being retrieved.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>type\_</td>
                <td><a href="/content/api/cpp/classgpudb_1_1Type">Type</a> object used for decoding returned objects. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of the collection or table from which records are to be retrieved, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. Must be an existing collection or table. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>offset</td>
                <td>A positive integer indicating the number of initial results to skip (this can be useful for paging through the results). The default value is 0. The minimum allowed value is 0. The maximum allowed value is MAX\_INT. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>limit</td>
                <td>A positive integer indicating the maximum number of results to be returned, or END\_OF\_SET (-9999) to indicate that the maximum number of results allowed by the server should be returned. The number of records returned will never exceed the server's own limit, defined by the <a href="/content/config/#config-main-general">max\_get\_records\_size</a> parameter in the server configuration. Use <span>offset</span> and <span>limit</span> to request subsequent pages of results. The default value is -9999. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ac6da5094c030db5012a21b0b4a8aca2b">get\_records\_from\_collection\_return\_record\_ids</a>: If <a href="/content/api/cpp/namespacegpudb#a335c36c8beee7ace6f681927cce8e277">true</a> then return the internal record ID along with each returned record. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a335c36c8beee7ace6f681927cce8e277">get\_records\_from\_collection\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a6f96653f15171fb8f903b09c84db00e8">get\_records\_from\_collection\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a6f96653f15171fb8f903b09c84db00e8">get\_records\_from\_collection\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a606a950809142651cd4f726d43c5ee4d">get\_records\_from\_collection\_expression</a>: Filter expression to apply to the table. The default value is ''. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>

        <p>Definition at line <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">34993</a> of file <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">GPUdb.hpp</a>.</p>
      </div>
    </div>

    <h2><span><a href="#a15a7bd6a0d065b5528141f8e00a91305">◆ </a></span>getRecordsFromCollectionRaw() <span>\[1/2]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1RawGetRecordsFromCollectionResponse">RawGetRecordsFromCollectionResponse</a> gpudb::GPUdb::getRecordsFromCollectionRaw </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionRequest">GetRecordsFromCollectionRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Retrieves records from a collection. </p>
        <p>The operation can optionally return the record IDs which can be used in certain queries such as <a href="#a737a76b0c9fdd8d091dc6d02e9fcac78">deleteRecords</a>.</p>
        <p>This operation supports paging through the data via the <a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionRequest#a80af610012202241c80bcc0a23466f76">offset</a> and <a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionRequest#af08501c9b67fbbee5a8195313d7e7120">limit</a> parameters.</p>
        <p>Note that when using the Java API, it is not possible to retrieve records from join views using this operation. (DEPRECATED)</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1RawGetRecordsFromCollectionResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ae59716b524af9a3d0532c72d85580ced">◆ </a></span>getRecordsFromCollectionRaw() <span>\[2/2]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1RawGetRecordsFromCollectionResponse">RawGetRecordsFromCollectionResponse</a> & gpudb::GPUdb::getRecordsFromCollectionRaw </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionRequest">GetRecordsFromCollectionRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1RawGetRecordsFromCollectionResponse">RawGetRecordsFromCollectionResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Retrieves records from a collection. </p>
        <p>The operation can optionally return the record IDs which can be used in certain queries such as <a href="#a737a76b0c9fdd8d091dc6d02e9fcac78">deleteRecords</a>.</p>
        <p>This operation supports paging through the data via the <a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionRequest#a80af610012202241c80bcc0a23466f76">offset</a> and <a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionRequest#af08501c9b67fbbee5a8195313d7e7120">limit</a> parameters.</p>
        <p>Note that when using the Java API, it is not possible to retrieve records from join views using this operation. (DEPRECATED)</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsFromCollectionRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1RawGetRecordsFromCollectionResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1RawGetRecordsFromCollectionResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#afefae2f48831c864d2f19e27fbb2ad65">◆ </a></span>getRecordsRaw() <span>\[1/2]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1RawGetRecordsResponse">RawGetRecordsResponse</a> gpudb::GPUdb::getRecordsRaw </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1GetRecordsRequest">GetRecordsRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Retrieves records from a given table, optionally filtered by an expression and/or sorted by a column. </p>
        <p>This operation can be performed on tables and views. Records can be returned encoded as binary, json, or geojson.</p>
        <p>This operation supports paging through the data via the <a href="/content/api/cpp/structgpudb_1_1GetRecordsRequest#a6f8fde526abfe2adc4845bd4582f96a5">offset</a> and <a href="/content/api/cpp/structgpudb_1_1GetRecordsRequest#a88646356abf331176d438e0e435cae79">limit</a> parameters. Note that when paging through a table, if the table (or the underlying table in case of a view) is updated (records are inserted, deleted or modified) the records retrieved may differ between calls based on the updates applied.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1RawGetRecordsResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a4d416d301bad8f60f2376499284a7d4e">◆ </a></span>getRecordsRaw() <span>\[2/2]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1RawGetRecordsResponse">RawGetRecordsResponse</a> & gpudb::GPUdb::getRecordsRaw </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1GetRecordsRequest">GetRecordsRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1RawGetRecordsResponse">RawGetRecordsResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Retrieves records from a given table, optionally filtered by an expression and/or sorted by a column. </p>
        <p>This operation can be performed on tables and views. Records can be returned encoded as binary, json, or geojson.</p>
        <p>This operation supports paging through the data via the <a href="/content/api/cpp/structgpudb_1_1GetRecordsRequest#a6f8fde526abfe2adc4845bd4582f96a5">offset</a> and <a href="/content/api/cpp/structgpudb_1_1GetRecordsRequest#a88646356abf331176d438e0e435cae79">limit</a> parameters. Note that when paging through a table, if the table (or the underlying table in case of a view) is updated (records are inserted, deleted or modified) the records retrieved may differ between calls based on the updates applied.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GetRecordsRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1RawGetRecordsResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1RawGetRecordsResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#af72c1f7f291b623383eea39d46e54ce9">◆ </a></span>getSslContext()</h2>

    <div>
      <div>
        <table>
          <tr>
            <td>boost::asio::ssl::context \* gpudb::GPUdb::getSslContext </td>
            <td>(</td>

            <td>
              <span>
                <span />
              </span>
            </td>

            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#ad152315a6dd0ef159997b96f156ab7e7">◆ </a></span>getThreadCount()</h2>

    <div>
      <div>
        <table>
          <tr>
            <td>size\_t gpudb::GPUdb::getThreadCount </td>
            <td>(</td>

            <td>
              <span>
                <span />
              </span>
            </td>

            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#a8346544922a72fcd795c9af457ed0455">◆ </a></span>getTimeout()</h2>

    <div>
      <div>
        <table>
          <tr>
            <td>size\_t gpudb::GPUdb::getTimeout </td>
            <td>(</td>

            <td>
              <span>
                <span />
              </span>
            </td>

            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#a98d2ff75f9bb2d749e49547d29bf2cf2">◆ </a></span>getUrl()</h2>

    <div>
      <div>
        <table>
          <tr>
            <td>const <a href="/content/api/cpp/classgpudb_1_1HttpUrl">HttpUrl</a> & gpudb::GPUdb::getUrl </td>
            <td>(</td>

            <td>
              <span>
                <span />
              </span>
            </td>

            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#a3b3644fe3162c0e3402f2dee45f6c074">◆ </a></span>getUrls()</h2>

    <div>
      <div>
        <table>
          <tr>
            <td>const std::vector\< <a href="/content/api/cpp/classgpudb_1_1HttpUrl">HttpUrl</a> > & gpudb::GPUdb::getUrls </td>
            <td>(</td>

            <td>
              <span>
                <span />
              </span>
            </td>

            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#aa3d79bf540dc5af7a220a2f10a7a3526">◆ </a></span>getUsername()</h2>

    <div>
      <div>
        <table>
          <tr>
            <td>const std::string & gpudb::GPUdb::getUsername </td>
            <td>(</td>

            <td>
              <span>
                <span />
              </span>
            </td>

            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#a89b57fb94c64f86e385d25b6e1763753">◆ </a></span>getUseSnappy()</h2>

    <div>
      <div>
        <table>
          <tr>
            <td>bool gpudb::GPUdb::getUseSnappy </td>
            <td>(</td>

            <td>
              <span>
                <span />
              </span>
            </td>

            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#a9634c497d7035ee98062b6f92a63be8d">◆ </a></span>grantPermission() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1GrantPermissionResponse">GrantPermissionResponse</a> gpudb::GPUdb::grantPermission </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1GrantPermissionRequest">GrantPermissionRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Grant user or role the specified permission on the specified object. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GrantPermissionRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1GrantPermissionResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a8952ec4a4b6493b32acbe9b5e6a7959f">◆ </a></span>grantPermission() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1GrantPermissionResponse">GrantPermissionResponse</a> & gpudb::GPUdb::grantPermission </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1GrantPermissionRequest">GrantPermissionRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1GrantPermissionResponse">GrantPermissionResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Grant user or role the specified permission on the specified object. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GrantPermissionRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GrantPermissionResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1GrantPermissionResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ad2439e67beadacbe234814ad9c4e4691">◆ </a></span>grantPermission() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1GrantPermissionResponse">GrantPermissionResponse</a> gpudb::GPUdb::grantPermission </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>principal</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>object</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>objectType</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>permission</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Grant user or role the specified permission on the specified object. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>principal</td>
                <td>Name of the user or role for which the permission is being granted. Must be an existing user or role. The default value is ''. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>object</td>
                <td>Name of object permission is being granted to. It is recommended to use a fully-qualified name when possible. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>objectType</td>

                <td>
                  The type of object being granted to. Supported values:

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a37206fbd0e3f9a13ba7501bba59fba35">grant\_permission\_catalog</a>: Catalog </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a42fb948603eb67a1878fe13482424ccc">grant\_permission\_context</a>: Context </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a30324ffbea79fcc2c03d2d2847e86bd4">grant\_permission\_credential</a>: Credential </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a523356365f81da1f53fc155711e140ed">grant\_permission\_datasink</a>: Data Sink </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a9e2706323be00f3327c77aa5d870978f">grant\_permission\_datasource</a>: Data Source </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a2d77669b19afc43493c7c9536ce1877e">grant\_permission\_directory</a>: KIFS File Directory </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ae95634b80d04aa9bcaced536756ea65c">grant\_permission\_graph</a>: A Graph object </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a27022cfe33fd027afe98bd515ed76164">grant\_permission\_proc</a>: UDF Procedure </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a512589fd51b0092b7103127ae8fdd644">grant\_permission\_schema</a>: Schema </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a16be68186a83c46fde817e4127531312">grant\_permission\_sql\_proc</a>: SQL Procedure </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ae3d494fb797e9ac977bcd6f741d953ab">grant\_permission\_system</a>: System-level access </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a3e2e5848c2d8628e3c83ff6a937f2691">grant\_permission\_table</a>: Database Table </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a9b09ff744019c2ac6820346ecc95386f">grant\_permission\_table\_monitor</a>: Table monitor </li>
                  </ul>
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>permission</td>

                <td>
                  Permission being granted. Supported values:

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a89c89f9679a7e3cb100989e71eec9b0b">grant\_permission\_admin</a>: Full read/write and administrative access on the object. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a979b539e99ba5984ae718ab8a2fb4fb2">grant\_permission\_connect</a>: Connect access on the given data source or data sink. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#af47abdc51efdfef4eb6b2722aa70b0e8">grant\_permission\_create</a>: Ability to create new objects of this type. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a0aab091df760dd732ba31c0b7fb9484f">grant\_permission\_delete</a>: Delete rows from tables. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ad5b25c6916cff7f73c637e7d38eb8047">grant\_permission\_execute</a>: Ability to Execute the Procedure object. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a0f36ab5887cbb13e802cff82d3053bdf">grant\_permission\_insert</a>: Insert access to tables. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a438f74c3ac20f9fd42dd1a3e20d3790f">grant\_permission\_monitor</a>: Monitor logs and statistics. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a692ef22b4fb5fcb9c69324be90c3c653">grant\_permission\_read</a>: Ability to read, list and use the object. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aa34b4ec6ad55aaf3ecafd10b3cb0f19a">grant\_permission\_send\_alert</a>: Ability to send system alerts. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a668b88450069d5970c15657fe9d4f895">grant\_permission\_update</a>: Update access to the table. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aa48e03113ef418f1eedb6828f0b810f6">grant\_permission\_user\_admin</a>: Access to administer users and roles that do not have system\_admin permission. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a8a5928c9d9b4efcbb03f388ab98d08dd">grant\_permission\_write</a>: Access to write, change and delete objects. </li>
                  </ul>
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a860307a66632035036a5055a090bd1fb">grant\_permission\_columns</a>: Apply table security to these columns, comma-separated. The default value is ''. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ab61a6300639ade83eb2668f922d66b24">grant\_permission\_filter\_expression</a>: Filter expression to apply to this grant. Only rows that match the filter will be affected. The default value is ''. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a9c23b453e73de3a3acd1c44f17b9b36d">grant\_permission\_with\_grant\_option</a>: Allow the recipient to grant the same permission (or subset) to others. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a3b94060fa83483944ccd69ec45996f1e">grant\_permission\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aedd795b6c6635094d46108eb8242cb13">grant\_permission\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#aedd795b6c6635094d46108eb8242cb13">grant\_permission\_false</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1GrantPermissionResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a13c6927f982fefb3149bbd625970e994">◆ </a></span>grantPermission() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1GrantPermissionResponse">GrantPermissionResponse</a> & gpudb::GPUdb::grantPermission </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>principal</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>object</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>objectType</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>permission</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1GrantPermissionResponse">GrantPermissionResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Grant user or role the specified permission on the specified object. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>principal</td>
                <td>Name of the user or role for which the permission is being granted. Must be an existing user or role. The default value is ''. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>object</td>
                <td>Name of object permission is being granted to. It is recommended to use a fully-qualified name when possible. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>objectType</td>

                <td>
                  The type of object being granted to. Supported values:

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a37206fbd0e3f9a13ba7501bba59fba35">grant\_permission\_catalog</a>: Catalog </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a42fb948603eb67a1878fe13482424ccc">grant\_permission\_context</a>: Context </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a30324ffbea79fcc2c03d2d2847e86bd4">grant\_permission\_credential</a>: Credential </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a523356365f81da1f53fc155711e140ed">grant\_permission\_datasink</a>: Data Sink </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a9e2706323be00f3327c77aa5d870978f">grant\_permission\_datasource</a>: Data Source </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a2d77669b19afc43493c7c9536ce1877e">grant\_permission\_directory</a>: KIFS File Directory </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ae95634b80d04aa9bcaced536756ea65c">grant\_permission\_graph</a>: A Graph object </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a27022cfe33fd027afe98bd515ed76164">grant\_permission\_proc</a>: UDF Procedure </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a512589fd51b0092b7103127ae8fdd644">grant\_permission\_schema</a>: Schema </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a16be68186a83c46fde817e4127531312">grant\_permission\_sql\_proc</a>: SQL Procedure </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ae3d494fb797e9ac977bcd6f741d953ab">grant\_permission\_system</a>: System-level access </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a3e2e5848c2d8628e3c83ff6a937f2691">grant\_permission\_table</a>: Database Table </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a9b09ff744019c2ac6820346ecc95386f">grant\_permission\_table\_monitor</a>: Table monitor </li>
                  </ul>
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>permission</td>

                <td>
                  Permission being granted. Supported values:

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a89c89f9679a7e3cb100989e71eec9b0b">grant\_permission\_admin</a>: Full read/write and administrative access on the object. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a979b539e99ba5984ae718ab8a2fb4fb2">grant\_permission\_connect</a>: Connect access on the given data source or data sink. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#af47abdc51efdfef4eb6b2722aa70b0e8">grant\_permission\_create</a>: Ability to create new objects of this type. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a0aab091df760dd732ba31c0b7fb9484f">grant\_permission\_delete</a>: Delete rows from tables. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ad5b25c6916cff7f73c637e7d38eb8047">grant\_permission\_execute</a>: Ability to Execute the Procedure object. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a0f36ab5887cbb13e802cff82d3053bdf">grant\_permission\_insert</a>: Insert access to tables. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a438f74c3ac20f9fd42dd1a3e20d3790f">grant\_permission\_monitor</a>: Monitor logs and statistics. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a692ef22b4fb5fcb9c69324be90c3c653">grant\_permission\_read</a>: Ability to read, list and use the object. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aa34b4ec6ad55aaf3ecafd10b3cb0f19a">grant\_permission\_send\_alert</a>: Ability to send system alerts. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a668b88450069d5970c15657fe9d4f895">grant\_permission\_update</a>: Update access to the table. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aa48e03113ef418f1eedb6828f0b810f6">grant\_permission\_user\_admin</a>: Access to administer users and roles that do not have system\_admin permission. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a8a5928c9d9b4efcbb03f388ab98d08dd">grant\_permission\_write</a>: Access to write, change and delete objects. </li>
                  </ul>
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a860307a66632035036a5055a090bd1fb">grant\_permission\_columns</a>: Apply table security to these columns, comma-separated. The default value is ''. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ab61a6300639ade83eb2668f922d66b24">grant\_permission\_filter\_expression</a>: Filter expression to apply to this grant. Only rows that match the filter will be affected. The default value is ''. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a9c23b453e73de3a3acd1c44f17b9b36d">grant\_permission\_with\_grant\_option</a>: Allow the recipient to grant the same permission (or subset) to others. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a3b94060fa83483944ccd69ec45996f1e">grant\_permission\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aedd795b6c6635094d46108eb8242cb13">grant\_permission\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#aedd795b6c6635094d46108eb8242cb13">grant\_permission\_false</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GrantPermissionResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1GrantPermissionResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a5af24b8cecd2bbd61c1fb7e9725e33a8">◆ </a></span>grantPermissionCredential() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1GrantPermissionCredentialResponse">GrantPermissionCredentialResponse</a> gpudb::GPUdb::grantPermissionCredential </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1GrantPermissionCredentialRequest">GrantPermissionCredentialRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Grants a <a href="/content/security/sec_concepts/#security-concepts-permissions-credential">credential-level permission</a> to a user or role. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GrantPermissionCredentialRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1GrantPermissionCredentialResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a5e6ce0e2b63b4f558fc15a2ffbbd9be2">◆ </a></span>grantPermissionCredential() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1GrantPermissionCredentialResponse">GrantPermissionCredentialResponse</a> & gpudb::GPUdb::grantPermissionCredential </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1GrantPermissionCredentialRequest">GrantPermissionCredentialRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1GrantPermissionCredentialResponse">GrantPermissionCredentialResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Grants a <a href="/content/security/sec_concepts/#security-concepts-permissions-credential">credential-level permission</a> to a user or role. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GrantPermissionCredentialRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GrantPermissionCredentialResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1GrantPermissionCredentialResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ab57fd01de61ce3a433bee4e63061a605">◆ </a></span>grantPermissionCredential() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1GrantPermissionCredentialResponse">GrantPermissionCredentialResponse</a> gpudb::GPUdb::grantPermissionCredential </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>permission</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>credentialName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Grants a <a href="/content/security/sec_concepts/#security-concepts-permissions-credential">credential-level permission</a> to a user or role. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>name</td>
                <td>Name of the user or role to which the permission will be granted. Must be an existing user or role. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>permission</td>

                <td>
                  Permission to grant to the user or role. Supported values:

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a3415c25f8cafd174adfbe1df56c54db0">grant\_permission\_credential\_credential\_admin</a>: Full read/write and administrative access on the credential. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a3b091a1057fa2c25e943bbe3dc6d9034">grant\_permission\_credential\_credential\_read</a>: Ability to read and use the credential. </li>
                  </ul>
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>credentialName</td>
                <td>Name of the credential on which the permission will be granted. Must be an existing credential, or an empty string to grant access on all credentials. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1GrantPermissionCredentialResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a4c9725405ce5877be0f5150a4cd5a916">◆ </a></span>grantPermissionCredential() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1GrantPermissionCredentialResponse">GrantPermissionCredentialResponse</a> & gpudb::GPUdb::grantPermissionCredential </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>permission</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>credentialName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1GrantPermissionCredentialResponse">GrantPermissionCredentialResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Grants a <a href="/content/security/sec_concepts/#security-concepts-permissions-credential">credential-level permission</a> to a user or role. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>name</td>
                <td>Name of the user or role to which the permission will be granted. Must be an existing user or role. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>permission</td>

                <td>
                  Permission to grant to the user or role. Supported values:

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a3415c25f8cafd174adfbe1df56c54db0">grant\_permission\_credential\_credential\_admin</a>: Full read/write and administrative access on the credential. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a3b091a1057fa2c25e943bbe3dc6d9034">grant\_permission\_credential\_credential\_read</a>: Ability to read and use the credential. </li>
                  </ul>
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>credentialName</td>
                <td>Name of the credential on which the permission will be granted. Must be an existing credential, or an empty string to grant access on all credentials. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GrantPermissionCredentialResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1GrantPermissionCredentialResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a5ea6ea4a2af4895f3acf2131ffe36c56">◆ </a></span>grantPermissionDatasource() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1GrantPermissionDatasourceResponse">GrantPermissionDatasourceResponse</a> gpudb::GPUdb::grantPermissionDatasource </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1GrantPermissionDatasourceRequest">GrantPermissionDatasourceRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Grants a <a href="/content/concepts/data_sources/">data source</a> permission to a user or role. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GrantPermissionDatasourceRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1GrantPermissionDatasourceResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a427ec3b80a4def2161784aa9e7371b00">◆ </a></span>grantPermissionDatasource() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1GrantPermissionDatasourceResponse">GrantPermissionDatasourceResponse</a> & gpudb::GPUdb::grantPermissionDatasource </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1GrantPermissionDatasourceRequest">GrantPermissionDatasourceRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1GrantPermissionDatasourceResponse">GrantPermissionDatasourceResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Grants a <a href="/content/concepts/data_sources/">data source</a> permission to a user or role. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GrantPermissionDatasourceRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GrantPermissionDatasourceResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1GrantPermissionDatasourceResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ab404e2c7c283594278c84d22832ccfaf">◆ </a></span>grantPermissionDatasource() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1GrantPermissionDatasourceResponse">GrantPermissionDatasourceResponse</a> gpudb::GPUdb::grantPermissionDatasource </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>permission</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>datasourceName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Grants a <a href="/content/concepts/data_sources/">data source</a> permission to a user or role. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>name</td>
                <td>Name of the user or role to which the permission will be granted. Must be an existing user or role. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>permission</td>

                <td>
                  Permission to grant to the user or role. Supported values:

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a7537475c56ceaa2d2583ba633210c191">grant\_permission\_datasource\_admin</a>: Admin access on the given data source. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ae657f681c0269d80d72dd986106ccf28">grant\_permission\_datasource\_connect</a>: Connect access on the given data source. </li>
                  </ul>
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>datasourceName</td>
                <td>Name of the data source on which the permission will be granted. Must be an existing data source, or an empty string to grant permission on all data sources. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1GrantPermissionDatasourceResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a131e77dc89bc9cebcb915c8b04e873eb">◆ </a></span>grantPermissionDatasource() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1GrantPermissionDatasourceResponse">GrantPermissionDatasourceResponse</a> & gpudb::GPUdb::grantPermissionDatasource </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>permission</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>datasourceName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1GrantPermissionDatasourceResponse">GrantPermissionDatasourceResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Grants a <a href="/content/concepts/data_sources/">data source</a> permission to a user or role. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>name</td>
                <td>Name of the user or role to which the permission will be granted. Must be an existing user or role. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>permission</td>

                <td>
                  Permission to grant to the user or role. Supported values:

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a7537475c56ceaa2d2583ba633210c191">grant\_permission\_datasource\_admin</a>: Admin access on the given data source. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ae657f681c0269d80d72dd986106ccf28">grant\_permission\_datasource\_connect</a>: Connect access on the given data source. </li>
                  </ul>
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>datasourceName</td>
                <td>Name of the data source on which the permission will be granted. Must be an existing data source, or an empty string to grant permission on all data sources. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GrantPermissionDatasourceResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1GrantPermissionDatasourceResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#aa02d37420e163a262aa02ac482c0a2fa">◆ </a></span>grantPermissionDirectory() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1GrantPermissionDirectoryResponse">GrantPermissionDirectoryResponse</a> gpudb::GPUdb::grantPermissionDirectory </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1GrantPermissionDirectoryRequest">GrantPermissionDirectoryRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Grants a <a href="/content/tools/kifs/">KiFS</a> directory-level permission to a user or role. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GrantPermissionDirectoryRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1GrantPermissionDirectoryResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ac66d25d1962e021bc7c0813f5d106c46">◆ </a></span>grantPermissionDirectory() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1GrantPermissionDirectoryResponse">GrantPermissionDirectoryResponse</a> & gpudb::GPUdb::grantPermissionDirectory </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1GrantPermissionDirectoryRequest">GrantPermissionDirectoryRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1GrantPermissionDirectoryResponse">GrantPermissionDirectoryResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Grants a <a href="/content/tools/kifs/">KiFS</a> directory-level permission to a user or role. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GrantPermissionDirectoryRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GrantPermissionDirectoryResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1GrantPermissionDirectoryResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ab075f1bfb3d056cc09fc5fa0dac49ed1">◆ </a></span>grantPermissionDirectory() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1GrantPermissionDirectoryResponse">GrantPermissionDirectoryResponse</a> gpudb::GPUdb::grantPermissionDirectory </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>permission</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>directoryName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Grants a <a href="/content/tools/kifs/">KiFS</a> directory-level permission to a user or role. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>name</td>
                <td>Name of the user or role to which the permission will be granted. Must be an existing user or role. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>permission</td>

                <td>
                  Permission to grant to the user or role. Supported values:

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a268fdef8ea1156901efbb6bc763013dc">grant\_permission\_directory\_directory\_read</a>: For files in the directory, access to list files, download files, or use files in server side functions. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a5bbac3b95c72870482d251e60f4805bb">grant\_permission\_directory\_directory\_write</a>: Access to upload files to, or delete files from, the directory. A user or role with write access automatically has read access. </li>
                  </ul>
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>directoryName</td>
                <td>Name of the KiFS directory to which the permission grants access. An empty directory name grants access to all KiFS directories. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1GrantPermissionDirectoryResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a738b0c8ec727a4ca7c4e00e9146650d2">◆ </a></span>grantPermissionDirectory() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1GrantPermissionDirectoryResponse">GrantPermissionDirectoryResponse</a> & gpudb::GPUdb::grantPermissionDirectory </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>permission</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>directoryName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1GrantPermissionDirectoryResponse">GrantPermissionDirectoryResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Grants a <a href="/content/tools/kifs/">KiFS</a> directory-level permission to a user or role. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>name</td>
                <td>Name of the user or role to which the permission will be granted. Must be an existing user or role. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>permission</td>

                <td>
                  Permission to grant to the user or role. Supported values:

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a268fdef8ea1156901efbb6bc763013dc">grant\_permission\_directory\_directory\_read</a>: For files in the directory, access to list files, download files, or use files in server side functions. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a5bbac3b95c72870482d251e60f4805bb">grant\_permission\_directory\_directory\_write</a>: Access to upload files to, or delete files from, the directory. A user or role with write access automatically has read access. </li>
                  </ul>
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>directoryName</td>
                <td>Name of the KiFS directory to which the permission grants access. An empty directory name grants access to all KiFS directories. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GrantPermissionDirectoryResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1GrantPermissionDirectoryResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ae1cd6282f2b962d6546030ef18f93ff9">◆ </a></span>grantPermissionProc() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1GrantPermissionProcResponse">GrantPermissionProcResponse</a> gpudb::GPUdb::grantPermissionProc </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1GrantPermissionProcRequest">GrantPermissionProcRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Grants a proc-level permission to a user or role. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GrantPermissionProcRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1GrantPermissionProcResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ab737c77492222b5ce08c7c956e5d340e">◆ </a></span>grantPermissionProc() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1GrantPermissionProcResponse">GrantPermissionProcResponse</a> & gpudb::GPUdb::grantPermissionProc </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1GrantPermissionProcRequest">GrantPermissionProcRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1GrantPermissionProcResponse">GrantPermissionProcResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Grants a proc-level permission to a user or role. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GrantPermissionProcRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GrantPermissionProcResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1GrantPermissionProcResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a39578835ce1484d4a150898a1774f62d">◆ </a></span>grantPermissionProc() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1GrantPermissionProcResponse">GrantPermissionProcResponse</a> gpudb::GPUdb::grantPermissionProc </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>permission</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>procName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Grants a proc-level permission to a user or role. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>name</td>
                <td>Name of the user or role to which the permission will be granted. Must be an existing user or role. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>permission</td>

                <td>
                  Permission to grant to the user or role. Supported values:

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a43c6473ecd8c648a1ea0afa3541c2845">grant\_permission\_proc\_proc\_admin</a>: Admin access to the proc. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a5797c99233dc45d3e6674cb60c7060d6">grant\_permission\_proc\_proc\_execute</a>: Execute access to the proc. </li>
                  </ul>
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>procName</td>
                <td>Name of the proc to which the permission grants access. Must be an existing proc, or an empty string to grant access to all procs. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1GrantPermissionProcResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ae76c509220ba69f3f36732ec77c77199">◆ </a></span>grantPermissionProc() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1GrantPermissionProcResponse">GrantPermissionProcResponse</a> & gpudb::GPUdb::grantPermissionProc </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>permission</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>procName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1GrantPermissionProcResponse">GrantPermissionProcResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Grants a proc-level permission to a user or role. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>name</td>
                <td>Name of the user or role to which the permission will be granted. Must be an existing user or role. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>permission</td>

                <td>
                  Permission to grant to the user or role. Supported values:

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a43c6473ecd8c648a1ea0afa3541c2845">grant\_permission\_proc\_proc\_admin</a>: Admin access to the proc. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a5797c99233dc45d3e6674cb60c7060d6">grant\_permission\_proc\_proc\_execute</a>: Execute access to the proc. </li>
                  </ul>
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>procName</td>
                <td>Name of the proc to which the permission grants access. Must be an existing proc, or an empty string to grant access to all procs. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GrantPermissionProcResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1GrantPermissionProcResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ac369cb52634167b30ce05c0f3a16cc53">◆ </a></span>grantPermissionSystem() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1GrantPermissionSystemResponse">GrantPermissionSystemResponse</a> gpudb::GPUdb::grantPermissionSystem </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1GrantPermissionSystemRequest">GrantPermissionSystemRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Grants a system-level permission to a user or role. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GrantPermissionSystemRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1GrantPermissionSystemResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ad059fd03ac708e02b8e161c70b70b88d">◆ </a></span>grantPermissionSystem() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1GrantPermissionSystemResponse">GrantPermissionSystemResponse</a> & gpudb::GPUdb::grantPermissionSystem </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1GrantPermissionSystemRequest">GrantPermissionSystemRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1GrantPermissionSystemResponse">GrantPermissionSystemResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Grants a system-level permission to a user or role. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GrantPermissionSystemRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GrantPermissionSystemResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1GrantPermissionSystemResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a690cdf000db0679b6955d10585398b84">◆ </a></span>grantPermissionSystem() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1GrantPermissionSystemResponse">GrantPermissionSystemResponse</a> gpudb::GPUdb::grantPermissionSystem </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>permission</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Grants a system-level permission to a user or role. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>name</td>
                <td>Name of the user or role to which the permission will be granted. Must be an existing user or role. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>permission</td>

                <td>
                  Permission to grant to the user or role. Supported values:

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a49aad29893cb4fb4f1d0bfb4f57d239d">grant\_permission\_system\_system\_admin</a>: Full access to all data and system functions. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a879bdf733506f4d379b861764b21aa97">grant\_permission\_system\_system\_user\_admin</a>: Access to administer users and roles that do not have system\_admin permission. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a41eb05f344d0171357a90f9e0ca8a172">grant\_permission\_system\_system\_write</a>: Read and write access to all tables. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ab90683aa57001d9351300e4bcfd0e180">grant\_permission\_system\_system\_read</a>: Read-only access to all tables. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aa08faff6e90820903186c756adb5f106">grant\_permission\_system\_system\_send\_alert</a>: Send system alerts. </li>
                  </ul>
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1GrantPermissionSystemResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a4f2521179ba1025d1df0a280a9303835">◆ </a></span>grantPermissionSystem() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1GrantPermissionSystemResponse">GrantPermissionSystemResponse</a> & gpudb::GPUdb::grantPermissionSystem </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>permission</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1GrantPermissionSystemResponse">GrantPermissionSystemResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Grants a system-level permission to a user or role. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>name</td>
                <td>Name of the user or role to which the permission will be granted. Must be an existing user or role. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>permission</td>

                <td>
                  Permission to grant to the user or role. Supported values:

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a49aad29893cb4fb4f1d0bfb4f57d239d">grant\_permission\_system\_system\_admin</a>: Full access to all data and system functions. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a879bdf733506f4d379b861764b21aa97">grant\_permission\_system\_system\_user\_admin</a>: Access to administer users and roles that do not have system\_admin permission. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a41eb05f344d0171357a90f9e0ca8a172">grant\_permission\_system\_system\_write</a>: Read and write access to all tables. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ab90683aa57001d9351300e4bcfd0e180">grant\_permission\_system\_system\_read</a>: Read-only access to all tables. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aa08faff6e90820903186c756adb5f106">grant\_permission\_system\_system\_send\_alert</a>: Send system alerts. </li>
                  </ul>
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GrantPermissionSystemResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1GrantPermissionSystemResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a7645484bba3b9b9cf2d0549fa9ea4a5e">◆ </a></span>grantPermissionTable() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1GrantPermissionTableResponse">GrantPermissionTableResponse</a> gpudb::GPUdb::grantPermissionTable </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1GrantPermissionTableRequest">GrantPermissionTableRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Grants a table-level permission to a user or role. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GrantPermissionTableRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1GrantPermissionTableResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a6ac61f85670e122b14f4bdc6de033563">◆ </a></span>grantPermissionTable() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1GrantPermissionTableResponse">GrantPermissionTableResponse</a> & gpudb::GPUdb::grantPermissionTable </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1GrantPermissionTableRequest">GrantPermissionTableRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1GrantPermissionTableResponse">GrantPermissionTableResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Grants a table-level permission to a user or role. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GrantPermissionTableRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GrantPermissionTableResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1GrantPermissionTableResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a316e6277ca48b863d066a315e6e19f01">◆ </a></span>grantPermissionTable() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1GrantPermissionTableResponse">GrantPermissionTableResponse</a> gpudb::GPUdb::grantPermissionTable </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>permission</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>filterExpression</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Grants a table-level permission to a user or role. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>name</td>
                <td>Name of the user or role to which the permission will be granted. Must be an existing user or role. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>permission</td>

                <td>
                  Permission to grant to the user or role. Supported values:

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a143306a2b55e28fbb97cdb7a15819ddf">grant\_permission\_table\_table\_admin</a>: Full read/write and administrative access to the table. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a3c5bc1409091cf8a64bb9ccc20dda443">grant\_permission\_table\_table\_insert</a>: Insert access to the table. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aef289a043bbd7e5fa4532820b81a5065">grant\_permission\_table\_table\_update</a>: Update access to the table. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a3abb5fcb6767f9871db6f6bdb63e2df8">grant\_permission\_table\_table\_delete</a>: Delete access to the table. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a2f8fad1eccd565474e553085c4bd57a9">grant\_permission\_table\_table\_read</a>: Read access to the table. </li>
                  </ul>
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of the table to which the permission grants access, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. Must be an existing table, view, or schema. If a schema, the permission also applies to tables and views in the schema. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>filterExpression</td>
                <td>Optional filter expression to apply to this grant. Only rows that match the filter will be affected. The default value is ''. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#abbac109214b76a5d44567061bd4a920f">grant\_permission\_table\_columns</a>: Apply security to these columns, comma-separated. The default value is ''. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1GrantPermissionTableResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ab41217b1f8c629a915e0df1913e3257d">◆ </a></span>grantPermissionTable() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1GrantPermissionTableResponse">GrantPermissionTableResponse</a> & gpudb::GPUdb::grantPermissionTable </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>permission</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>filterExpression</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1GrantPermissionTableResponse">GrantPermissionTableResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Grants a table-level permission to a user or role. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>name</td>
                <td>Name of the user or role to which the permission will be granted. Must be an existing user or role. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>permission</td>

                <td>
                  Permission to grant to the user or role. Supported values:

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a143306a2b55e28fbb97cdb7a15819ddf">grant\_permission\_table\_table\_admin</a>: Full read/write and administrative access to the table. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a3c5bc1409091cf8a64bb9ccc20dda443">grant\_permission\_table\_table\_insert</a>: Insert access to the table. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aef289a043bbd7e5fa4532820b81a5065">grant\_permission\_table\_table\_update</a>: Update access to the table. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a3abb5fcb6767f9871db6f6bdb63e2df8">grant\_permission\_table\_table\_delete</a>: Delete access to the table. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a2f8fad1eccd565474e553085c4bd57a9">grant\_permission\_table\_table\_read</a>: Read access to the table. </li>
                  </ul>
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of the table to which the permission grants access, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. Must be an existing table, view, or schema. If a schema, the permission also applies to tables and views in the schema. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>filterExpression</td>
                <td>Optional filter expression to apply to this grant. Only rows that match the filter will be affected. The default value is ''. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#abbac109214b76a5d44567061bd4a920f">grant\_permission\_table\_columns</a>: Apply security to these columns, comma-separated. The default value is ''. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GrantPermissionTableResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1GrantPermissionTableResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ade2d2cdb909e06802487b2045858fc11">◆ </a></span>grantRole() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1GrantRoleResponse">GrantRoleResponse</a> gpudb::GPUdb::grantRole </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1GrantRoleRequest">GrantRoleRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Grants membership in a role to a user or role. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GrantRoleRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1GrantRoleResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ae7f09ce61485841d9aafdb2d0152b61a">◆ </a></span>grantRole() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1GrantRoleResponse">GrantRoleResponse</a> & gpudb::GPUdb::grantRole </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1GrantRoleRequest">GrantRoleRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1GrantRoleResponse">GrantRoleResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Grants membership in a role to a user or role. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GrantRoleRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GrantRoleResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1GrantRoleResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a9983e28ef620839a6f823682bd82d7d3">◆ </a></span>grantRole() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1GrantRoleResponse">GrantRoleResponse</a> gpudb::GPUdb::grantRole </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>role</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>member</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Grants membership in a role to a user or role. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>role</td>
                <td>Name of the role in which membership will be granted. Must be an existing role. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>member</td>
                <td>Name of the user or role that will be granted membership in <span>role</span>. Must be an existing user or role. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1GrantRoleResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a6b2b87f37e939d37af459304a4ac2d22">◆ </a></span>grantRole() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1GrantRoleResponse">GrantRoleResponse</a> & gpudb::GPUdb::grantRole </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>role</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>member</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1GrantRoleResponse">GrantRoleResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Grants membership in a role to a user or role. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>role</td>
                <td>Name of the role in which membership will be granted. Must be an existing role. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>member</td>
                <td>Name of the user or role that will be granted membership in <span>role</span>. Must be an existing user or role. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1GrantRoleResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1GrantRoleResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ad740516d31f0ac8d62a590aa2878a277">◆ </a></span>hasPermission() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1HasPermissionResponse">HasPermissionResponse</a> gpudb::GPUdb::hasPermission </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1HasPermissionRequest">HasPermissionRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Checks if the specified user has the specified permission on the specified object. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1HasPermissionRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1HasPermissionResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#aebb61f251c3e6b98ba7e548e8a29d725">◆ </a></span>hasPermission() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1HasPermissionResponse">HasPermissionResponse</a> & gpudb::GPUdb::hasPermission </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1HasPermissionRequest">HasPermissionRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1HasPermissionResponse">HasPermissionResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Checks if the specified user has the specified permission on the specified object. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1HasPermissionRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1HasPermissionResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1HasPermissionResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a1b210b587020332f624a3f593b06cd59">◆ </a></span>hasPermission() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1HasPermissionResponse">HasPermissionResponse</a> gpudb::GPUdb::hasPermission </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>principal</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>object</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>objectType</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>permission</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Checks if the specified user has the specified permission on the specified object. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>principal</td>
                <td>Name of the user for which the permission is being checked. Must be an existing user. If blank, will use the current user. The default value is ''. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>object</td>
                <td>Name of object to check for the requested permission. It is recommended to use a fully-qualified name when possible. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>objectType</td>

                <td>
                  The type of object being checked. Supported values:

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a767c126386b1dc1521403225ca5f2f23">has\_permission\_catalog</a>: External Catalog </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a03af6d590b45321bb2e35fed6828e950">has\_permission\_context</a>: Context </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a090ccf7eb4ef2ad2ff9ed11b17f49c7c">has\_permission\_credential</a>: Credential </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aa62f75fd6edf6daa61e954069cf4e5fe">has\_permission\_datasink</a>: Data Sink </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a0c04c6550a9e464de2859f98ff037732">has\_permission\_datasource</a>: Data Source </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a4cbca7d37ce5bebc97e7b04c0caca9a3">has\_permission\_directory</a>: KiFS File Directory </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ab6cacce8a91d52b7b6b944d3b72be748">has\_permission\_graph</a>: A Graph object </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a3ba61d0d3e9837d76b737e4dea2ac875">has\_permission\_proc</a>: UDF Procedure </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#abafb41b476981436f70a94dbeb2bb01d">has\_permission\_schema</a>: Schema </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#adae5146b883404baa649cd512ad4a0d8">has\_permission\_sql\_proc</a>: SQL Procedure </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a51fba795646bb9859ec8285c6b1697bf">has\_permission\_system</a>: System-level access </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a735ac696b15c26bda42e5ac8b83c30b1">has\_permission\_table</a>: Database Table </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#af0c06b4f6465463098bfee9da41ee93a">has\_permission\_table\_monitor</a>: Table monitor </li>
                  </ul>
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>permission</td>

                <td>
                  Permission to check for. Supported values:

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a8788ef65be6c9b2c243d14d18121a882">has\_permission\_admin</a>: Full read/write and administrative access on the object. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a71b90d379708ccc0a1f1e0b1451c08de">has\_permission\_connect</a>: Connect access on the given data source or data sink. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a020aa4e42a19ed5f5b2ee46885c69eb0">has\_permission\_create</a>: Ability to create new objects of this type. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#afec66c3b938351e81d2678b4f3bba9e9">has\_permission\_delete</a>: Delete rows from tables. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ae2de46a467eeab9af50435966251eae6">has\_permission\_execute</a>: Ability to Execute the Procedure object. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a8fde46efe1ecc83cbfe296db3bc885b3">has\_permission\_insert</a>: Insert access to tables. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a6d4a5cc82e45ffd2dff7f1eadf66ea45">has\_permission\_monitor</a>: Monitor logs and statistics. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a3c3964fa47c92ef20cd3413481e8d4f3">has\_permission\_read</a>: Ability to read, list and use the object. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a18ef8628741c5aa01413b020f3334b21">has\_permission\_send\_alert</a>: Ability to send system alerts. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a53c6486ead60a419192fe8cd1e4622c8">has\_permission\_update</a>: Update access to the table. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a35e4f6e1898c173bc941a92045c58c0d">has\_permission\_user\_admin</a>: Access to administer users and roles that do not have system\_admin permission. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ace00eb2e18611481e698239310595e4f">has\_permission\_write</a>: Access to write, change and delete objects. </li>
                  </ul>
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a51a3d6cf6178e3b560e79430f15cd799">has\_permission\_no\_error\_if\_not\_exists</a>: If <a href="/content/api/cpp/namespacegpudb#a044212fe1d24da28931aa217400a0a0e">false</a> will return an error if the provided <span>object</span> does not exist or is blank. If <a href="/content/api/cpp/namespacegpudb#ab1d00c71f5a315f1280671f39d1cff56">true</a> then it will return <a href="/content/api/cpp/namespacegpudb#a044212fe1d24da28931aa217400a0a0e">false</a> for <a href="/content/api/cpp/structgpudb_1_1HasPermissionResponse#a34fdce033e77733b1438ac249294080e">hasPermission</a>. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ab1d00c71f5a315f1280671f39d1cff56">has\_permission\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a044212fe1d24da28931aa217400a0a0e">has\_permission\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a044212fe1d24da28931aa217400a0a0e">has\_permission\_false</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1HasPermissionResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ad4b2f3ea35b07dc86431bb1483ead30b">◆ </a></span>hasPermission() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1HasPermissionResponse">HasPermissionResponse</a> & gpudb::GPUdb::hasPermission </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>principal</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>object</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>objectType</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>permission</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1HasPermissionResponse">HasPermissionResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Checks if the specified user has the specified permission on the specified object. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>principal</td>
                <td>Name of the user for which the permission is being checked. Must be an existing user. If blank, will use the current user. The default value is ''. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>object</td>
                <td>Name of object to check for the requested permission. It is recommended to use a fully-qualified name when possible. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>objectType</td>

                <td>
                  The type of object being checked. Supported values:

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a767c126386b1dc1521403225ca5f2f23">has\_permission\_catalog</a>: External Catalog </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a03af6d590b45321bb2e35fed6828e950">has\_permission\_context</a>: Context </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a090ccf7eb4ef2ad2ff9ed11b17f49c7c">has\_permission\_credential</a>: Credential </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aa62f75fd6edf6daa61e954069cf4e5fe">has\_permission\_datasink</a>: Data Sink </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a0c04c6550a9e464de2859f98ff037732">has\_permission\_datasource</a>: Data Source </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a4cbca7d37ce5bebc97e7b04c0caca9a3">has\_permission\_directory</a>: KiFS File Directory </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ab6cacce8a91d52b7b6b944d3b72be748">has\_permission\_graph</a>: A Graph object </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a3ba61d0d3e9837d76b737e4dea2ac875">has\_permission\_proc</a>: UDF Procedure </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#abafb41b476981436f70a94dbeb2bb01d">has\_permission\_schema</a>: Schema </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#adae5146b883404baa649cd512ad4a0d8">has\_permission\_sql\_proc</a>: SQL Procedure </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a51fba795646bb9859ec8285c6b1697bf">has\_permission\_system</a>: System-level access </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a735ac696b15c26bda42e5ac8b83c30b1">has\_permission\_table</a>: Database Table </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#af0c06b4f6465463098bfee9da41ee93a">has\_permission\_table\_monitor</a>: Table monitor </li>
                  </ul>
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>permission</td>

                <td>
                  Permission to check for. Supported values:

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a8788ef65be6c9b2c243d14d18121a882">has\_permission\_admin</a>: Full read/write and administrative access on the object. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a71b90d379708ccc0a1f1e0b1451c08de">has\_permission\_connect</a>: Connect access on the given data source or data sink. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a020aa4e42a19ed5f5b2ee46885c69eb0">has\_permission\_create</a>: Ability to create new objects of this type. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#afec66c3b938351e81d2678b4f3bba9e9">has\_permission\_delete</a>: Delete rows from tables. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ae2de46a467eeab9af50435966251eae6">has\_permission\_execute</a>: Ability to Execute the Procedure object. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a8fde46efe1ecc83cbfe296db3bc885b3">has\_permission\_insert</a>: Insert access to tables. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a6d4a5cc82e45ffd2dff7f1eadf66ea45">has\_permission\_monitor</a>: Monitor logs and statistics. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a3c3964fa47c92ef20cd3413481e8d4f3">has\_permission\_read</a>: Ability to read, list and use the object. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a18ef8628741c5aa01413b020f3334b21">has\_permission\_send\_alert</a>: Ability to send system alerts. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a53c6486ead60a419192fe8cd1e4622c8">has\_permission\_update</a>: Update access to the table. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a35e4f6e1898c173bc941a92045c58c0d">has\_permission\_user\_admin</a>: Access to administer users and roles that do not have system\_admin permission. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ace00eb2e18611481e698239310595e4f">has\_permission\_write</a>: Access to write, change and delete objects. </li>
                  </ul>
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a51a3d6cf6178e3b560e79430f15cd799">has\_permission\_no\_error\_if\_not\_exists</a>: If <a href="/content/api/cpp/namespacegpudb#a044212fe1d24da28931aa217400a0a0e">false</a> will return an error if the provided <span>object</span> does not exist or is blank. If <a href="/content/api/cpp/namespacegpudb#ab1d00c71f5a315f1280671f39d1cff56">true</a> then it will return <a href="/content/api/cpp/namespacegpudb#a044212fe1d24da28931aa217400a0a0e">false</a> for <a href="/content/api/cpp/structgpudb_1_1HasPermissionResponse#a34fdce033e77733b1438ac249294080e">hasPermission</a>. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ab1d00c71f5a315f1280671f39d1cff56">has\_permission\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a044212fe1d24da28931aa217400a0a0e">has\_permission\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a044212fe1d24da28931aa217400a0a0e">has\_permission\_false</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1HasPermissionResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1HasPermissionResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a8fca6e2965ad9a737ede2c6df0ea1684">◆ </a></span>hasProc() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1HasProcResponse">HasProcResponse</a> gpudb::GPUdb::hasProc </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1HasProcRequest">HasProcRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Checks the existence of a proc with the given name. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1HasProcRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1HasProcResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a9e6b482a289a859bdc661c0c23349f6c">◆ </a></span>hasProc() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1HasProcResponse">HasProcResponse</a> & gpudb::GPUdb::hasProc </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1HasProcRequest">HasProcRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1HasProcResponse">HasProcResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Checks the existence of a proc with the given name. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1HasProcRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1HasProcResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1HasProcResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a438632111406c853d6210addab7c764c">◆ </a></span>hasProc() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1HasProcResponse">HasProcResponse</a> gpudb::GPUdb::hasProc </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>procName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Checks the existence of a proc with the given name. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>procName</td>
                <td>Name of the proc to check for existence. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1HasProcResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a4d178d98d1c5209df924b6c6a459b2ad">◆ </a></span>hasProc() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1HasProcResponse">HasProcResponse</a> & gpudb::GPUdb::hasProc </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>procName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1HasProcResponse">HasProcResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Checks the existence of a proc with the given name. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>procName</td>
                <td>Name of the proc to check for existence. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1HasProcResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1HasProcResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a9de0d2bb24bdfa17ea915c8c29ab9f06">◆ </a></span>hasRole() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1HasRoleResponse">HasRoleResponse</a> gpudb::GPUdb::hasRole </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1HasRoleRequest">HasRoleRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Checks if the specified user has the specified role. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1HasRoleRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1HasRoleResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a5b8c49a68512e098f534b4ad4345080e">◆ </a></span>hasRole() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1HasRoleResponse">HasRoleResponse</a> & gpudb::GPUdb::hasRole </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1HasRoleRequest">HasRoleRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1HasRoleResponse">HasRoleResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Checks if the specified user has the specified role. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1HasRoleRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1HasRoleResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1HasRoleResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ac09bb999e6f1d7e839949498beb2a0d7">◆ </a></span>hasRole() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1HasRoleResponse">HasRoleResponse</a> gpudb::GPUdb::hasRole </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>principal</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>role</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Checks if the specified user has the specified role. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>principal</td>
                <td>Name of the user for which role membership is being checked. Must be an existing user. If blank, will use the current user. The default value is ''. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>role</td>
                <td>Name of role to check for membership. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#aacf51814d2a53ab6e98ce65fa0acf955">has\_role\_no\_error\_if\_not\_exists</a>: If <a href="/content/api/cpp/namespacegpudb#a75680d2b8b9603da05dcd22794162a06">false</a> will return an error if the provided <span>role</span> does not exist or is blank. If <a href="/content/api/cpp/namespacegpudb#a7a9e6d715315aec0f6eb6ceb3c6a5a55">true</a> then it will return <a href="/content/api/cpp/namespacegpudb#a75680d2b8b9603da05dcd22794162a06">false</a> for <a href="/content/api/cpp/structgpudb_1_1HasRoleResponse#a9fb645db6c469a4a10e59b4e823461fa">hasRole</a>. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a7a9e6d715315aec0f6eb6ceb3c6a5a55">has\_role\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a75680d2b8b9603da05dcd22794162a06">has\_role\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a75680d2b8b9603da05dcd22794162a06">has\_role\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a448bac98035ddaa22a4f20f944a91287">has\_role\_only\_direct</a>: If <a href="/content/api/cpp/namespacegpudb#a75680d2b8b9603da05dcd22794162a06">false</a> will search recursively if the <span>principal</span> is a member of <span>role</span>. If <a href="/content/api/cpp/namespacegpudb#a7a9e6d715315aec0f6eb6ceb3c6a5a55">true</a> then <span>principal</span> must directly be a member of <span>role</span>. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a7a9e6d715315aec0f6eb6ceb3c6a5a55">has\_role\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a75680d2b8b9603da05dcd22794162a06">has\_role\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a75680d2b8b9603da05dcd22794162a06">has\_role\_false</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1HasRoleResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a11a614337a040e473f85b6dbd9b03cc2">◆ </a></span>hasRole() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1HasRoleResponse">HasRoleResponse</a> & gpudb::GPUdb::hasRole </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>principal</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>role</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1HasRoleResponse">HasRoleResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Checks if the specified user has the specified role. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>principal</td>
                <td>Name of the user for which role membership is being checked. Must be an existing user. If blank, will use the current user. The default value is ''. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>role</td>
                <td>Name of role to check for membership. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#aacf51814d2a53ab6e98ce65fa0acf955">has\_role\_no\_error\_if\_not\_exists</a>: If <a href="/content/api/cpp/namespacegpudb#a75680d2b8b9603da05dcd22794162a06">false</a> will return an error if the provided <span>role</span> does not exist or is blank. If <a href="/content/api/cpp/namespacegpudb#a7a9e6d715315aec0f6eb6ceb3c6a5a55">true</a> then it will return <a href="/content/api/cpp/namespacegpudb#a75680d2b8b9603da05dcd22794162a06">false</a> for <a href="/content/api/cpp/structgpudb_1_1HasRoleResponse#a9fb645db6c469a4a10e59b4e823461fa">hasRole</a>. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a7a9e6d715315aec0f6eb6ceb3c6a5a55">has\_role\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a75680d2b8b9603da05dcd22794162a06">has\_role\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a75680d2b8b9603da05dcd22794162a06">has\_role\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a448bac98035ddaa22a4f20f944a91287">has\_role\_only\_direct</a>: If <a href="/content/api/cpp/namespacegpudb#a75680d2b8b9603da05dcd22794162a06">false</a> will search recursively if the <span>principal</span> is a member of <span>role</span>. If <a href="/content/api/cpp/namespacegpudb#a7a9e6d715315aec0f6eb6ceb3c6a5a55">true</a> then <span>principal</span> must directly be a member of <span>role</span>. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a7a9e6d715315aec0f6eb6ceb3c6a5a55">has\_role\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a75680d2b8b9603da05dcd22794162a06">has\_role\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a75680d2b8b9603da05dcd22794162a06">has\_role\_false</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1HasRoleResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1HasRoleResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ad9239208a2646cbf0b1bd9bf4e1a0d50">◆ </a></span>hasSchema() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1HasSchemaResponse">HasSchemaResponse</a> gpudb::GPUdb::hasSchema </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1HasSchemaRequest">HasSchemaRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Checks for the existence of a schema with the given name. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1HasSchemaRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1HasSchemaResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a52f028efcf36a5a95a9414f7f9fb7edc">◆ </a></span>hasSchema() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1HasSchemaResponse">HasSchemaResponse</a> & gpudb::GPUdb::hasSchema </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1HasSchemaRequest">HasSchemaRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1HasSchemaResponse">HasSchemaResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Checks for the existence of a schema with the given name. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1HasSchemaRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1HasSchemaResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1HasSchemaResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#aca31db2984272fe8c75bfdde4f40cd0c">◆ </a></span>hasSchema() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1HasSchemaResponse">HasSchemaResponse</a> gpudb::GPUdb::hasSchema </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>schemaName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Checks for the existence of a schema with the given name. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>schemaName</td>
                <td>Name of the schema to check for existence, in root, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1HasSchemaResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a691e59e90b1fa45c6611a48eab718be4">◆ </a></span>hasSchema() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1HasSchemaResponse">HasSchemaResponse</a> & gpudb::GPUdb::hasSchema </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>schemaName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1HasSchemaResponse">HasSchemaResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Checks for the existence of a schema with the given name. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>schemaName</td>
                <td>Name of the schema to check for existence, in root, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1HasSchemaResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1HasSchemaResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#acba046e591d5e9cdb71dcc296a1a6587">◆ </a></span>hasTable() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1HasTableResponse">HasTableResponse</a> gpudb::GPUdb::hasTable </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1HasTableRequest">HasTableRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Checks for the existence of a table with the given name. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1HasTableRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1HasTableResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a4b9843b0949f80e4cbc339c926a9e7e9">◆ </a></span>hasTable() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1HasTableResponse">HasTableResponse</a> & gpudb::GPUdb::hasTable </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1HasTableRequest">HasTableRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1HasTableResponse">HasTableResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Checks for the existence of a table with the given name. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1HasTableRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1HasTableResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1HasTableResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#aac084e60db02e0e37e5070f8ff50d606">◆ </a></span>hasTable() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1HasTableResponse">HasTableResponse</a> gpudb::GPUdb::hasTable </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Checks for the existence of a table with the given name. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of the table to check for existence, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1HasTableResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a819aae2b606944d8b4aff38b4093e734">◆ </a></span>hasTable() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1HasTableResponse">HasTableResponse</a> & gpudb::GPUdb::hasTable </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1HasTableResponse">HasTableResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Checks for the existence of a table with the given name. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of the table to check for existence, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1HasTableResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1HasTableResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a70f01970c1caaccd6cf17b208a980b50">◆ </a></span>hasType() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1HasTypeResponse">HasTypeResponse</a> gpudb::GPUdb::hasType </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1HasTypeRequest">HasTypeRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Check for the existence of a type. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1HasTypeRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1HasTypeResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#aded925491b917a966762252dabd03fd8">◆ </a></span>hasType() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1HasTypeResponse">HasTypeResponse</a> & gpudb::GPUdb::hasType </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1HasTypeRequest">HasTypeRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1HasTypeResponse">HasTypeResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Check for the existence of a type. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1HasTypeRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1HasTypeResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1HasTypeResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a5bd2c473cda48e8ad94645326db866d1">◆ </a></span>hasType() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1HasTypeResponse">HasTypeResponse</a> gpudb::GPUdb::hasType </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>typeId</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Check for the existence of a type. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>typeId</td>
                <td>Id of the type returned in response to <a href="#a1698840c08d7212878c9c1dac3f94cfc">createType</a> request. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1HasTypeResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ab0b6cc8af193558e4b3ca0c3fa5ed78d">◆ </a></span>hasType() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1HasTypeResponse">HasTypeResponse</a> & gpudb::GPUdb::hasType </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>typeId</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1HasTypeResponse">HasTypeResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Check for the existence of a type. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>typeId</td>
                <td>Id of the type returned in response to <a href="#a1698840c08d7212878c9c1dac3f94cfc">createType</a> request. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1HasTypeResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1HasTypeResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ab6ab327611452cc777c159d202146997">◆ </a></span>insertRecords() <span>\[1/4]</span></h2>

    <div>
      <div>
        <div> template\<typename TRequest> </div>

        <table>
          <tr>
            <td>
              <table>
                <tr>
                  <td><a href="/content/api/cpp/structgpudb_1_1InsertRecordsResponse">InsertRecordsResponse</a> gpudb::GPUdb::insertRecords </td>
                  <td>(</td>
                  <td>const <a href="/content/api/cpp/structgpudb_1_1InsertRecordsRequest">InsertRecordsRequest</a>\< TRequest > &</td>
                  <td><span><span>request\_</span></span></td>
                  <td>)</td>
                  <td> const</td>
                </tr>
              </table>
            </td>

            <td> <span><span>inline</span></span> </td>
          </tr>
        </table>
      </div>

      <div>
        <p>Adds multiple records to the specified table. </p>
        <p>The operation is synchronous, meaning that a response will not be returned until all the records are fully inserted and available. The response payload provides the counts of the number of records actually inserted and/or updated, and can provide the unique identifier of each added record.</p>
        <p>The <a href="/content/api/cpp/structgpudb_1_1InsertRecordsRequest#a7e3bb3bd9d193ffc187517fa0e6bddcd">options</a> parameter can be used to customize this function's behavior.</p>
        <p>The <a href="/content/api/cpp/namespacegpudb#aced7e07b232676a8e62a6da2adc83110">update\_on\_existing\_pk</a> option specifies the record collision policy for inserting into a table with a <a href="/content/concepts/tables/#primary-keys">primary key</a>, but is ignored if no primary key exists.</p>
        <p>The <a href="/content/api/cpp/namespacegpudb#a856c802e8393a8a5771f4200845b3d00">return\_record\_ids</a> option indicates that the database should return the unique identifiers of inserted records.</p>

        <div>
          <div>Template Parameters</div>

          <div>
            <table>
              <tr>
                <td>TRequest</td>
                <td>The type of object being added.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1InsertRecordsRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1InsertRecordsResponse">Response</a> object containing the result of the operation. </div>
        </div>

        <p>Definition at line <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">36741</a> of file <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">GPUdb.hpp</a>.</p>
      </div>
    </div>

    <h2><span><a href="#ac584d020987d1dbfa77b1bf6f32e8ebf">◆ </a></span>insertRecords() <span>\[2/4]</span></h2>

    <div>
      <div>
        <div> template\<typename TRequest> </div>

        <table>
          <tr>
            <td>
              <table>
                <tr>
                  <td><a href="/content/api/cpp/structgpudb_1_1InsertRecordsResponse">InsertRecordsResponse</a> & gpudb::GPUdb::insertRecords </td>
                  <td>(</td>
                  <td>const <a href="/content/api/cpp/structgpudb_1_1InsertRecordsRequest">InsertRecordsRequest</a>\< TRequest > &</td>
                  <td><span><span>request\_</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td><a href="/content/api/cpp/structgpudb_1_1InsertRecordsResponse">InsertRecordsResponse</a> &</td>
                  <td><span><span>response\_</span></span> ) const</td>
                </tr>
              </table>
            </td>

            <td> <span><span>inline</span></span> </td>
          </tr>
        </table>
      </div>

      <div>
        <p>Adds multiple records to the specified table. </p>
        <p>The operation is synchronous, meaning that a response will not be returned until all the records are fully inserted and available. The response payload provides the counts of the number of records actually inserted and/or updated, and can provide the unique identifier of each added record.</p>
        <p>The <a href="/content/api/cpp/structgpudb_1_1InsertRecordsRequest#a7e3bb3bd9d193ffc187517fa0e6bddcd">options</a> parameter can be used to customize this function's behavior.</p>
        <p>The <a href="/content/api/cpp/namespacegpudb#aced7e07b232676a8e62a6da2adc83110">update\_on\_existing\_pk</a> option specifies the record collision policy for inserting into a table with a <a href="/content/concepts/tables/#primary-keys">primary key</a>, but is ignored if no primary key exists.</p>
        <p>The <a href="/content/api/cpp/namespacegpudb#a856c802e8393a8a5771f4200845b3d00">return\_record\_ids</a> option indicates that the database should return the unique identifiers of inserted records.</p>

        <div>
          <div>Template Parameters</div>

          <div>
            <table>
              <tr>
                <td>TRequest</td>
                <td>The type of object being added.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1InsertRecordsRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1InsertRecordsResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1InsertRecordsResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>

        <p>Definition at line <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">36782</a> of file <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">GPUdb.hpp</a>.</p>
      </div>
    </div>

    <h2><span><a href="#a1cbbfefa7a3d6b4570f1be6734a8d849">◆ </a></span>insertRecords() <span>\[3/4]</span></h2>

    <div>
      <div>
        <div> template\<typename TRequest> </div>

        <table>
          <tr>
            <td>
              <table>
                <tr>
                  <td><a href="/content/api/cpp/structgpudb_1_1InsertRecordsResponse">InsertRecordsResponse</a> gpudb::GPUdb::insertRecords </td>
                  <td>(</td>
                  <td>const std::string &</td>
                  <td><span><span>tableName</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const std::vector\< TRequest > &</td>
                  <td><span><span>data</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const std::map\< std::string, std::string > &</td>
                  <td><span><span>options</span></span> ) const</td>
                </tr>
              </table>
            </td>

            <td> <span><span>inline</span></span> </td>
          </tr>
        </table>
      </div>

      <div>
        <p>Adds multiple records to the specified table. </p>
        <p>The operation is synchronous, meaning that a response will not be returned until all the records are fully inserted and available. The response payload provides the counts of the number of records actually inserted and/or updated, and can provide the unique identifier of each added record.</p>
        <p>The <span>options</span> parameter can be used to customize this function's behavior.</p>
        <p>The <a href="/content/api/cpp/namespacegpudb#aced7e07b232676a8e62a6da2adc83110">update\_on\_existing\_pk</a> option specifies the record collision policy for inserting into a table with a <a href="/content/concepts/tables/#primary-keys">primary key</a>, but is ignored if no primary key exists.</p>
        <p>The <a href="/content/api/cpp/namespacegpudb#a856c802e8393a8a5771f4200845b3d00">return\_record\_ids</a> option indicates that the database should return the unique identifiers of inserted records.</p>

        <div>
          <div>Template Parameters</div>

          <div>
            <table>
              <tr>
                <td>TRequest</td>
                <td>The type of object being added.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of table to which the records are to be added, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. Must be an existing table. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>data</td>
                <td>An array of binary-encoded data for the records to be added. All records must be of the same type as that of the table. Empty array if <span>listEncoding</span> is <span>json</span>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#aced7e07b232676a8e62a6da2adc83110">insert\_records\_update\_on\_existing\_pk</a>: Specifies the record collision policy for inserting into a table with a <a href="/content/concepts/tables/#primary-keys">primary key</a>. If set to <a href="/content/api/cpp/namespacegpudb#a2e622343f394ec8057ae448aec6cf3b7">true</a>, any existing table record with primary key values that match those of a record being inserted will be replaced by that new record (the new data will be "upserted"). If set to <a href="/content/api/cpp/namespacegpudb#ac24439cf2e2fba1d969bcf941fdb7e38">false</a>, any existing table record with primary key values that match those of a record being inserted will remain unchanged, while the new record will be rejected and the error handled as determined by <a href="/content/api/cpp/namespacegpudb#ac54a9b457e65e7a4387c93a49071f164">ignore\_existing\_pk</a>, <a href="/content/api/cpp/namespacegpudb#abba4285a95a1175e47d97d33c94a6b5a">allow\_partial\_batch</a>, and <a href="/content/api/cpp/namespacegpudb#aba17bcf17be8ede74d65ad1375d777d2">return\_individual\_errors</a>. If the specified table does not have a primary key, then this option has no effect. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a2e622343f394ec8057ae448aec6cf3b7">insert\_records\_true</a>: Upsert new records when primary keys match existing records. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ac24439cf2e2fba1d969bcf941fdb7e38">insert\_records\_false</a>: Reject new records when primary keys match existing records. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ac24439cf2e2fba1d969bcf941fdb7e38">insert\_records\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a8aa572a7b0774e3a668e67ec7e1a6205">insert\_records\_enable\_inplace\_updates</a>: Applies only when upserting (when <a href="/content/api/cpp/namespacegpudb#aced7e07b232676a8e62a6da2adc83110">update\_on\_existing\_pk</a> is <a href="/content/api/cpp/namespacegpudb#a2e622343f394ec8057ae448aec6cf3b7">true</a>). If set to <a href="/content/api/cpp/namespacegpudb#a2e622343f394ec8057ae448aec6cf3b7">true</a>, an existing record matched by primary key is modified in place. If set to <a href="/content/api/cpp/namespacegpudb#ac24439cf2e2fba1d969bcf941fdb7e38">false</a>, it is updated by deleting the existing record and inserting a replacement (delete and insert), which prevents the change from being reflected in dependent materialized views until they are refreshed. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a2e622343f394ec8057ae448aec6cf3b7">insert\_records\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ac24439cf2e2fba1d969bcf941fdb7e38">insert\_records\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a2e622343f394ec8057ae448aec6cf3b7">insert\_records\_true</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ac54a9b457e65e7a4387c93a49071f164">insert\_records\_ignore\_existing\_pk</a>: Specifies the record collision error-suppression policy for inserting into a table with a <a href="/content/concepts/tables/#primary-keys">primary key</a>, only used when not in upsert mode (upsert mode is disabled when <a href="/content/api/cpp/namespacegpudb#aced7e07b232676a8e62a6da2adc83110">update\_on\_existing\_pk</a> is <a href="/content/api/cpp/namespacegpudb#ac24439cf2e2fba1d969bcf941fdb7e38">false</a>). If set to <a href="/content/api/cpp/namespacegpudb#a2e622343f394ec8057ae448aec6cf3b7">true</a>, any record being inserted that is rejected for having primary key values that match those of an existing table record will be ignored with no error generated. If <a href="/content/api/cpp/namespacegpudb#ac24439cf2e2fba1d969bcf941fdb7e38">false</a>, the rejection of any record for having primary key values matching an existing record will result in an error being reported, as determined by <a href="/content/api/cpp/namespacegpudb#abba4285a95a1175e47d97d33c94a6b5a">allow\_partial\_batch</a> and <a href="/content/api/cpp/namespacegpudb#aba17bcf17be8ede74d65ad1375d777d2">return\_individual\_errors</a>. If the specified table does not have a primary key or if upsert mode is in effect (<a href="/content/api/cpp/namespacegpudb#aced7e07b232676a8e62a6da2adc83110">update\_on\_existing\_pk</a> is <a href="/content/api/cpp/namespacegpudb#a2e622343f394ec8057ae448aec6cf3b7">true</a>), then this option has no effect. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a2e622343f394ec8057ae448aec6cf3b7">insert\_records\_true</a>: Ignore new records whose primary key values collide with those of existing records. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ac24439cf2e2fba1d969bcf941fdb7e38">insert\_records\_false</a>: Treat as errors any new records whose primary key values collide with those of existing records. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ac24439cf2e2fba1d969bcf941fdb7e38">insert\_records\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a4273dd6e4cab34f09509b6f2e02c59d1">insert\_records\_pk\_conflict\_predicate\_higher</a>: The record with higher value for the column resolves the primary-key insert conflict. The default value is ''. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a2f863c979be67366d1a00b131b7317b2">insert\_records\_pk\_conflict\_predicate\_lower</a>: The record with lower value for the column resolves the primary-key insert conflict. The default value is ''. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a856c802e8393a8a5771f4200845b3d00">insert\_records\_return\_record\_ids</a>: If <a href="/content/api/cpp/namespacegpudb#a2e622343f394ec8057ae448aec6cf3b7">true</a> then return the internal record id along for each inserted record. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a2e622343f394ec8057ae448aec6cf3b7">insert\_records\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ac24439cf2e2fba1d969bcf941fdb7e38">insert\_records\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ac24439cf2e2fba1d969bcf941fdb7e38">insert\_records\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a1ad916b3df48e7fb54e4fb87d9b5e6b8">insert\_records\_truncate\_strings</a>: If set to <a href="/content/api/cpp/namespacegpudb#a2e622343f394ec8057ae448aec6cf3b7">true</a>, any strings which are too long for their target charN string columns will be truncated to fit. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a2e622343f394ec8057ae448aec6cf3b7">insert\_records\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ac24439cf2e2fba1d969bcf941fdb7e38">insert\_records\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ac24439cf2e2fba1d969bcf941fdb7e38">insert\_records\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#aba17bcf17be8ede74d65ad1375d777d2">insert\_records\_return\_individual\_errors</a>: If set to <a href="/content/api/cpp/namespacegpudb#a2e622343f394ec8057ae448aec6cf3b7">true</a>, success will always be returned, and any errors found will be included in the info map. The "bad\_record\_indices" entry is a comma-separated list of bad records (0-based). If so, there will also be an "error\_N" entry for each record with an error, where N is the index (0-based). Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a2e622343f394ec8057ae448aec6cf3b7">insert\_records\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ac24439cf2e2fba1d969bcf941fdb7e38">insert\_records\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ac24439cf2e2fba1d969bcf941fdb7e38">insert\_records\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#abba4285a95a1175e47d97d33c94a6b5a">insert\_records\_allow\_partial\_batch</a>: If set to <a href="/content/api/cpp/namespacegpudb#a2e622343f394ec8057ae448aec6cf3b7">true</a>, all correct records will be inserted and incorrect records will be rejected and reported. Otherwise, the entire batch will be rejected if any records are incorrect. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a2e622343f394ec8057ae448aec6cf3b7">insert\_records\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ac24439cf2e2fba1d969bcf941fdb7e38">insert\_records\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ac24439cf2e2fba1d969bcf941fdb7e38">insert\_records\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#aa802d8642645f3a89f01d5e2a242d965">insert\_records\_error\_handling</a>: Specifies how errors should be handled upon insertion. When set, this option is authoritative; supplying a contradictory <a href="/content/api/cpp/namespacegpudb#abba4285a95a1175e47d97d33c94a6b5a">allow\_partial\_batch</a> is an error. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a5846f621934ff465b48c15e716ccfffe">insert\_records\_permissive</a>: Records with bad column values are kept when possible: the offending column is filled with its default value if one exists, otherwise with null if the column is nullable; if neither is possible the record is skipped and reported. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a5a3d91cf270f4df6133d75de35d78eda">insert\_records\_skip</a>: Records with bad values are skipped and reported; the rest of the batch is inserted. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a1da193371ef8fe19d31104450b43ce74">insert\_records\_abort</a>: Stops the insertion and rejects the remaining batch when any record is incorrect. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a1da193371ef8fe19d31104450b43ce74">insert\_records\_abort</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a7ab1597e0af17babdda721618006804f">insert\_records\_dry\_run</a>: If set to <a href="/content/api/cpp/namespacegpudb#a2e622343f394ec8057ae448aec6cf3b7">true</a>, no data will be saved and any errors will be returned. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a2e622343f394ec8057ae448aec6cf3b7">insert\_records\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ac24439cf2e2fba1d969bcf941fdb7e38">insert\_records\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ac24439cf2e2fba1d969bcf941fdb7e38">insert\_records\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a1ac05f91f3b11299f75149f4e4bbb353">insert\_records\_request\_schema\_str</a>: <a href="/content/api/cpp/classgpudb_1_1Type">Type</a> schema of <span>data</span> (when <span>listEncoding</span> is <span>binary</span>), in \[\["column\_name","column\_type"]] format. When non-empty and different from the table's schema, the server remaps the incoming records to the table's full schema. Columns present in the table but absent from this schema are filled using their default values, NULL (if nullable), or an error is returned. If empty, records must match the table's full schema. The default value is ''. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a74bae75d7f409a4e951152a4e83c3e63">insert\_records\_transformations</a>: Comma-separated expressions, one per target table column. Each expression is evaluated per record. Empty entries (two consecutive commas) mean no transformation for that column – the value is resolved from the input record, table default, NULL, or an error. Expressions may reference input columns by name or by position ($1 for the first input column, $2 for the second, etc.). The default value is ''. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1InsertRecordsResponse">Response</a> object containing the result of the operation. </div>
        </div>

        <p>Definition at line <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">37082</a> of file <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">GPUdb.hpp</a>.</p>
      </div>
    </div>

    <h2><span><a href="#a19ca29162fd0ce0fe1993ff791bcca4f">◆ </a></span>insertRecords() <span>\[4/4]</span></h2>

    <div>
      <div>
        <div> template\<typename TRequest> </div>

        <table>
          <tr>
            <td>
              <table>
                <tr>
                  <td><a href="/content/api/cpp/structgpudb_1_1InsertRecordsResponse">InsertRecordsResponse</a> & gpudb::GPUdb::insertRecords </td>
                  <td>(</td>
                  <td>const std::string &</td>
                  <td><span><span>tableName</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const std::vector\< TRequest > &</td>
                  <td><span><span>data</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const std::map\< std::string, std::string > &</td>
                  <td><span><span>options</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td><a href="/content/api/cpp/structgpudb_1_1InsertRecordsResponse">InsertRecordsResponse</a> &</td>
                  <td><span><span>response\_</span></span> ) const</td>
                </tr>
              </table>
            </td>

            <td> <span><span>inline</span></span> </td>
          </tr>
        </table>
      </div>

      <div>
        <p>Adds multiple records to the specified table. </p>
        <p>The operation is synchronous, meaning that a response will not be returned until all the records are fully inserted and available. The response payload provides the counts of the number of records actually inserted and/or updated, and can provide the unique identifier of each added record.</p>
        <p>The <span>options</span> parameter can be used to customize this function's behavior.</p>
        <p>The <a href="/content/api/cpp/namespacegpudb#aced7e07b232676a8e62a6da2adc83110">update\_on\_existing\_pk</a> option specifies the record collision policy for inserting into a table with a <a href="/content/concepts/tables/#primary-keys">primary key</a>, but is ignored if no primary key exists.</p>
        <p>The <a href="/content/api/cpp/namespacegpudb#a856c802e8393a8a5771f4200845b3d00">return\_record\_ids</a> option indicates that the database should return the unique identifiers of inserted records.</p>

        <div>
          <div>Template Parameters</div>

          <div>
            <table>
              <tr>
                <td>TRequest</td>
                <td>The type of object being added.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of table to which the records are to be added, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. Must be an existing table. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>data</td>
                <td>An array of binary-encoded data for the records to be added. All records must be of the same type as that of the table. Empty array if <span>listEncoding</span> is <span>json</span>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#aced7e07b232676a8e62a6da2adc83110">insert\_records\_update\_on\_existing\_pk</a>: Specifies the record collision policy for inserting into a table with a <a href="/content/concepts/tables/#primary-keys">primary key</a>. If set to <a href="/content/api/cpp/namespacegpudb#a2e622343f394ec8057ae448aec6cf3b7">true</a>, any existing table record with primary key values that match those of a record being inserted will be replaced by that new record (the new data will be "upserted"). If set to <a href="/content/api/cpp/namespacegpudb#ac24439cf2e2fba1d969bcf941fdb7e38">false</a>, any existing table record with primary key values that match those of a record being inserted will remain unchanged, while the new record will be rejected and the error handled as determined by <a href="/content/api/cpp/namespacegpudb#ac54a9b457e65e7a4387c93a49071f164">ignore\_existing\_pk</a>, <a href="/content/api/cpp/namespacegpudb#abba4285a95a1175e47d97d33c94a6b5a">allow\_partial\_batch</a>, and <a href="/content/api/cpp/namespacegpudb#aba17bcf17be8ede74d65ad1375d777d2">return\_individual\_errors</a>. If the specified table does not have a primary key, then this option has no effect. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a2e622343f394ec8057ae448aec6cf3b7">insert\_records\_true</a>: Upsert new records when primary keys match existing records. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ac24439cf2e2fba1d969bcf941fdb7e38">insert\_records\_false</a>: Reject new records when primary keys match existing records. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ac24439cf2e2fba1d969bcf941fdb7e38">insert\_records\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a8aa572a7b0774e3a668e67ec7e1a6205">insert\_records\_enable\_inplace\_updates</a>: Applies only when upserting (when <a href="/content/api/cpp/namespacegpudb#aced7e07b232676a8e62a6da2adc83110">update\_on\_existing\_pk</a> is <a href="/content/api/cpp/namespacegpudb#a2e622343f394ec8057ae448aec6cf3b7">true</a>). If set to <a href="/content/api/cpp/namespacegpudb#a2e622343f394ec8057ae448aec6cf3b7">true</a>, an existing record matched by primary key is modified in place. If set to <a href="/content/api/cpp/namespacegpudb#ac24439cf2e2fba1d969bcf941fdb7e38">false</a>, it is updated by deleting the existing record and inserting a replacement (delete and insert), which prevents the change from being reflected in dependent materialized views until they are refreshed. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a2e622343f394ec8057ae448aec6cf3b7">insert\_records\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ac24439cf2e2fba1d969bcf941fdb7e38">insert\_records\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a2e622343f394ec8057ae448aec6cf3b7">insert\_records\_true</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ac54a9b457e65e7a4387c93a49071f164">insert\_records\_ignore\_existing\_pk</a>: Specifies the record collision error-suppression policy for inserting into a table with a <a href="/content/concepts/tables/#primary-keys">primary key</a>, only used when not in upsert mode (upsert mode is disabled when <a href="/content/api/cpp/namespacegpudb#aced7e07b232676a8e62a6da2adc83110">update\_on\_existing\_pk</a> is <a href="/content/api/cpp/namespacegpudb#ac24439cf2e2fba1d969bcf941fdb7e38">false</a>). If set to <a href="/content/api/cpp/namespacegpudb#a2e622343f394ec8057ae448aec6cf3b7">true</a>, any record being inserted that is rejected for having primary key values that match those of an existing table record will be ignored with no error generated. If <a href="/content/api/cpp/namespacegpudb#ac24439cf2e2fba1d969bcf941fdb7e38">false</a>, the rejection of any record for having primary key values matching an existing record will result in an error being reported, as determined by <a href="/content/api/cpp/namespacegpudb#abba4285a95a1175e47d97d33c94a6b5a">allow\_partial\_batch</a> and <a href="/content/api/cpp/namespacegpudb#aba17bcf17be8ede74d65ad1375d777d2">return\_individual\_errors</a>. If the specified table does not have a primary key or if upsert mode is in effect (<a href="/content/api/cpp/namespacegpudb#aced7e07b232676a8e62a6da2adc83110">update\_on\_existing\_pk</a> is <a href="/content/api/cpp/namespacegpudb#a2e622343f394ec8057ae448aec6cf3b7">true</a>), then this option has no effect. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a2e622343f394ec8057ae448aec6cf3b7">insert\_records\_true</a>: Ignore new records whose primary key values collide with those of existing records. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ac24439cf2e2fba1d969bcf941fdb7e38">insert\_records\_false</a>: Treat as errors any new records whose primary key values collide with those of existing records. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ac24439cf2e2fba1d969bcf941fdb7e38">insert\_records\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a4273dd6e4cab34f09509b6f2e02c59d1">insert\_records\_pk\_conflict\_predicate\_higher</a>: The record with higher value for the column resolves the primary-key insert conflict. The default value is ''. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a2f863c979be67366d1a00b131b7317b2">insert\_records\_pk\_conflict\_predicate\_lower</a>: The record with lower value for the column resolves the primary-key insert conflict. The default value is ''. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a856c802e8393a8a5771f4200845b3d00">insert\_records\_return\_record\_ids</a>: If <a href="/content/api/cpp/namespacegpudb#a2e622343f394ec8057ae448aec6cf3b7">true</a> then return the internal record id along for each inserted record. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a2e622343f394ec8057ae448aec6cf3b7">insert\_records\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ac24439cf2e2fba1d969bcf941fdb7e38">insert\_records\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ac24439cf2e2fba1d969bcf941fdb7e38">insert\_records\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a1ad916b3df48e7fb54e4fb87d9b5e6b8">insert\_records\_truncate\_strings</a>: If set to <a href="/content/api/cpp/namespacegpudb#a2e622343f394ec8057ae448aec6cf3b7">true</a>, any strings which are too long for their target charN string columns will be truncated to fit. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a2e622343f394ec8057ae448aec6cf3b7">insert\_records\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ac24439cf2e2fba1d969bcf941fdb7e38">insert\_records\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ac24439cf2e2fba1d969bcf941fdb7e38">insert\_records\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#aba17bcf17be8ede74d65ad1375d777d2">insert\_records\_return\_individual\_errors</a>: If set to <a href="/content/api/cpp/namespacegpudb#a2e622343f394ec8057ae448aec6cf3b7">true</a>, success will always be returned, and any errors found will be included in the info map. The "bad\_record\_indices" entry is a comma-separated list of bad records (0-based). If so, there will also be an "error\_N" entry for each record with an error, where N is the index (0-based). Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a2e622343f394ec8057ae448aec6cf3b7">insert\_records\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ac24439cf2e2fba1d969bcf941fdb7e38">insert\_records\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ac24439cf2e2fba1d969bcf941fdb7e38">insert\_records\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#abba4285a95a1175e47d97d33c94a6b5a">insert\_records\_allow\_partial\_batch</a>: If set to <a href="/content/api/cpp/namespacegpudb#a2e622343f394ec8057ae448aec6cf3b7">true</a>, all correct records will be inserted and incorrect records will be rejected and reported. Otherwise, the entire batch will be rejected if any records are incorrect. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a2e622343f394ec8057ae448aec6cf3b7">insert\_records\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ac24439cf2e2fba1d969bcf941fdb7e38">insert\_records\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ac24439cf2e2fba1d969bcf941fdb7e38">insert\_records\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#aa802d8642645f3a89f01d5e2a242d965">insert\_records\_error\_handling</a>: Specifies how errors should be handled upon insertion. When set, this option is authoritative; supplying a contradictory <a href="/content/api/cpp/namespacegpudb#abba4285a95a1175e47d97d33c94a6b5a">allow\_partial\_batch</a> is an error. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a5846f621934ff465b48c15e716ccfffe">insert\_records\_permissive</a>: Records with bad column values are kept when possible: the offending column is filled with its default value if one exists, otherwise with null if the column is nullable; if neither is possible the record is skipped and reported. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a5a3d91cf270f4df6133d75de35d78eda">insert\_records\_skip</a>: Records with bad values are skipped and reported; the rest of the batch is inserted. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a1da193371ef8fe19d31104450b43ce74">insert\_records\_abort</a>: Stops the insertion and rejects the remaining batch when any record is incorrect. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a1da193371ef8fe19d31104450b43ce74">insert\_records\_abort</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a7ab1597e0af17babdda721618006804f">insert\_records\_dry\_run</a>: If set to <a href="/content/api/cpp/namespacegpudb#a2e622343f394ec8057ae448aec6cf3b7">true</a>, no data will be saved and any errors will be returned. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a2e622343f394ec8057ae448aec6cf3b7">insert\_records\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ac24439cf2e2fba1d969bcf941fdb7e38">insert\_records\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ac24439cf2e2fba1d969bcf941fdb7e38">insert\_records\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a1ac05f91f3b11299f75149f4e4bbb353">insert\_records\_request\_schema\_str</a>: <a href="/content/api/cpp/classgpudb_1_1Type">Type</a> schema of <span>data</span> (when <span>listEncoding</span> is <span>binary</span>), in \[\["column\_name","column\_type"]] format. When non-empty and different from the table's schema, the server remaps the incoming records to the table's full schema. Columns present in the table but absent from this schema are filled using their default values, NULL (if nullable), or an error is returned. If empty, records must match the table's full schema. The default value is ''. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a74bae75d7f409a4e951152a4e83c3e63">insert\_records\_transformations</a>: Comma-separated expressions, one per target table column. Each expression is evaluated per record. Empty entries (two consecutive commas) mean no transformation for that column – the value is resolved from the input record, table default, NULL, or an error. Expressions may reference input columns by name or by position ($1 for the first input column, $2 for the second, etc.). The default value is ''. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1InsertRecordsResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1InsertRecordsResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>

        <p>Definition at line <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">37386</a> of file <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">GPUdb.hpp</a>.</p>
      </div>
    </div>

    <h2><span><a href="#a03fd9d3a6a56088c1ce707c642c9c736">◆ </a></span>insertRecordsFromFiles() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1InsertRecordsFromFilesResponse">InsertRecordsFromFilesResponse</a> gpudb::GPUdb::insertRecordsFromFiles </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1InsertRecordsFromFilesRequest">InsertRecordsFromFilesRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Reads from one or more files and inserts the data into a new or existing table. </p>
        <p>The source data can be located either in <a href="/content/tools/kifs/">KiFS</a>; on the cluster, accessible to the database; or remotely, accessible via a pre-defined external <a href="/content/concepts/data_sources/">data source</a>.</p>
        <p>For delimited text files, there are two loading schemes: positional and name-based. The name-based loading scheme is enabled when the file has a header present and <a href="/content/api/cpp/namespacegpudb#ab234ce6680f377661f1759b39210f242">text\_has\_header</a> is set to <a href="/content/api/cpp/namespacegpudb#ad58bb28eb5e7272a1e135c544b07776e">true</a>. In this scheme, the source file(s) field names must match the target table's column names exactly; however, the source file can have more fields than the target table has columns. If <a href="/content/api/cpp/namespacegpudb#ac7886929e3d552f763cd09a54ed30d2e">error\_handling</a> is set to <a href="/content/api/cpp/namespacegpudb#af8be89f360cd5e95ba91c40978391415">permissive</a>, the source file can have fewer fields than the target table has columns. If the name-based loading scheme is being used, names matching the file header's names may be provided to <a href="/content/api/cpp/namespacegpudb#aa34d6374fb7a0bf79109a98d7aa96983">columns\_to\_load</a> instead of numbers, but ranges are not supported.</p>
        <p>Note: Due to data being loaded in parallel, there is no insertion order guaranteed. For tables with primary keys, in the case of a primary key collision, this means it is indeterminate which record will be inserted first and remain, while the rest of the colliding key records are discarded.</p>
        <p>Returns once all files are processed.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1InsertRecordsFromFilesRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1InsertRecordsFromFilesResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a3a8b0729508c7543c177436086334564">◆ </a></span>insertRecordsFromFiles() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1InsertRecordsFromFilesResponse">InsertRecordsFromFilesResponse</a> & gpudb::GPUdb::insertRecordsFromFiles </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1InsertRecordsFromFilesRequest">InsertRecordsFromFilesRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1InsertRecordsFromFilesResponse">InsertRecordsFromFilesResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Reads from one or more files and inserts the data into a new or existing table. </p>
        <p>The source data can be located either in <a href="/content/tools/kifs/">KiFS</a>; on the cluster, accessible to the database; or remotely, accessible via a pre-defined external <a href="/content/concepts/data_sources/">data source</a>.</p>
        <p>For delimited text files, there are two loading schemes: positional and name-based. The name-based loading scheme is enabled when the file has a header present and <a href="/content/api/cpp/namespacegpudb#ab234ce6680f377661f1759b39210f242">text\_has\_header</a> is set to <a href="/content/api/cpp/namespacegpudb#ad58bb28eb5e7272a1e135c544b07776e">true</a>. In this scheme, the source file(s) field names must match the target table's column names exactly; however, the source file can have more fields than the target table has columns. If <a href="/content/api/cpp/namespacegpudb#ac7886929e3d552f763cd09a54ed30d2e">error\_handling</a> is set to <a href="/content/api/cpp/namespacegpudb#af8be89f360cd5e95ba91c40978391415">permissive</a>, the source file can have fewer fields than the target table has columns. If the name-based loading scheme is being used, names matching the file header's names may be provided to <a href="/content/api/cpp/namespacegpudb#aa34d6374fb7a0bf79109a98d7aa96983">columns\_to\_load</a> instead of numbers, but ranges are not supported.</p>
        <p>Note: Due to data being loaded in parallel, there is no insertion order guaranteed. For tables with primary keys, in the case of a primary key collision, this means it is indeterminate which record will be inserted first and remain, while the rest of the colliding key records are discarded.</p>
        <p>Returns once all files are processed.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1InsertRecordsFromFilesRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1InsertRecordsFromFilesResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1InsertRecordsFromFilesResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a2a25d6161cbe8ecaa88bed607c04821b">◆ </a></span>insertRecordsFromFiles() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1InsertRecordsFromFilesResponse">InsertRecordsFromFilesResponse</a> gpudb::GPUdb::insertRecordsFromFiles </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< std::string > &</td>
            <td><span><span>filepaths</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::map\< std::string, std::string > > &</td>
            <td><span><span>modifyColumns</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>createTableOptions</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Reads from one or more files and inserts the data into a new or existing table. </p>
        <p>The source data can be located either in <a href="/content/tools/kifs/">KiFS</a>; on the cluster, accessible to the database; or remotely, accessible via a pre-defined external <a href="/content/concepts/data_sources/">data source</a>.</p>
        <p>For delimited text files, there are two loading schemes: positional and name-based. The name-based loading scheme is enabled when the file has a header present and <a href="/content/api/cpp/namespacegpudb#ab234ce6680f377661f1759b39210f242">text\_has\_header</a> is set to <a href="/content/api/cpp/namespacegpudb#ad58bb28eb5e7272a1e135c544b07776e">true</a>. In this scheme, the source file(s) field names must match the target table's column names exactly; however, the source file can have more fields than the target table has columns. If <a href="/content/api/cpp/namespacegpudb#ac7886929e3d552f763cd09a54ed30d2e">error\_handling</a> is set to <a href="/content/api/cpp/namespacegpudb#af8be89f360cd5e95ba91c40978391415">permissive</a>, the source file can have fewer fields than the target table has columns. If the name-based loading scheme is being used, names matching the file header's names may be provided to <a href="/content/api/cpp/namespacegpudb#aa34d6374fb7a0bf79109a98d7aa96983">columns\_to\_load</a> instead of numbers, but ranges are not supported.</p>
        <p>Note: Due to data being loaded in parallel, there is no insertion order guaranteed. For tables with primary keys, in the case of a primary key collision, this means it is indeterminate which record will be inserted first and remain, while the rest of the colliding key records are discarded.</p>
        <p>Returns once all files are processed.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of the table into which the data will be inserted, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. If the table does not exist, the table will be created using either an existing <a href="/content/api/cpp/namespacegpudb#a315d4ef68c44fbf43b0c66f491e6c5d1">type\_id</a> or the type inferred from the file, and the new table name will have to meet standard <a href="/content/concepts/tables/#table-naming-criteria">table naming criteria</a>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>filepaths</td>
                <td>A list of file paths from which data will be sourced; For paths in <a href="/content/tools/kifs/">KiFS</a>, use the URI prefix of kifs\:// followed by the path to a file or directory. File matching by prefix is supported, e.g. kifs\://dir/file would match dir/file\_1 and dir/file\_2. When prefix matching is used, the path must start with a full, valid KiFS directory name. If an external data source is specified in <a href="/content/api/cpp/namespacegpudb#a715ab62c16af690e60749b84681dc949">datasource\_name</a>, these file paths must resolve to accessible files at that data source location. Prefix matching is supported. If the data source is hdfs, prefixes must be aligned with directories, i.e. partial file names will not match. If no data source is specified, the files are assumed to be local to the database and must all be accessible to the gpudb user, residing on the path (or relative to the path) specified by the external files directory in the Kinetica <a href="/content/config/#config-main-external-files">configuration file</a>. Wildcards (\*) can be used to specify a group of files. Prefix matching is supported, the prefixes must be aligned with directories. If the first path ends in .tsv, the text delimiter will be defaulted to a tab character. If the first path ends in .psv, the text delimiter will be defaulted to a pipe character (|). </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>modifyColumns</td>
                <td>Not implemented yet. The default value is an empty map. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>createTableOptions</td>

                <td>
                  <a href="/content/api/cpp/classgpudb_1_1GPUdb_1_1Options">Options</a> from <a href="#afa4ded9fdb07b49b4b1cb0835b5ac52a">createTable</a>, allowing the structure of the table to be defined independently of the data source, when creating the target table.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a315d4ef68c44fbf43b0c66f491e6c5d1">insert\_records\_from\_files\_type\_id</a>: ID of a currently registered <a href="/content/concepts/types/">type</a>. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ae62e946b7b1c91596cfbf36980918858">insert\_records\_from\_files\_no\_error\_if\_exists</a>: If <a href="/content/api/cpp/namespacegpudb#ad58bb28eb5e7272a1e135c544b07776e">true</a>, prevents an error from occurring if the table already exists and is of the given type. If a table with the same name but a different type exists, it is still an error. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad58bb28eb5e7272a1e135c544b07776e">insert\_records\_from\_files\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a3776c76d5b4e24922af4c329863e6ea3">insert\_records\_from\_files\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a3776c76d5b4e24922af4c329863e6ea3">insert\_records\_from\_files\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a594faaa30551f0af50e243b3a3691f05">insert\_records\_from\_files\_is\_replicated</a>: Affects the <a href="/content/concepts/tables/#distribution">distribution scheme</a> for the table's data. If <a href="/content/api/cpp/namespacegpudb#ad58bb28eb5e7272a1e135c544b07776e">true</a> and the given table has no explicit <a href="/content/concepts/tables/#shard-key">shard key</a> defined, the table will be <a href="/content/concepts/tables/#replication">replicated</a>. If <a href="/content/api/cpp/namespacegpudb#a3776c76d5b4e24922af4c329863e6ea3">false</a>, the table will be <a href="/content/concepts/tables/#sharding">sharded</a> according to the shard key specified in the given <a href="/content/api/cpp/namespacegpudb#a315d4ef68c44fbf43b0c66f491e6c5d1">type\_id</a>, or <a href="/content/concepts/tables/#random-sharding">randomly sharded</a>, if no shard key is specified. Note that a type containing a shard key cannot be used to create a replicated table. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad58bb28eb5e7272a1e135c544b07776e">insert\_records\_from\_files\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a3776c76d5b4e24922af4c329863e6ea3">insert\_records\_from\_files\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a3776c76d5b4e24922af4c329863e6ea3">insert\_records\_from\_files\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a8362ac091da6d0f2a4338690ee010825">insert\_records\_from\_files\_foreign\_keys</a>: Semicolon-separated list of <a href="/content/concepts/tables/#foreign-keys">foreign keys</a>, of the format '(source\_column\_name \[, ...]) references target\_table\_name(primary\_key\_column\_name \[, ...]) \[as foreign\_key\_name]'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a807c40696d5e465c0bec8421328963e3">insert\_records\_from\_files\_foreign\_shard\_key</a>: Foreign shard key of the format 'source\_column references shard\_by\_column from target\_table(primary\_key\_column)'. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a985f93e21b2780772c837842d7177612">insert\_records\_from\_files\_partition\_type</a>: <a href="/content/concepts/tables/#partitioning">Partitioning</a> scheme to use. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a0862003fdd8b6ec9b01edf53304d9d1f">insert\_records\_from\_files\_RANGE</a>: Use <a href="/content/concepts/tables/#partitioning-by-range">range partitioning</a>. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a7d15cd0d8c9811c850bdbe03f27db26d">insert\_records\_from\_files\_INTERVAL</a>: Use <a href="/content/concepts/tables/#partitioning-by-interval">interval partitioning</a>. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#accbc3118051b91dcf43fd6656a17674d">insert\_records\_from\_files\_LIST</a>: Use <a href="/content/concepts/tables/#partitioning-by-list">list partitioning</a>. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a3ad2df5e9be8cbf2de26ac1c0372a90d">insert\_records\_from\_files\_HASH</a>: Use <a href="/content/concepts/tables/#partitioning-by-hash">hash partitioning</a>. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a222778675ef4124a150567eed913d6eb">insert\_records\_from\_files\_SERIES</a>: Use <a href="/content/concepts/tables/#partitioning-by-series">series partitioning</a>. </li>
                      </ul>
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a2ac300786c2a60854ab066a02601db01">insert\_records\_from\_files\_partition\_keys</a>: Comma-separated list of partition keys, which are the columns or column expressions by which records will be assigned to partitions defined by <a href="/content/api/cpp/namespacegpudb#ae4baea68bd51cfc4ce99f955ecf574db">partition\_definitions</a>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ae4baea68bd51cfc4ce99f955ecf574db">insert\_records\_from\_files\_partition\_definitions</a>: Comma-separated list of partition definitions, whose format depends on the choice of <a href="/content/api/cpp/namespacegpudb#a985f93e21b2780772c837842d7177612">partition\_type</a>. See <a href="/content/concepts/tables/#partitioning-by-range">range partitioning</a>, <a href="/content/concepts/tables/#partitioning-by-interval">interval partitioning</a>, <a href="/content/concepts/tables/#partitioning-by-list">list partitioning</a>, <a href="/content/concepts/tables/#partitioning-by-hash">hash partitioning</a>, or <a href="/content/concepts/tables/#partitioning-by-series">series partitioning</a> for example formats. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ada3f83249e94e4ec1a61d5f3e48c9838">insert\_records\_from\_files\_is\_automatic\_partition</a>: If <a href="/content/api/cpp/namespacegpudb#ad58bb28eb5e7272a1e135c544b07776e">true</a>, a new partition will be created for values which don't fall into an existing partition. Currently, only supported for <a href="/content/concepts/tables/#partitioning-by-list">list partitions</a>. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad58bb28eb5e7272a1e135c544b07776e">insert\_records\_from\_files\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a3776c76d5b4e24922af4c329863e6ea3">insert\_records\_from\_files\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a3776c76d5b4e24922af4c329863e6ea3">insert\_records\_from\_files\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#aa4f43afd416ea25c890fbe59decaf768">insert\_records\_from\_files\_ttl</a>: Sets the <a href="/content/concepts/ttl/">TTL</a> of the table specified in <span>tableName</span>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a2295d3e0ae0cf497a76619b793ab8844">insert\_records\_from\_files\_chunk\_size</a>: Indicates the number of records per chunk to be used for this table. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a5b8872cccd87f7cb9439f765d857068c">insert\_records\_from\_files\_chunk\_column\_max\_memory</a>: Indicates the target maximum data size for each column in a chunk to be used for this table. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aba833d54ccdab5fc825a2c9d4eb23cac">insert\_records\_from\_files\_chunk\_max\_memory</a>: Indicates the target maximum data size for all columns in a chunk to be used for this table. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#abdc169744d47f174b446e434573e35b4">insert\_records\_from\_files\_is\_result\_table</a>: Indicates whether the table is a <a href="/content/concepts/tables_memory_only/">memory-only table</a>. A result table cannot contain columns with text\_search <a href="/content/concepts/types/#data-handling">data-handling</a>, and it will not be retained if the server is restarted. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad58bb28eb5e7272a1e135c544b07776e">insert\_records\_from\_files\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a3776c76d5b4e24922af4c329863e6ea3">insert\_records\_from\_files\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a3776c76d5b4e24922af4c329863e6ea3">insert\_records\_from\_files\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a1a7a1a1ea4d2002f074b0edc492d8a2c">insert\_records\_from\_files\_strategy\_definition</a>: The <a href="/content/rm/concepts/#tier-strategies">tier strategy</a> for the table and its columns. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a5c8e3812cb8e1e821b12a106b3758a2d">insert\_records\_from\_files\_compression\_codec</a>: The default <a href="/content/concepts/column_compression/">compression codec</a> for this table's columns. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a19e5fa0b272577b4da1034f50bd4f805">insert\_records\_from\_files\_bad\_record\_table\_name</a>: Name of a table to which records that were rejected are written. The bad-record-table has the following columns: line\_number (long), line\_rejected (string), error\_message (string). When <a href="/content/api/cpp/namespacegpudb#ac7886929e3d552f763cd09a54ed30d2e">error\_handling</a> is <a href="/content/api/cpp/namespacegpudb#a01cdf8f671e47432458c62110c2836e5">abort</a>, bad records table is not populated. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a0839191e6a9db565fba911a5d2af1eae">insert\_records\_from\_files\_bad\_record\_table\_limit</a>: A positive integer indicating the maximum number of records that can be written to the bad-record-table. The default value is '10000'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a51bea12f5ca4816838894d3852a3ccb2">insert\_records\_from\_files\_bad\_record\_table\_limit\_per\_input</a>: For subscriptions, a positive integer indicating the maximum number of records that can be written to the bad-record-table per file/payload. Default value will be <a href="/content/api/cpp/namespacegpudb#a0839191e6a9db565fba911a5d2af1eae">bad\_record\_table\_limit</a> and total size of the table per rank is limited to <a href="/content/api/cpp/namespacegpudb#a0839191e6a9db565fba911a5d2af1eae">bad\_record\_table\_limit</a>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a068cbf9ef07dfe11f3b0069d8bae67fc">insert\_records\_from\_files\_batch\_size</a>: Number of records to insert per batch when inserting data. The default value is '50000'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a9cb6bc5b7508d0445ed1ec14e953b1ec">insert\_records\_from\_files\_column\_formats</a>: For each target column specified, applies the column-property-bound format to the source data loaded into that column. Each column format will contain a mapping of one or more of its column properties to an appropriate format for each property. Currently supported column properties include date, time, and datetime. The parameter value must be formatted as a JSON string of maps of column names to maps of column properties to their corresponding column formats, e.g., ' "order\_date" :  "date" : "%Y.%m.%d" , "order\_time" :  "time" : "%H:%M:%S"  '. See <a href="/content/api/cpp/namespacegpudb#ae86d81a182f4c08d6f474374320fe7f6">default\_column\_formats</a> for valid format syntax. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aa34d6374fb7a0bf79109a98d7aa96983">insert\_records\_from\_files\_columns\_to\_load</a>: Specifies a comma-delimited list of columns from the source data to load. If more than one file is being loaded, this list applies to all files. Column numbers can be specified discretely or as a range. For example, a value of '5,7,1..3' will insert values from the fifth column in the source data into the first column in the target table, from the seventh column in the source data into the second column in the target table, and from the first through third columns in the source data into the third through fifth columns in the target table. If the source data contains a header, column names matching the file header names may be provided instead of column numbers. If the target table doesn't exist, the table will be created with the columns in this order. If the target table does exist with columns in a different order than the source data, this list can be used to match the order of the target table. For example, a value of 'C, B, A' will create a three column table with column C, followed by column B, followed by column A; or will insert those fields in that order into a table created with columns in that order. If the target table exists, the column names must match the source data field names for a name-mapping to be successful. Mutually exclusive with <a href="/content/api/cpp/namespacegpudb#a620823c2b5cd0ac1237aaefdade7b15e">columns\_to\_skip</a>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a620823c2b5cd0ac1237aaefdade7b15e">insert\_records\_from\_files\_columns\_to\_skip</a>: Specifies a comma-delimited list of columns from the source data to skip. Mutually exclusive with <a href="/content/api/cpp/namespacegpudb#aa34d6374fb7a0bf79109a98d7aa96983">columns\_to\_load</a>. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#af3aa6cbfed26ee30e7f4e085100fa48d">insert\_records\_from\_files\_compression\_type</a>: Source data compression type. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a76b9ff7498d452538ffa8b0ae3f16f63">insert\_records\_from\_files\_none</a>: No compression. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aab1dd7f07598346e0c35b660cb1d3a44">insert\_records\_from\_files\_auto</a>: Auto detect compression type. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a4824d77ba3c0ef92d13b85a54add7843">insert\_records\_from\_files\_gzip</a>: gzip file compression. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a1636a66107f1df8d2eec81f0b17f21d1">insert\_records\_from\_files\_bzip2</a>: bzip2 file compression. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#aab1dd7f07598346e0c35b660cb1d3a44">insert\_records\_from\_files\_auto</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a715ab62c16af690e60749b84681dc949">insert\_records\_from\_files\_datasource\_name</a>: Name of an existing external data source from which data file(s) specified in <span>filepaths</span> will be loaded. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ae86d81a182f4c08d6f474374320fe7f6">insert\_records\_from\_files\_default\_column\_formats</a>: Specifies the default format to be applied to source data loaded into columns with the corresponding column property. Currently supported column properties include date, time, and datetime. This default column-property-bound format can be overridden by specifying a column property and format for a given target column in <a href="/content/api/cpp/namespacegpudb#a9cb6bc5b7508d0445ed1ec14e953b1ec">column\_formats</a>. For each specified annotation, the format will apply to all columns with that annotation unless a custom <a href="/content/api/cpp/namespacegpudb#a9cb6bc5b7508d0445ed1ec14e953b1ec">column\_formats</a> for that annotation is specified. The parameter value must be formatted as a JSON string that is a map of column properties to their respective column formats, e.g., ' "date" : "%Y.%m.%d", "time" : "%H:%M:%S" '. Column formats are specified as a string of control characters and plain text. The supported control characters are 'Y', 'm', 'd', 'H', 'M', 'S', and 's', which follow the Linux 'strptime()' specification, as well as 's', which specifies seconds and fractional seconds (though the fractional component will be truncated past milliseconds). Formats for the 'date' annotation must include the 'Y', 'm', and 'd' control characters. Formats for the 'time' annotation must include the 'H', 'M', and either 'S' or 's' (but not both) control characters. Formats for the 'datetime' annotation meet both the 'date' and 'time' control character requirements. For example, '"datetime" : "%m/%d/%Y %H:%M:%S" ' would be used to interpret text as "05/04/2000 12:12:11" </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ac7886929e3d552f763cd09a54ed30d2e">insert\_records\_from\_files\_error\_handling</a>: Specifies how errors should be handled upon insertion. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#af8be89f360cd5e95ba91c40978391415">insert\_records\_from\_files\_permissive</a>: Records with missing columns are populated with nulls if possible; otherwise, the malformed records are skipped. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a14662fdab882c65832f29340ce55f01f">insert\_records\_from\_files\_skip</a>: Malformed records are skipped. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a437505771bdf71e343a345b611b99891">insert\_records\_from\_files\_ignore\_bad\_records</a>: Deprecated. Alias for <a href="/content/api/cpp/namespacegpudb#a14662fdab882c65832f29340ce55f01f">skip</a>. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a01cdf8f671e47432458c62110c2836e5">insert\_records\_from\_files\_abort</a>: Stops current insertion and aborts entire operation when an error is encountered. Primary key collisions are considered abortable errors in this mode. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a01cdf8f671e47432458c62110c2836e5">insert\_records\_from\_files\_abort</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a296565d33ab38cdd42bae9a521e25558">insert\_records\_from\_files\_file\_type</a>: Specifies the type of the file(s) whose records will be inserted. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ac1826f250108bc2524f25610e81051d9">insert\_records\_from\_files\_avro</a>: Avro file format. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a55f0ea7f01ea3e1c5fd20fbc3b42f8e2">insert\_records\_from\_files\_delimited\_text</a>: Delimited text file format; e.g., CSV, TSV, PSV, etc. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ace8130d5b518af7a6859fb74cb96b318">insert\_records\_from\_files\_gdb</a>: Esri/GDB file format. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a1fdad603995a7b96d7bdc8fd70d30d8d">insert\_records\_from\_files\_json</a>: JSON file format. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a5b0b6b46a2ab3d8bece75eccc681e20e">insert\_records\_from\_files\_parquet</a>: Apache Parquet file format. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a546ee87740989500ac67a3cd52f0aa04">insert\_records\_from\_files\_shapefile</a>: ShapeFile file format. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a55f0ea7f01ea3e1c5fd20fbc3b42f8e2">insert\_records\_from\_files\_delimited\_text</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#abc6733239a1841d86b0d33e01e6da5cf">insert\_records\_from\_files\_flatten\_columns</a>: Specifies how to handle nested columns. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad58bb28eb5e7272a1e135c544b07776e">insert\_records\_from\_files\_true</a>: Break up nested columns to multiple columns. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a3776c76d5b4e24922af4c329863e6ea3">insert\_records\_from\_files\_false</a>: Treat nested columns as JSON columns instead of flattening. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a3776c76d5b4e24922af4c329863e6ea3">insert\_records\_from\_files\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#af74084bdecf33c80cbf35ea9b8b39ecf">insert\_records\_from\_files\_gdal\_configuration\_options</a>: Comma separated list of gdal conf options, for the specific requests: key=value. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a32b41a38a44d51d9ac5942cb13ef7c5d">insert\_records\_from\_files\_pk\_conflict\_predicate\_higher</a>: The record with higher value for the column resolves the primary-key insert conflict. The default value is ''. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#affd7464c8931992b721ab5363a785fc8">insert\_records\_from\_files\_pk\_conflict\_predicate\_lower</a>: The record with lower value for the column resolves the primary-key insert conflict. The default value is ''. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ad34ab6d2b08b738d8ca7737f7360f903">insert\_records\_from\_files\_ignore\_existing\_pk</a>: Specifies the record collision error-suppression policy for inserting into a table with a <a href="/content/concepts/tables/#primary-keys">primary key</a>, only used when not in upsert mode (upsert mode is disabled when <a href="/content/api/cpp/namespacegpudb#a4f2f7fca3bf3fcbeaea237eacdbc43e0">update\_on\_existing\_pk</a> is <a href="/content/api/cpp/namespacegpudb#a3776c76d5b4e24922af4c329863e6ea3">false</a>). If set to <a href="/content/api/cpp/namespacegpudb#ad58bb28eb5e7272a1e135c544b07776e">true</a>, any record being inserted that is rejected for having primary key values that match those of an existing table record will be ignored with no error generated. If <a href="/content/api/cpp/namespacegpudb#a3776c76d5b4e24922af4c329863e6ea3">false</a>, the rejection of any record for having primary key values matching an existing record will result in an error being reported, as determined by <a href="/content/api/cpp/namespacegpudb#ac7886929e3d552f763cd09a54ed30d2e">error\_handling</a>. If the specified table does not have a primary key or if upsert mode is in effect (<a href="/content/api/cpp/namespacegpudb#a4f2f7fca3bf3fcbeaea237eacdbc43e0">update\_on\_existing\_pk</a> is <a href="/content/api/cpp/namespacegpudb#ad58bb28eb5e7272a1e135c544b07776e">true</a>), then this option has no effect. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad58bb28eb5e7272a1e135c544b07776e">insert\_records\_from\_files\_true</a>: Ignore new records whose primary key values collide with those of existing records. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a3776c76d5b4e24922af4c329863e6ea3">insert\_records\_from\_files\_false</a>: Treat as errors any new records whose primary key values collide with those of existing records. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a3776c76d5b4e24922af4c329863e6ea3">insert\_records\_from\_files\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a2b7706db1a670125f2e3e0e6bf49ef04">insert\_records\_from\_files\_ingestion\_mode</a>: Whether to do a full load, dry run, or perform a type inference on the source data. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a212a7d007797e41211645f48becacd6c">insert\_records\_from\_files\_full</a>: Run a type inference on the source data (if needed) and ingest. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a84142a0fa75bd248cee5d9da0d81ad09">insert\_records\_from\_files\_dry\_run</a>: Does not load data, but walks through the source data and determines the number of valid records, taking into account the current mode of <a href="/content/api/cpp/namespacegpudb#ac7886929e3d552f763cd09a54ed30d2e">error\_handling</a>. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a4ab7e02ec673bb457e683a7ab6122565">insert\_records\_from\_files\_type\_inference\_only</a>: Infer the type of the source data and return, without ingesting any data. The inferred type is returned in the response. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a212a7d007797e41211645f48becacd6c">insert\_records\_from\_files\_full</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a4c79c7038cce8a37a093dbec5263ae38">insert\_records\_from\_files\_kafka\_consumers\_per\_rank</a>: Number of Kafka consumer threads per rank (valid range 1-6). The default value is '1'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a3bd5d28ede21e71944ca46c0bf7292f7">insert\_records\_from\_files\_kafka\_group\_id</a>: The group id to be used when consuming data from a Kafka topic (valid only for Kafka datasource subscriptions). </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a499bb1fb36e431c0fbb221092b9351f4">insert\_records\_from\_files\_kafka\_offset\_reset\_policy</a>: Policy to determine whether the Kafka data consumption starts either at earliest offset or latest offset. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a1b8a560c67816f4b7294de3dd6842126">insert\_records\_from\_files\_earliest</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aa1e18104a58436b812d30f6ddf2825e5">insert\_records\_from\_files\_latest</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a1b8a560c67816f4b7294de3dd6842126">insert\_records\_from\_files\_earliest</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ab54b523185e4ad4a93b7a147d98c45a8">insert\_records\_from\_files\_kafka\_optimistic\_ingest</a>: Enable optimistic ingestion where Kafka topic offsets and table data are committed independently to achieve parallelism. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad58bb28eb5e7272a1e135c544b07776e">insert\_records\_from\_files\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a3776c76d5b4e24922af4c329863e6ea3">insert\_records\_from\_files\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a3776c76d5b4e24922af4c329863e6ea3">insert\_records\_from\_files\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#aad15fd1822e865dbd4f385fd0f1a631e">insert\_records\_from\_files\_kafka\_subscription\_cancel\_after</a>: Sets the Kafka subscription lifespan (in minutes). Expired subscription will be cancelled automatically. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a7a22cb196cb429cc396572e574c1f26a">insert\_records\_from\_files\_kafka\_type\_inference\_fetch\_timeout</a>: Maximum time to collect Kafka messages before type inferencing on the set of them. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a19290efaa208db91a8894efadb13b7e9">insert\_records\_from\_files\_layer</a>: Geo files layer(s) name(s): comma separated. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#aac4dd690613319ce8d9b82da2bae057e">insert\_records\_from\_files\_loading\_mode</a>: Scheme for distributing the extraction and loading of data from the source data file(s). This option applies only when loading files that are local to the database. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#af34414630f70fb87d95b6c797e1887c4">insert\_records\_from\_files\_head</a>: The head node loads all data. All files must be available to the head node. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a0aa9bf0c1893ca093ae139aa8fd5fef3">insert\_records\_from\_files\_distributed\_shared</a>: The head node coordinates loading data by worker processes across all nodes from shared files available to all workers. NOTE: Instead of existing on a shared source, the files can be duplicated on a source local to each host to improve performance, though the files must appear as the same data set from the perspective of all hosts performing the load. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a292ef8a563cb992b4fa5d0a63b681ad8">insert\_records\_from\_files\_distributed\_local</a>: A single worker process on each node loads all files that are available to it. This option works best when each worker loads files from its own file system, to maximize performance. In order to avoid data duplication, either each worker performing the load needs to have visibility to a set of files unique to it (no file is visible to more than one node) or the target table needs to have a primary key (which will allow the worker to automatically deduplicate data). NOTE: If the target table doesn't exist, the table structure will be determined by the head node. If the head node has no files local to it, it will be unable to determine the structure and the request will fail. If the head node is configured to have no worker processes, no data strictly accessible to the head node will be loaded. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#af34414630f70fb87d95b6c797e1887c4">insert\_records\_from\_files\_head</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a657cbb69b798755a8e0fa4e4618c016a">insert\_records\_from\_files\_local\_time\_offset</a>: Apply an offset to Avro local timestamp columns. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a38376c87545a7e00c475728342bada90">insert\_records\_from\_files\_max\_records\_to\_load</a>: Limit the number of records to load in this request: if this number is larger than <a href="/content/api/cpp/namespacegpudb#a068cbf9ef07dfe11f3b0069d8bae67fc">batch\_size</a>, then the number of records loaded will be limited to the next whole number of <a href="/content/api/cpp/namespacegpudb#a068cbf9ef07dfe11f3b0069d8bae67fc">batch\_size</a> (per working thread). </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#afcbf69cf62114bd321856eb75eb0283c">insert\_records\_from\_files\_name\_columns\_from\_file</a>: Specifies a comma-delimited list of column names to be used as the source-data column names. If the file has a header row (i.e., <a href="/content/api/cpp/namespacegpudb#ab234ce6680f377661f1759b39210f242">text\_has\_header</a> is <a href="/content/api/cpp/namespacegpudb#ad58bb28eb5e7272a1e135c544b07776e">true</a>), these names override the file's header names. If the file has no header row, these names are used as the source-data column names. Either way, the i-th name in this list applies to the i-th column in the file, enabling name-based matching against the target table's columns (and use with <a href="/content/api/cpp/namespacegpudb#aa34d6374fb7a0bf79109a98d7aa96983">columns\_to\_load</a> / <a href="/content/api/cpp/namespacegpudb#a620823c2b5cd0ac1237aaefdade7b15e">columns\_to\_skip</a>). </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#add3f1d5bb336cbc09836a3f79ce441cc">insert\_records\_from\_files\_num\_tasks\_per\_rank</a>: Number of tasks for reading file per rank. Default will be system configuration parameter, external\_file\_reader\_num\_tasks. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a79ae89ee9186ae8d8e460f09377c78c7">insert\_records\_from\_files\_poll\_interval</a>: If <a href="/content/api/cpp/namespacegpudb#ad58bb28eb5e7272a1e135c544b07776e">true</a>, the number of seconds between attempts to load external files into the table. If zero, polling will be continuous as long as data is found. If no data is found, the interval will steadily increase to a maximum of 60 seconds. The default value is '0'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a08250de18ea928f78323a19afdd1bcc9">insert\_records\_from\_files\_primary\_keys</a>: Comma separated list of column names to set as primary keys, when not specified in the type. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a81a6a37dc2497c4e2cfd21948496a91d">insert\_records\_from\_files\_schema\_registry\_connection\_retries</a>: Confluent Schema registry connection timeout (in secs). </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a389e3056b188ef4a4a32ccebae655985">insert\_records\_from\_files\_schema\_registry\_connection\_timeout</a>: Confluent Schema registry connection timeout (in secs). </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#afcd865130ffe9e51623b28cbdb830eda">insert\_records\_from\_files\_schema\_registry\_max\_consecutive\_connection\_failures</a>: Max records to skip due to SR connection failures, before failing. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a8d013b7a2bf2cad3382fc7da560b6a12">insert\_records\_from\_files\_max\_consecutive\_invalid\_schema\_failure</a>: Max records to skip due to schema related errors, before failing. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a689f1851fdd29a04dbe0f3124c1ee505">insert\_records\_from\_files\_schema\_registry\_schema\_name</a>: Name of the Avro schema in the schema registry to use when reading Avro records. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a5046e18efc807e4d8efa4447d7c28b1f">insert\_records\_from\_files\_shard\_keys</a>: Comma separated list of column names to set as shard keys, when not specified in the type. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a5a1c92e29f63accf51d57061fe825992">insert\_records\_from\_files\_skip\_lines</a>: Skip a number of lines from the beginning of the file. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#adbf92d6b9c0e2e489a771297135612ba">insert\_records\_from\_files\_start\_offsets</a>: Starting offsets by partition to fetch from kafka. A comma separated list of partition:offset pairs. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a77a71aa25f7772081f2df583f8cbca74">insert\_records\_from\_files\_subscribe</a>: Continuously poll the data source to check for new data and load it into the table. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad58bb28eb5e7272a1e135c544b07776e">insert\_records\_from\_files\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a3776c76d5b4e24922af4c329863e6ea3">insert\_records\_from\_files\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a3776c76d5b4e24922af4c329863e6ea3">insert\_records\_from\_files\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a03356b6694f6acf3a60c0eb4b3b86902">insert\_records\_from\_files\_table\_insert\_mode</a>: Insertion scheme to use when inserting records from multiple shapefiles. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a070a53da9bf1791a1eed2e009c1dc533">insert\_records\_from\_files\_single</a>: Insert all records into a single table. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a46fa16688857d4c656523dab1c289ed9">insert\_records\_from\_files\_table\_per\_file</a>: Insert records from each file into a new table corresponding to that file. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a070a53da9bf1791a1eed2e009c1dc533">insert\_records\_from\_files\_single</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a0a770629d32703b4c52723a3054ccea3">insert\_records\_from\_files\_text\_comment\_string</a>: Specifies the character string that should be interpreted as a comment line prefix in the source data. All lines in the data starting with the provided string are ignored. For <a href="/content/api/cpp/namespacegpudb#a55f0ea7f01ea3e1c5fd20fbc3b42f8e2">delimited\_text</a> <a href="/content/api/cpp/namespacegpudb#a296565d33ab38cdd42bae9a521e25558">file\_type</a> only. The default value is '#'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aa1e0300306be7d8b4999689f7d98393a">insert\_records\_from\_files\_text\_delimiter</a>: Specifies the character delimiting field values in the source data and field names in the header (if present). For <a href="/content/api/cpp/namespacegpudb#a55f0ea7f01ea3e1c5fd20fbc3b42f8e2">delimited\_text</a> <a href="/content/api/cpp/namespacegpudb#a296565d33ab38cdd42bae9a521e25558">file\_type</a> only. The default value is ','. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a1774c0c672edddbbe4600fc2e26d740a">insert\_records\_from\_files\_text\_escape\_character</a>: Specifies the character that is used to escape other characters in the source data. An 'a', 'b', 'f', 'n', 'r', 't', or 'v' preceded by an escape character will be interpreted as the ASCII bell, backspace, form feed, line feed, carriage return, horizontal tab, and vertical tab, respectively. For example, the escape character followed by an 'n' will be interpreted as a newline within a field value. The escape character can also be used to escape the quoting character, and will be treated as an escape character whether it is within a quoted field value or not. For <a href="/content/api/cpp/namespacegpudb#a55f0ea7f01ea3e1c5fd20fbc3b42f8e2">delimited\_text</a> <a href="/content/api/cpp/namespacegpudb#a296565d33ab38cdd42bae9a521e25558">file\_type</a> only. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ab234ce6680f377661f1759b39210f242">insert\_records\_from\_files\_text\_has\_header</a>: Indicates whether the source data contains a header row. For <a href="/content/api/cpp/namespacegpudb#a55f0ea7f01ea3e1c5fd20fbc3b42f8e2">delimited\_text</a><a href="/content/api/cpp/namespacegpudb#a296565d33ab38cdd42bae9a521e25558">file\_type</a> only. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad58bb28eb5e7272a1e135c544b07776e">insert\_records\_from\_files\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a3776c76d5b4e24922af4c329863e6ea3">insert\_records\_from\_files\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ad58bb28eb5e7272a1e135c544b07776e">insert\_records\_from\_files\_true</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a05fd6b35e29ed00927edb3c2f2488e74">insert\_records\_from\_files\_text\_header\_property\_delimiter</a>: Specifies the delimiter for <a href="/content/concepts/types/#column-properties">column properties</a> in the header row (if present). Cannot be set to same value as <a href="/content/api/cpp/namespacegpudb#aa1e0300306be7d8b4999689f7d98393a">text\_delimiter</a>. For <a href="/content/api/cpp/namespacegpudb#a55f0ea7f01ea3e1c5fd20fbc3b42f8e2">delimited\_text</a> <a href="/content/api/cpp/namespacegpudb#a296565d33ab38cdd42bae9a521e25558">file\_type</a> only. The default value is '|'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ab1654f4d433593abf58fc0fcaf0581aa">insert\_records\_from\_files\_text\_null\_string</a>: Specifies the character string that should be interpreted as a null value in the source data. For <a href="/content/api/cpp/namespacegpudb#a55f0ea7f01ea3e1c5fd20fbc3b42f8e2">delimited\_text</a> <a href="/content/api/cpp/namespacegpudb#a296565d33ab38cdd42bae9a521e25558">file\_type</a> only. The default value is '\N'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a7a5ae5d0612c507f8309aec4422ae52d">insert\_records\_from\_files\_text\_quote\_character</a>: Specifies the character that should be interpreted as a field value quoting character in the source data. The character must appear at beginning and end of field value to take effect. Delimiters within quoted fields are treated as literals and not delimiters. Within a quoted field, two consecutive quote characters will be interpreted as a single literal quote character, effectively escaping it. To not have a quote character, specify an empty string. For <a href="/content/api/cpp/namespacegpudb#a55f0ea7f01ea3e1c5fd20fbc3b42f8e2">delimited\_text</a> <a href="/content/api/cpp/namespacegpudb#a296565d33ab38cdd42bae9a521e25558">file\_type</a> only. The default value is '"'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a86311fc6eda839ed2e4e17fd52b6a765">insert\_records\_from\_files\_text\_search\_columns</a>: Add 'text\_search' property to internally inferenced string columns. Comma separated list of column names or '\*' for all columns. To add 'text\_search' property only to string columns greater than or equal to a minimum size, also set the <a href="/content/api/cpp/namespacegpudb#a802400646bec1f9cbf38e23b13dc489b">text\_search\_min\_column\_length</a> </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a802400646bec1f9cbf38e23b13dc489b">insert\_records\_from\_files\_text\_search\_min\_column\_length</a>: Set the minimum column size for strings to apply the 'text\_search' property to. Used only when <a href="/content/api/cpp/namespacegpudb#a86311fc6eda839ed2e4e17fd52b6a765">text\_search\_columns</a> has a value. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a38cda2f161f406b53b064fb8a996cb62">insert\_records\_from\_files\_trim\_space</a>: If set to <a href="/content/api/cpp/namespacegpudb#ad58bb28eb5e7272a1e135c544b07776e">true</a>, remove leading or trailing space from fields. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad58bb28eb5e7272a1e135c544b07776e">insert\_records\_from\_files\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a3776c76d5b4e24922af4c329863e6ea3">insert\_records\_from\_files\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a3776c76d5b4e24922af4c329863e6ea3">insert\_records\_from\_files\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a19ea038426e4304bc03c62c2e029f565">insert\_records\_from\_files\_truncate\_strings</a>: If set to <a href="/content/api/cpp/namespacegpudb#ad58bb28eb5e7272a1e135c544b07776e">true</a>, truncate string values that are longer than the column's type size. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad58bb28eb5e7272a1e135c544b07776e">insert\_records\_from\_files\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a3776c76d5b4e24922af4c329863e6ea3">insert\_records\_from\_files\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a3776c76d5b4e24922af4c329863e6ea3">insert\_records\_from\_files\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a7038cbd09f2220134da161944110b6c1">insert\_records\_from\_files\_truncate\_table</a>: If set to <a href="/content/api/cpp/namespacegpudb#ad58bb28eb5e7272a1e135c544b07776e">true</a>, truncates the table specified by <span>tableName</span> prior to loading the file(s). Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad58bb28eb5e7272a1e135c544b07776e">insert\_records\_from\_files\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a3776c76d5b4e24922af4c329863e6ea3">insert\_records\_from\_files\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a3776c76d5b4e24922af4c329863e6ea3">insert\_records\_from\_files\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a87fb4c59a6a530c0348610c434ef7a1b">insert\_records\_from\_files\_type\_inference\_max\_records\_read</a> </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#af9c6d26ecc40f9806c14c5aa6fbd4308">insert\_records\_from\_files\_type\_inference\_mode</a>: Optimize type inferencing for either speed or accuracy. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#aefa1d7cffecc597fb6ea22c0dd49de34">insert\_records\_from\_files\_accuracy</a>: Scans data to get exactly-typed and sized columns for all data scanned. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a528c0f230a51ac4ecfc26ad0a2ed7c4b">insert\_records\_from\_files\_speed</a>: Scans data and picks the widest possible column types so that 'all' values will fit with minimum data scanned. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#aefa1d7cffecc597fb6ea22c0dd49de34">insert\_records\_from\_files\_accuracy</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#adac84d336a979797e7aa8d3d9b518738">insert\_records\_from\_files\_enable\_inplace\_updates</a>: Applies only when upserting (when update\_on\_existing\_pk is true). If set to true (the default), an existing record matched by primary key is modified in place. If set to false, the matched record is updated by deleting it and inserting a replacement (delete and insert), which prevents the change from being reflected in dependent materialized views until they are refreshed. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad58bb28eb5e7272a1e135c544b07776e">insert\_records\_from\_files\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a3776c76d5b4e24922af4c329863e6ea3">insert\_records\_from\_files\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ad58bb28eb5e7272a1e135c544b07776e">insert\_records\_from\_files\_true</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a4f2f7fca3bf3fcbeaea237eacdbc43e0">insert\_records\_from\_files\_update\_on\_existing\_pk</a>: Specifies the record collision policy for inserting into a table with a <a href="/content/concepts/tables/#primary-keys">primary key</a>. If set to <a href="/content/api/cpp/namespacegpudb#ad58bb28eb5e7272a1e135c544b07776e">true</a>, any existing table record with primary key values that match those of a record being inserted will be replaced by that new record (the new data will be 'upserted'). If set to <a href="/content/api/cpp/namespacegpudb#a3776c76d5b4e24922af4c329863e6ea3">false</a>, any existing table record with primary key values that match those of a record being inserted will remain unchanged, while the new record will be rejected and the error handled as determined by <a href="/content/api/cpp/namespacegpudb#ad34ab6d2b08b738d8ca7737f7360f903">ignore\_existing\_pk</a> and <a href="/content/api/cpp/namespacegpudb#ac7886929e3d552f763cd09a54ed30d2e">error\_handling</a>. If the specified table does not have a primary key, then this option has no effect. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad58bb28eb5e7272a1e135c544b07776e">insert\_records\_from\_files\_true</a>: Upsert new records when primary keys match existing records. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a3776c76d5b4e24922af4c329863e6ea3">insert\_records\_from\_files\_false</a>: Reject new records when primary keys match existing records. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a3776c76d5b4e24922af4c329863e6ea3">insert\_records\_from\_files\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#ad215c403bf0d9b801f70044f3ba458d7">insert\_records\_from\_files\_transformations</a>: Comma-separated expressions, one per target table column. Each expression is evaluated per record. Empty entries (two consecutive commas) mean no transformation for that column – the value is resolved from the input record, table default, NULL, or an error. Expressions may reference input columns by name or by position ($1 for the first input column, $2 for the second, etc.). The default value is ''. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1InsertRecordsFromFilesResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a8c0483195731de927d1628c231b421bf">◆ </a></span>insertRecordsFromFiles() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1InsertRecordsFromFilesResponse">InsertRecordsFromFilesResponse</a> & gpudb::GPUdb::insertRecordsFromFiles </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< std::string > &</td>
            <td><span><span>filepaths</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::map\< std::string, std::string > > &</td>
            <td><span><span>modifyColumns</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>createTableOptions</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1InsertRecordsFromFilesResponse">InsertRecordsFromFilesResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Reads from one or more files and inserts the data into a new or existing table. </p>
        <p>The source data can be located either in <a href="/content/tools/kifs/">KiFS</a>; on the cluster, accessible to the database; or remotely, accessible via a pre-defined external <a href="/content/concepts/data_sources/">data source</a>.</p>
        <p>For delimited text files, there are two loading schemes: positional and name-based. The name-based loading scheme is enabled when the file has a header present and <a href="/content/api/cpp/namespacegpudb#ab234ce6680f377661f1759b39210f242">text\_has\_header</a> is set to <a href="/content/api/cpp/namespacegpudb#ad58bb28eb5e7272a1e135c544b07776e">true</a>. In this scheme, the source file(s) field names must match the target table's column names exactly; however, the source file can have more fields than the target table has columns. If <a href="/content/api/cpp/namespacegpudb#ac7886929e3d552f763cd09a54ed30d2e">error\_handling</a> is set to <a href="/content/api/cpp/namespacegpudb#af8be89f360cd5e95ba91c40978391415">permissive</a>, the source file can have fewer fields than the target table has columns. If the name-based loading scheme is being used, names matching the file header's names may be provided to <a href="/content/api/cpp/namespacegpudb#aa34d6374fb7a0bf79109a98d7aa96983">columns\_to\_load</a> instead of numbers, but ranges are not supported.</p>
        <p>Note: Due to data being loaded in parallel, there is no insertion order guaranteed. For tables with primary keys, in the case of a primary key collision, this means it is indeterminate which record will be inserted first and remain, while the rest of the colliding key records are discarded.</p>
        <p>Returns once all files are processed.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of the table into which the data will be inserted, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. If the table does not exist, the table will be created using either an existing <a href="/content/api/cpp/namespacegpudb#a315d4ef68c44fbf43b0c66f491e6c5d1">type\_id</a> or the type inferred from the file, and the new table name will have to meet standard <a href="/content/concepts/tables/#table-naming-criteria">table naming criteria</a>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>filepaths</td>
                <td>A list of file paths from which data will be sourced; For paths in <a href="/content/tools/kifs/">KiFS</a>, use the URI prefix of kifs\:// followed by the path to a file or directory. File matching by prefix is supported, e.g. kifs\://dir/file would match dir/file\_1 and dir/file\_2. When prefix matching is used, the path must start with a full, valid KiFS directory name. If an external data source is specified in <a href="/content/api/cpp/namespacegpudb#a715ab62c16af690e60749b84681dc949">datasource\_name</a>, these file paths must resolve to accessible files at that data source location. Prefix matching is supported. If the data source is hdfs, prefixes must be aligned with directories, i.e. partial file names will not match. If no data source is specified, the files are assumed to be local to the database and must all be accessible to the gpudb user, residing on the path (or relative to the path) specified by the external files directory in the Kinetica <a href="/content/config/#config-main-external-files">configuration file</a>. Wildcards (\*) can be used to specify a group of files. Prefix matching is supported, the prefixes must be aligned with directories. If the first path ends in .tsv, the text delimiter will be defaulted to a tab character. If the first path ends in .psv, the text delimiter will be defaulted to a pipe character (|). </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>modifyColumns</td>
                <td>Not implemented yet. The default value is an empty map. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>createTableOptions</td>

                <td>
                  <a href="/content/api/cpp/classgpudb_1_1GPUdb_1_1Options">Options</a> from <a href="#afa4ded9fdb07b49b4b1cb0835b5ac52a">createTable</a>, allowing the structure of the table to be defined independently of the data source, when creating the target table.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a315d4ef68c44fbf43b0c66f491e6c5d1">insert\_records\_from\_files\_type\_id</a>: ID of a currently registered <a href="/content/concepts/types/">type</a>. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ae62e946b7b1c91596cfbf36980918858">insert\_records\_from\_files\_no\_error\_if\_exists</a>: If <a href="/content/api/cpp/namespacegpudb#ad58bb28eb5e7272a1e135c544b07776e">true</a>, prevents an error from occurring if the table already exists and is of the given type. If a table with the same name but a different type exists, it is still an error. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad58bb28eb5e7272a1e135c544b07776e">insert\_records\_from\_files\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a3776c76d5b4e24922af4c329863e6ea3">insert\_records\_from\_files\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a3776c76d5b4e24922af4c329863e6ea3">insert\_records\_from\_files\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a594faaa30551f0af50e243b3a3691f05">insert\_records\_from\_files\_is\_replicated</a>: Affects the <a href="/content/concepts/tables/#distribution">distribution scheme</a> for the table's data. If <a href="/content/api/cpp/namespacegpudb#ad58bb28eb5e7272a1e135c544b07776e">true</a> and the given table has no explicit <a href="/content/concepts/tables/#shard-key">shard key</a> defined, the table will be <a href="/content/concepts/tables/#replication">replicated</a>. If <a href="/content/api/cpp/namespacegpudb#a3776c76d5b4e24922af4c329863e6ea3">false</a>, the table will be <a href="/content/concepts/tables/#sharding">sharded</a> according to the shard key specified in the given <a href="/content/api/cpp/namespacegpudb#a315d4ef68c44fbf43b0c66f491e6c5d1">type\_id</a>, or <a href="/content/concepts/tables/#random-sharding">randomly sharded</a>, if no shard key is specified. Note that a type containing a shard key cannot be used to create a replicated table. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad58bb28eb5e7272a1e135c544b07776e">insert\_records\_from\_files\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a3776c76d5b4e24922af4c329863e6ea3">insert\_records\_from\_files\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a3776c76d5b4e24922af4c329863e6ea3">insert\_records\_from\_files\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a8362ac091da6d0f2a4338690ee010825">insert\_records\_from\_files\_foreign\_keys</a>: Semicolon-separated list of <a href="/content/concepts/tables/#foreign-keys">foreign keys</a>, of the format '(source\_column\_name \[, ...]) references target\_table\_name(primary\_key\_column\_name \[, ...]) \[as foreign\_key\_name]'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a807c40696d5e465c0bec8421328963e3">insert\_records\_from\_files\_foreign\_shard\_key</a>: Foreign shard key of the format 'source\_column references shard\_by\_column from target\_table(primary\_key\_column)'. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a985f93e21b2780772c837842d7177612">insert\_records\_from\_files\_partition\_type</a>: <a href="/content/concepts/tables/#partitioning">Partitioning</a> scheme to use. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a0862003fdd8b6ec9b01edf53304d9d1f">insert\_records\_from\_files\_RANGE</a>: Use <a href="/content/concepts/tables/#partitioning-by-range">range partitioning</a>. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a7d15cd0d8c9811c850bdbe03f27db26d">insert\_records\_from\_files\_INTERVAL</a>: Use <a href="/content/concepts/tables/#partitioning-by-interval">interval partitioning</a>. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#accbc3118051b91dcf43fd6656a17674d">insert\_records\_from\_files\_LIST</a>: Use <a href="/content/concepts/tables/#partitioning-by-list">list partitioning</a>. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a3ad2df5e9be8cbf2de26ac1c0372a90d">insert\_records\_from\_files\_HASH</a>: Use <a href="/content/concepts/tables/#partitioning-by-hash">hash partitioning</a>. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a222778675ef4124a150567eed913d6eb">insert\_records\_from\_files\_SERIES</a>: Use <a href="/content/concepts/tables/#partitioning-by-series">series partitioning</a>. </li>
                      </ul>
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a2ac300786c2a60854ab066a02601db01">insert\_records\_from\_files\_partition\_keys</a>: Comma-separated list of partition keys, which are the columns or column expressions by which records will be assigned to partitions defined by <a href="/content/api/cpp/namespacegpudb#ae4baea68bd51cfc4ce99f955ecf574db">partition\_definitions</a>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ae4baea68bd51cfc4ce99f955ecf574db">insert\_records\_from\_files\_partition\_definitions</a>: Comma-separated list of partition definitions, whose format depends on the choice of <a href="/content/api/cpp/namespacegpudb#a985f93e21b2780772c837842d7177612">partition\_type</a>. See <a href="/content/concepts/tables/#partitioning-by-range">range partitioning</a>, <a href="/content/concepts/tables/#partitioning-by-interval">interval partitioning</a>, <a href="/content/concepts/tables/#partitioning-by-list">list partitioning</a>, <a href="/content/concepts/tables/#partitioning-by-hash">hash partitioning</a>, or <a href="/content/concepts/tables/#partitioning-by-series">series partitioning</a> for example formats. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ada3f83249e94e4ec1a61d5f3e48c9838">insert\_records\_from\_files\_is\_automatic\_partition</a>: If <a href="/content/api/cpp/namespacegpudb#ad58bb28eb5e7272a1e135c544b07776e">true</a>, a new partition will be created for values which don't fall into an existing partition. Currently, only supported for <a href="/content/concepts/tables/#partitioning-by-list">list partitions</a>. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad58bb28eb5e7272a1e135c544b07776e">insert\_records\_from\_files\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a3776c76d5b4e24922af4c329863e6ea3">insert\_records\_from\_files\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a3776c76d5b4e24922af4c329863e6ea3">insert\_records\_from\_files\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#aa4f43afd416ea25c890fbe59decaf768">insert\_records\_from\_files\_ttl</a>: Sets the <a href="/content/concepts/ttl/">TTL</a> of the table specified in <span>tableName</span>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a2295d3e0ae0cf497a76619b793ab8844">insert\_records\_from\_files\_chunk\_size</a>: Indicates the number of records per chunk to be used for this table. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a5b8872cccd87f7cb9439f765d857068c">insert\_records\_from\_files\_chunk\_column\_max\_memory</a>: Indicates the target maximum data size for each column in a chunk to be used for this table. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aba833d54ccdab5fc825a2c9d4eb23cac">insert\_records\_from\_files\_chunk\_max\_memory</a>: Indicates the target maximum data size for all columns in a chunk to be used for this table. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#abdc169744d47f174b446e434573e35b4">insert\_records\_from\_files\_is\_result\_table</a>: Indicates whether the table is a <a href="/content/concepts/tables_memory_only/">memory-only table</a>. A result table cannot contain columns with text\_search <a href="/content/concepts/types/#data-handling">data-handling</a>, and it will not be retained if the server is restarted. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad58bb28eb5e7272a1e135c544b07776e">insert\_records\_from\_files\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a3776c76d5b4e24922af4c329863e6ea3">insert\_records\_from\_files\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a3776c76d5b4e24922af4c329863e6ea3">insert\_records\_from\_files\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a1a7a1a1ea4d2002f074b0edc492d8a2c">insert\_records\_from\_files\_strategy\_definition</a>: The <a href="/content/rm/concepts/#tier-strategies">tier strategy</a> for the table and its columns. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a5c8e3812cb8e1e821b12a106b3758a2d">insert\_records\_from\_files\_compression\_codec</a>: The default <a href="/content/concepts/column_compression/">compression codec</a> for this table's columns. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a19e5fa0b272577b4da1034f50bd4f805">insert\_records\_from\_files\_bad\_record\_table\_name</a>: Name of a table to which records that were rejected are written. The bad-record-table has the following columns: line\_number (long), line\_rejected (string), error\_message (string). When <a href="/content/api/cpp/namespacegpudb#ac7886929e3d552f763cd09a54ed30d2e">error\_handling</a> is <a href="/content/api/cpp/namespacegpudb#a01cdf8f671e47432458c62110c2836e5">abort</a>, bad records table is not populated. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a0839191e6a9db565fba911a5d2af1eae">insert\_records\_from\_files\_bad\_record\_table\_limit</a>: A positive integer indicating the maximum number of records that can be written to the bad-record-table. The default value is '10000'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a51bea12f5ca4816838894d3852a3ccb2">insert\_records\_from\_files\_bad\_record\_table\_limit\_per\_input</a>: For subscriptions, a positive integer indicating the maximum number of records that can be written to the bad-record-table per file/payload. Default value will be <a href="/content/api/cpp/namespacegpudb#a0839191e6a9db565fba911a5d2af1eae">bad\_record\_table\_limit</a> and total size of the table per rank is limited to <a href="/content/api/cpp/namespacegpudb#a0839191e6a9db565fba911a5d2af1eae">bad\_record\_table\_limit</a>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a068cbf9ef07dfe11f3b0069d8bae67fc">insert\_records\_from\_files\_batch\_size</a>: Number of records to insert per batch when inserting data. The default value is '50000'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a9cb6bc5b7508d0445ed1ec14e953b1ec">insert\_records\_from\_files\_column\_formats</a>: For each target column specified, applies the column-property-bound format to the source data loaded into that column. Each column format will contain a mapping of one or more of its column properties to an appropriate format for each property. Currently supported column properties include date, time, and datetime. The parameter value must be formatted as a JSON string of maps of column names to maps of column properties to their corresponding column formats, e.g., ' "order\_date" :  "date" : "%Y.%m.%d" , "order\_time" :  "time" : "%H:%M:%S"  '. See <a href="/content/api/cpp/namespacegpudb#ae86d81a182f4c08d6f474374320fe7f6">default\_column\_formats</a> for valid format syntax. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aa34d6374fb7a0bf79109a98d7aa96983">insert\_records\_from\_files\_columns\_to\_load</a>: Specifies a comma-delimited list of columns from the source data to load. If more than one file is being loaded, this list applies to all files. Column numbers can be specified discretely or as a range. For example, a value of '5,7,1..3' will insert values from the fifth column in the source data into the first column in the target table, from the seventh column in the source data into the second column in the target table, and from the first through third columns in the source data into the third through fifth columns in the target table. If the source data contains a header, column names matching the file header names may be provided instead of column numbers. If the target table doesn't exist, the table will be created with the columns in this order. If the target table does exist with columns in a different order than the source data, this list can be used to match the order of the target table. For example, a value of 'C, B, A' will create a three column table with column C, followed by column B, followed by column A; or will insert those fields in that order into a table created with columns in that order. If the target table exists, the column names must match the source data field names for a name-mapping to be successful. Mutually exclusive with <a href="/content/api/cpp/namespacegpudb#a620823c2b5cd0ac1237aaefdade7b15e">columns\_to\_skip</a>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a620823c2b5cd0ac1237aaefdade7b15e">insert\_records\_from\_files\_columns\_to\_skip</a>: Specifies a comma-delimited list of columns from the source data to skip. Mutually exclusive with <a href="/content/api/cpp/namespacegpudb#aa34d6374fb7a0bf79109a98d7aa96983">columns\_to\_load</a>. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#af3aa6cbfed26ee30e7f4e085100fa48d">insert\_records\_from\_files\_compression\_type</a>: Source data compression type. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a76b9ff7498d452538ffa8b0ae3f16f63">insert\_records\_from\_files\_none</a>: No compression. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aab1dd7f07598346e0c35b660cb1d3a44">insert\_records\_from\_files\_auto</a>: Auto detect compression type. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a4824d77ba3c0ef92d13b85a54add7843">insert\_records\_from\_files\_gzip</a>: gzip file compression. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a1636a66107f1df8d2eec81f0b17f21d1">insert\_records\_from\_files\_bzip2</a>: bzip2 file compression. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#aab1dd7f07598346e0c35b660cb1d3a44">insert\_records\_from\_files\_auto</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a715ab62c16af690e60749b84681dc949">insert\_records\_from\_files\_datasource\_name</a>: Name of an existing external data source from which data file(s) specified in <span>filepaths</span> will be loaded. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ae86d81a182f4c08d6f474374320fe7f6">insert\_records\_from\_files\_default\_column\_formats</a>: Specifies the default format to be applied to source data loaded into columns with the corresponding column property. Currently supported column properties include date, time, and datetime. This default column-property-bound format can be overridden by specifying a column property and format for a given target column in <a href="/content/api/cpp/namespacegpudb#a9cb6bc5b7508d0445ed1ec14e953b1ec">column\_formats</a>. For each specified annotation, the format will apply to all columns with that annotation unless a custom <a href="/content/api/cpp/namespacegpudb#a9cb6bc5b7508d0445ed1ec14e953b1ec">column\_formats</a> for that annotation is specified. The parameter value must be formatted as a JSON string that is a map of column properties to their respective column formats, e.g., ' "date" : "%Y.%m.%d", "time" : "%H:%M:%S" '. Column formats are specified as a string of control characters and plain text. The supported control characters are 'Y', 'm', 'd', 'H', 'M', 'S', and 's', which follow the Linux 'strptime()' specification, as well as 's', which specifies seconds and fractional seconds (though the fractional component will be truncated past milliseconds). Formats for the 'date' annotation must include the 'Y', 'm', and 'd' control characters. Formats for the 'time' annotation must include the 'H', 'M', and either 'S' or 's' (but not both) control characters. Formats for the 'datetime' annotation meet both the 'date' and 'time' control character requirements. For example, '"datetime" : "%m/%d/%Y %H:%M:%S" ' would be used to interpret text as "05/04/2000 12:12:11" </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ac7886929e3d552f763cd09a54ed30d2e">insert\_records\_from\_files\_error\_handling</a>: Specifies how errors should be handled upon insertion. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#af8be89f360cd5e95ba91c40978391415">insert\_records\_from\_files\_permissive</a>: Records with missing columns are populated with nulls if possible; otherwise, the malformed records are skipped. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a14662fdab882c65832f29340ce55f01f">insert\_records\_from\_files\_skip</a>: Malformed records are skipped. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a437505771bdf71e343a345b611b99891">insert\_records\_from\_files\_ignore\_bad\_records</a>: Deprecated. Alias for <a href="/content/api/cpp/namespacegpudb#a14662fdab882c65832f29340ce55f01f">skip</a>. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a01cdf8f671e47432458c62110c2836e5">insert\_records\_from\_files\_abort</a>: Stops current insertion and aborts entire operation when an error is encountered. Primary key collisions are considered abortable errors in this mode. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a01cdf8f671e47432458c62110c2836e5">insert\_records\_from\_files\_abort</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a296565d33ab38cdd42bae9a521e25558">insert\_records\_from\_files\_file\_type</a>: Specifies the type of the file(s) whose records will be inserted. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ac1826f250108bc2524f25610e81051d9">insert\_records\_from\_files\_avro</a>: Avro file format. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a55f0ea7f01ea3e1c5fd20fbc3b42f8e2">insert\_records\_from\_files\_delimited\_text</a>: Delimited text file format; e.g., CSV, TSV, PSV, etc. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ace8130d5b518af7a6859fb74cb96b318">insert\_records\_from\_files\_gdb</a>: Esri/GDB file format. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a1fdad603995a7b96d7bdc8fd70d30d8d">insert\_records\_from\_files\_json</a>: JSON file format. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a5b0b6b46a2ab3d8bece75eccc681e20e">insert\_records\_from\_files\_parquet</a>: Apache Parquet file format. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a546ee87740989500ac67a3cd52f0aa04">insert\_records\_from\_files\_shapefile</a>: ShapeFile file format. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a55f0ea7f01ea3e1c5fd20fbc3b42f8e2">insert\_records\_from\_files\_delimited\_text</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#abc6733239a1841d86b0d33e01e6da5cf">insert\_records\_from\_files\_flatten\_columns</a>: Specifies how to handle nested columns. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad58bb28eb5e7272a1e135c544b07776e">insert\_records\_from\_files\_true</a>: Break up nested columns to multiple columns. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a3776c76d5b4e24922af4c329863e6ea3">insert\_records\_from\_files\_false</a>: Treat nested columns as JSON columns instead of flattening. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a3776c76d5b4e24922af4c329863e6ea3">insert\_records\_from\_files\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#af74084bdecf33c80cbf35ea9b8b39ecf">insert\_records\_from\_files\_gdal\_configuration\_options</a>: Comma separated list of gdal conf options, for the specific requests: key=value. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a32b41a38a44d51d9ac5942cb13ef7c5d">insert\_records\_from\_files\_pk\_conflict\_predicate\_higher</a>: The record with higher value for the column resolves the primary-key insert conflict. The default value is ''. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#affd7464c8931992b721ab5363a785fc8">insert\_records\_from\_files\_pk\_conflict\_predicate\_lower</a>: The record with lower value for the column resolves the primary-key insert conflict. The default value is ''. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ad34ab6d2b08b738d8ca7737f7360f903">insert\_records\_from\_files\_ignore\_existing\_pk</a>: Specifies the record collision error-suppression policy for inserting into a table with a <a href="/content/concepts/tables/#primary-keys">primary key</a>, only used when not in upsert mode (upsert mode is disabled when <a href="/content/api/cpp/namespacegpudb#a4f2f7fca3bf3fcbeaea237eacdbc43e0">update\_on\_existing\_pk</a> is <a href="/content/api/cpp/namespacegpudb#a3776c76d5b4e24922af4c329863e6ea3">false</a>). If set to <a href="/content/api/cpp/namespacegpudb#ad58bb28eb5e7272a1e135c544b07776e">true</a>, any record being inserted that is rejected for having primary key values that match those of an existing table record will be ignored with no error generated. If <a href="/content/api/cpp/namespacegpudb#a3776c76d5b4e24922af4c329863e6ea3">false</a>, the rejection of any record for having primary key values matching an existing record will result in an error being reported, as determined by <a href="/content/api/cpp/namespacegpudb#ac7886929e3d552f763cd09a54ed30d2e">error\_handling</a>. If the specified table does not have a primary key or if upsert mode is in effect (<a href="/content/api/cpp/namespacegpudb#a4f2f7fca3bf3fcbeaea237eacdbc43e0">update\_on\_existing\_pk</a> is <a href="/content/api/cpp/namespacegpudb#ad58bb28eb5e7272a1e135c544b07776e">true</a>), then this option has no effect. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad58bb28eb5e7272a1e135c544b07776e">insert\_records\_from\_files\_true</a>: Ignore new records whose primary key values collide with those of existing records. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a3776c76d5b4e24922af4c329863e6ea3">insert\_records\_from\_files\_false</a>: Treat as errors any new records whose primary key values collide with those of existing records. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a3776c76d5b4e24922af4c329863e6ea3">insert\_records\_from\_files\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a2b7706db1a670125f2e3e0e6bf49ef04">insert\_records\_from\_files\_ingestion\_mode</a>: Whether to do a full load, dry run, or perform a type inference on the source data. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a212a7d007797e41211645f48becacd6c">insert\_records\_from\_files\_full</a>: Run a type inference on the source data (if needed) and ingest. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a84142a0fa75bd248cee5d9da0d81ad09">insert\_records\_from\_files\_dry\_run</a>: Does not load data, but walks through the source data and determines the number of valid records, taking into account the current mode of <a href="/content/api/cpp/namespacegpudb#ac7886929e3d552f763cd09a54ed30d2e">error\_handling</a>. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a4ab7e02ec673bb457e683a7ab6122565">insert\_records\_from\_files\_type\_inference\_only</a>: Infer the type of the source data and return, without ingesting any data. The inferred type is returned in the response. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a212a7d007797e41211645f48becacd6c">insert\_records\_from\_files\_full</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a4c79c7038cce8a37a093dbec5263ae38">insert\_records\_from\_files\_kafka\_consumers\_per\_rank</a>: Number of Kafka consumer threads per rank (valid range 1-6). The default value is '1'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a3bd5d28ede21e71944ca46c0bf7292f7">insert\_records\_from\_files\_kafka\_group\_id</a>: The group id to be used when consuming data from a Kafka topic (valid only for Kafka datasource subscriptions). </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a499bb1fb36e431c0fbb221092b9351f4">insert\_records\_from\_files\_kafka\_offset\_reset\_policy</a>: Policy to determine whether the Kafka data consumption starts either at earliest offset or latest offset. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a1b8a560c67816f4b7294de3dd6842126">insert\_records\_from\_files\_earliest</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aa1e18104a58436b812d30f6ddf2825e5">insert\_records\_from\_files\_latest</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a1b8a560c67816f4b7294de3dd6842126">insert\_records\_from\_files\_earliest</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ab54b523185e4ad4a93b7a147d98c45a8">insert\_records\_from\_files\_kafka\_optimistic\_ingest</a>: Enable optimistic ingestion where Kafka topic offsets and table data are committed independently to achieve parallelism. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad58bb28eb5e7272a1e135c544b07776e">insert\_records\_from\_files\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a3776c76d5b4e24922af4c329863e6ea3">insert\_records\_from\_files\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a3776c76d5b4e24922af4c329863e6ea3">insert\_records\_from\_files\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#aad15fd1822e865dbd4f385fd0f1a631e">insert\_records\_from\_files\_kafka\_subscription\_cancel\_after</a>: Sets the Kafka subscription lifespan (in minutes). Expired subscription will be cancelled automatically. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a7a22cb196cb429cc396572e574c1f26a">insert\_records\_from\_files\_kafka\_type\_inference\_fetch\_timeout</a>: Maximum time to collect Kafka messages before type inferencing on the set of them. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a19290efaa208db91a8894efadb13b7e9">insert\_records\_from\_files\_layer</a>: Geo files layer(s) name(s): comma separated. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#aac4dd690613319ce8d9b82da2bae057e">insert\_records\_from\_files\_loading\_mode</a>: Scheme for distributing the extraction and loading of data from the source data file(s). This option applies only when loading files that are local to the database. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#af34414630f70fb87d95b6c797e1887c4">insert\_records\_from\_files\_head</a>: The head node loads all data. All files must be available to the head node. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a0aa9bf0c1893ca093ae139aa8fd5fef3">insert\_records\_from\_files\_distributed\_shared</a>: The head node coordinates loading data by worker processes across all nodes from shared files available to all workers. NOTE: Instead of existing on a shared source, the files can be duplicated on a source local to each host to improve performance, though the files must appear as the same data set from the perspective of all hosts performing the load. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a292ef8a563cb992b4fa5d0a63b681ad8">insert\_records\_from\_files\_distributed\_local</a>: A single worker process on each node loads all files that are available to it. This option works best when each worker loads files from its own file system, to maximize performance. In order to avoid data duplication, either each worker performing the load needs to have visibility to a set of files unique to it (no file is visible to more than one node) or the target table needs to have a primary key (which will allow the worker to automatically deduplicate data). NOTE: If the target table doesn't exist, the table structure will be determined by the head node. If the head node has no files local to it, it will be unable to determine the structure and the request will fail. If the head node is configured to have no worker processes, no data strictly accessible to the head node will be loaded. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#af34414630f70fb87d95b6c797e1887c4">insert\_records\_from\_files\_head</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a657cbb69b798755a8e0fa4e4618c016a">insert\_records\_from\_files\_local\_time\_offset</a>: Apply an offset to Avro local timestamp columns. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a38376c87545a7e00c475728342bada90">insert\_records\_from\_files\_max\_records\_to\_load</a>: Limit the number of records to load in this request: if this number is larger than <a href="/content/api/cpp/namespacegpudb#a068cbf9ef07dfe11f3b0069d8bae67fc">batch\_size</a>, then the number of records loaded will be limited to the next whole number of <a href="/content/api/cpp/namespacegpudb#a068cbf9ef07dfe11f3b0069d8bae67fc">batch\_size</a> (per working thread). </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#afcbf69cf62114bd321856eb75eb0283c">insert\_records\_from\_files\_name\_columns\_from\_file</a>: Specifies a comma-delimited list of column names to be used as the source-data column names. If the file has a header row (i.e., <a href="/content/api/cpp/namespacegpudb#ab234ce6680f377661f1759b39210f242">text\_has\_header</a> is <a href="/content/api/cpp/namespacegpudb#ad58bb28eb5e7272a1e135c544b07776e">true</a>), these names override the file's header names. If the file has no header row, these names are used as the source-data column names. Either way, the i-th name in this list applies to the i-th column in the file, enabling name-based matching against the target table's columns (and use with <a href="/content/api/cpp/namespacegpudb#aa34d6374fb7a0bf79109a98d7aa96983">columns\_to\_load</a> / <a href="/content/api/cpp/namespacegpudb#a620823c2b5cd0ac1237aaefdade7b15e">columns\_to\_skip</a>). </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#add3f1d5bb336cbc09836a3f79ce441cc">insert\_records\_from\_files\_num\_tasks\_per\_rank</a>: Number of tasks for reading file per rank. Default will be system configuration parameter, external\_file\_reader\_num\_tasks. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a79ae89ee9186ae8d8e460f09377c78c7">insert\_records\_from\_files\_poll\_interval</a>: If <a href="/content/api/cpp/namespacegpudb#ad58bb28eb5e7272a1e135c544b07776e">true</a>, the number of seconds between attempts to load external files into the table. If zero, polling will be continuous as long as data is found. If no data is found, the interval will steadily increase to a maximum of 60 seconds. The default value is '0'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a08250de18ea928f78323a19afdd1bcc9">insert\_records\_from\_files\_primary\_keys</a>: Comma separated list of column names to set as primary keys, when not specified in the type. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a81a6a37dc2497c4e2cfd21948496a91d">insert\_records\_from\_files\_schema\_registry\_connection\_retries</a>: Confluent Schema registry connection timeout (in secs). </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a389e3056b188ef4a4a32ccebae655985">insert\_records\_from\_files\_schema\_registry\_connection\_timeout</a>: Confluent Schema registry connection timeout (in secs). </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#afcd865130ffe9e51623b28cbdb830eda">insert\_records\_from\_files\_schema\_registry\_max\_consecutive\_connection\_failures</a>: Max records to skip due to SR connection failures, before failing. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a8d013b7a2bf2cad3382fc7da560b6a12">insert\_records\_from\_files\_max\_consecutive\_invalid\_schema\_failure</a>: Max records to skip due to schema related errors, before failing. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a689f1851fdd29a04dbe0f3124c1ee505">insert\_records\_from\_files\_schema\_registry\_schema\_name</a>: Name of the Avro schema in the schema registry to use when reading Avro records. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a5046e18efc807e4d8efa4447d7c28b1f">insert\_records\_from\_files\_shard\_keys</a>: Comma separated list of column names to set as shard keys, when not specified in the type. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a5a1c92e29f63accf51d57061fe825992">insert\_records\_from\_files\_skip\_lines</a>: Skip a number of lines from the beginning of the file. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#adbf92d6b9c0e2e489a771297135612ba">insert\_records\_from\_files\_start\_offsets</a>: Starting offsets by partition to fetch from kafka. A comma separated list of partition:offset pairs. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a77a71aa25f7772081f2df583f8cbca74">insert\_records\_from\_files\_subscribe</a>: Continuously poll the data source to check for new data and load it into the table. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad58bb28eb5e7272a1e135c544b07776e">insert\_records\_from\_files\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a3776c76d5b4e24922af4c329863e6ea3">insert\_records\_from\_files\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a3776c76d5b4e24922af4c329863e6ea3">insert\_records\_from\_files\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a03356b6694f6acf3a60c0eb4b3b86902">insert\_records\_from\_files\_table\_insert\_mode</a>: Insertion scheme to use when inserting records from multiple shapefiles. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a070a53da9bf1791a1eed2e009c1dc533">insert\_records\_from\_files\_single</a>: Insert all records into a single table. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a46fa16688857d4c656523dab1c289ed9">insert\_records\_from\_files\_table\_per\_file</a>: Insert records from each file into a new table corresponding to that file. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a070a53da9bf1791a1eed2e009c1dc533">insert\_records\_from\_files\_single</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a0a770629d32703b4c52723a3054ccea3">insert\_records\_from\_files\_text\_comment\_string</a>: Specifies the character string that should be interpreted as a comment line prefix in the source data. All lines in the data starting with the provided string are ignored. For <a href="/content/api/cpp/namespacegpudb#a55f0ea7f01ea3e1c5fd20fbc3b42f8e2">delimited\_text</a> <a href="/content/api/cpp/namespacegpudb#a296565d33ab38cdd42bae9a521e25558">file\_type</a> only. The default value is '#'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aa1e0300306be7d8b4999689f7d98393a">insert\_records\_from\_files\_text\_delimiter</a>: Specifies the character delimiting field values in the source data and field names in the header (if present). For <a href="/content/api/cpp/namespacegpudb#a55f0ea7f01ea3e1c5fd20fbc3b42f8e2">delimited\_text</a> <a href="/content/api/cpp/namespacegpudb#a296565d33ab38cdd42bae9a521e25558">file\_type</a> only. The default value is ','. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a1774c0c672edddbbe4600fc2e26d740a">insert\_records\_from\_files\_text\_escape\_character</a>: Specifies the character that is used to escape other characters in the source data. An 'a', 'b', 'f', 'n', 'r', 't', or 'v' preceded by an escape character will be interpreted as the ASCII bell, backspace, form feed, line feed, carriage return, horizontal tab, and vertical tab, respectively. For example, the escape character followed by an 'n' will be interpreted as a newline within a field value. The escape character can also be used to escape the quoting character, and will be treated as an escape character whether it is within a quoted field value or not. For <a href="/content/api/cpp/namespacegpudb#a55f0ea7f01ea3e1c5fd20fbc3b42f8e2">delimited\_text</a> <a href="/content/api/cpp/namespacegpudb#a296565d33ab38cdd42bae9a521e25558">file\_type</a> only. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ab234ce6680f377661f1759b39210f242">insert\_records\_from\_files\_text\_has\_header</a>: Indicates whether the source data contains a header row. For <a href="/content/api/cpp/namespacegpudb#a55f0ea7f01ea3e1c5fd20fbc3b42f8e2">delimited\_text</a><a href="/content/api/cpp/namespacegpudb#a296565d33ab38cdd42bae9a521e25558">file\_type</a> only. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad58bb28eb5e7272a1e135c544b07776e">insert\_records\_from\_files\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a3776c76d5b4e24922af4c329863e6ea3">insert\_records\_from\_files\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ad58bb28eb5e7272a1e135c544b07776e">insert\_records\_from\_files\_true</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a05fd6b35e29ed00927edb3c2f2488e74">insert\_records\_from\_files\_text\_header\_property\_delimiter</a>: Specifies the delimiter for <a href="/content/concepts/types/#column-properties">column properties</a> in the header row (if present). Cannot be set to same value as <a href="/content/api/cpp/namespacegpudb#aa1e0300306be7d8b4999689f7d98393a">text\_delimiter</a>. For <a href="/content/api/cpp/namespacegpudb#a55f0ea7f01ea3e1c5fd20fbc3b42f8e2">delimited\_text</a> <a href="/content/api/cpp/namespacegpudb#a296565d33ab38cdd42bae9a521e25558">file\_type</a> only. The default value is '|'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ab1654f4d433593abf58fc0fcaf0581aa">insert\_records\_from\_files\_text\_null\_string</a>: Specifies the character string that should be interpreted as a null value in the source data. For <a href="/content/api/cpp/namespacegpudb#a55f0ea7f01ea3e1c5fd20fbc3b42f8e2">delimited\_text</a> <a href="/content/api/cpp/namespacegpudb#a296565d33ab38cdd42bae9a521e25558">file\_type</a> only. The default value is '\N'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a7a5ae5d0612c507f8309aec4422ae52d">insert\_records\_from\_files\_text\_quote\_character</a>: Specifies the character that should be interpreted as a field value quoting character in the source data. The character must appear at beginning and end of field value to take effect. Delimiters within quoted fields are treated as literals and not delimiters. Within a quoted field, two consecutive quote characters will be interpreted as a single literal quote character, effectively escaping it. To not have a quote character, specify an empty string. For <a href="/content/api/cpp/namespacegpudb#a55f0ea7f01ea3e1c5fd20fbc3b42f8e2">delimited\_text</a> <a href="/content/api/cpp/namespacegpudb#a296565d33ab38cdd42bae9a521e25558">file\_type</a> only. The default value is '"'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a86311fc6eda839ed2e4e17fd52b6a765">insert\_records\_from\_files\_text\_search\_columns</a>: Add 'text\_search' property to internally inferenced string columns. Comma separated list of column names or '\*' for all columns. To add 'text\_search' property only to string columns greater than or equal to a minimum size, also set the <a href="/content/api/cpp/namespacegpudb#a802400646bec1f9cbf38e23b13dc489b">text\_search\_min\_column\_length</a> </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a802400646bec1f9cbf38e23b13dc489b">insert\_records\_from\_files\_text\_search\_min\_column\_length</a>: Set the minimum column size for strings to apply the 'text\_search' property to. Used only when <a href="/content/api/cpp/namespacegpudb#a86311fc6eda839ed2e4e17fd52b6a765">text\_search\_columns</a> has a value. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a38cda2f161f406b53b064fb8a996cb62">insert\_records\_from\_files\_trim\_space</a>: If set to <a href="/content/api/cpp/namespacegpudb#ad58bb28eb5e7272a1e135c544b07776e">true</a>, remove leading or trailing space from fields. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad58bb28eb5e7272a1e135c544b07776e">insert\_records\_from\_files\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a3776c76d5b4e24922af4c329863e6ea3">insert\_records\_from\_files\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a3776c76d5b4e24922af4c329863e6ea3">insert\_records\_from\_files\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a19ea038426e4304bc03c62c2e029f565">insert\_records\_from\_files\_truncate\_strings</a>: If set to <a href="/content/api/cpp/namespacegpudb#ad58bb28eb5e7272a1e135c544b07776e">true</a>, truncate string values that are longer than the column's type size. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad58bb28eb5e7272a1e135c544b07776e">insert\_records\_from\_files\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a3776c76d5b4e24922af4c329863e6ea3">insert\_records\_from\_files\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a3776c76d5b4e24922af4c329863e6ea3">insert\_records\_from\_files\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a7038cbd09f2220134da161944110b6c1">insert\_records\_from\_files\_truncate\_table</a>: If set to <a href="/content/api/cpp/namespacegpudb#ad58bb28eb5e7272a1e135c544b07776e">true</a>, truncates the table specified by <span>tableName</span> prior to loading the file(s). Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad58bb28eb5e7272a1e135c544b07776e">insert\_records\_from\_files\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a3776c76d5b4e24922af4c329863e6ea3">insert\_records\_from\_files\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a3776c76d5b4e24922af4c329863e6ea3">insert\_records\_from\_files\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a87fb4c59a6a530c0348610c434ef7a1b">insert\_records\_from\_files\_type\_inference\_max\_records\_read</a> </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#af9c6d26ecc40f9806c14c5aa6fbd4308">insert\_records\_from\_files\_type\_inference\_mode</a>: Optimize type inferencing for either speed or accuracy. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#aefa1d7cffecc597fb6ea22c0dd49de34">insert\_records\_from\_files\_accuracy</a>: Scans data to get exactly-typed and sized columns for all data scanned. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a528c0f230a51ac4ecfc26ad0a2ed7c4b">insert\_records\_from\_files\_speed</a>: Scans data and picks the widest possible column types so that 'all' values will fit with minimum data scanned. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#aefa1d7cffecc597fb6ea22c0dd49de34">insert\_records\_from\_files\_accuracy</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#adac84d336a979797e7aa8d3d9b518738">insert\_records\_from\_files\_enable\_inplace\_updates</a>: Applies only when upserting (when update\_on\_existing\_pk is true). If set to true (the default), an existing record matched by primary key is modified in place. If set to false, the matched record is updated by deleting it and inserting a replacement (delete and insert), which prevents the change from being reflected in dependent materialized views until they are refreshed. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad58bb28eb5e7272a1e135c544b07776e">insert\_records\_from\_files\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a3776c76d5b4e24922af4c329863e6ea3">insert\_records\_from\_files\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ad58bb28eb5e7272a1e135c544b07776e">insert\_records\_from\_files\_true</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a4f2f7fca3bf3fcbeaea237eacdbc43e0">insert\_records\_from\_files\_update\_on\_existing\_pk</a>: Specifies the record collision policy for inserting into a table with a <a href="/content/concepts/tables/#primary-keys">primary key</a>. If set to <a href="/content/api/cpp/namespacegpudb#ad58bb28eb5e7272a1e135c544b07776e">true</a>, any existing table record with primary key values that match those of a record being inserted will be replaced by that new record (the new data will be 'upserted'). If set to <a href="/content/api/cpp/namespacegpudb#a3776c76d5b4e24922af4c329863e6ea3">false</a>, any existing table record with primary key values that match those of a record being inserted will remain unchanged, while the new record will be rejected and the error handled as determined by <a href="/content/api/cpp/namespacegpudb#ad34ab6d2b08b738d8ca7737f7360f903">ignore\_existing\_pk</a> and <a href="/content/api/cpp/namespacegpudb#ac7886929e3d552f763cd09a54ed30d2e">error\_handling</a>. If the specified table does not have a primary key, then this option has no effect. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad58bb28eb5e7272a1e135c544b07776e">insert\_records\_from\_files\_true</a>: Upsert new records when primary keys match existing records. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a3776c76d5b4e24922af4c329863e6ea3">insert\_records\_from\_files\_false</a>: Reject new records when primary keys match existing records. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a3776c76d5b4e24922af4c329863e6ea3">insert\_records\_from\_files\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#ad215c403bf0d9b801f70044f3ba458d7">insert\_records\_from\_files\_transformations</a>: Comma-separated expressions, one per target table column. Each expression is evaluated per record. Empty entries (two consecutive commas) mean no transformation for that column – the value is resolved from the input record, table default, NULL, or an error. Expressions may reference input columns by name or by position ($1 for the first input column, $2 for the second, etc.). The default value is ''. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1InsertRecordsFromFilesResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1InsertRecordsFromFilesResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ac9ee5faa5ba7081d8c73e9d6526bde98">◆ </a></span>insertRecordsFromPayload() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1InsertRecordsFromPayloadResponse">InsertRecordsFromPayloadResponse</a> gpudb::GPUdb::insertRecordsFromPayload </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1InsertRecordsFromPayloadRequest">InsertRecordsFromPayloadRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Reads from the given text-based or binary payload and inserts the data into a new or existing table. </p>
        <p>The table will be created if it doesn't already exist.</p>
        <p>Returns once all records are processed.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1InsertRecordsFromPayloadRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1InsertRecordsFromPayloadResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a902abba0f676da7c34c3c5c3683ba37d">◆ </a></span>insertRecordsFromPayload() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1InsertRecordsFromPayloadResponse">InsertRecordsFromPayloadResponse</a> & gpudb::GPUdb::insertRecordsFromPayload </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1InsertRecordsFromPayloadRequest">InsertRecordsFromPayloadRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1InsertRecordsFromPayloadResponse">InsertRecordsFromPayloadResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Reads from the given text-based or binary payload and inserts the data into a new or existing table. </p>
        <p>The table will be created if it doesn't already exist.</p>
        <p>Returns once all records are processed.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1InsertRecordsFromPayloadRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1InsertRecordsFromPayloadResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1InsertRecordsFromPayloadResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#adeb45ef2ffbd245618c1e8a23dfa2405">◆ </a></span>insertRecordsFromPayload() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1InsertRecordsFromPayloadResponse">InsertRecordsFromPayloadResponse</a> gpudb::GPUdb::insertRecordsFromPayload </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>dataText</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< uint8\_t > &</td>
            <td><span><span>dataBytes</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::map\< std::string, std::string > > &</td>
            <td><span><span>modifyColumns</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>createTableOptions</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Reads from the given text-based or binary payload and inserts the data into a new or existing table. </p>
        <p>The table will be created if it doesn't already exist.</p>
        <p>Returns once all records are processed.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of the table into which the data will be inserted, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. If the table does not exist, the table will be created using either an existing <a href="/content/api/cpp/namespacegpudb#aa4d0fd213fc0e4af1216b05fd17617e4">type\_id</a> or the type inferred from the payload, and the new table name will have to meet standard <a href="/content/concepts/tables/#table-naming-criteria">table naming criteria</a>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>dataText</td>
                <td>Records formatted as delimited text. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>dataBytes</td>
                <td>Records formatted as binary data. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>modifyColumns</td>
                <td>Not implemented yet. The default value is an empty map. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>createTableOptions</td>

                <td>
                  <a href="/content/api/cpp/classgpudb_1_1GPUdb_1_1Options">Options</a> used when creating the target table. Includes type to use. The other options match those in <a href="#afa4ded9fdb07b49b4b1cb0835b5ac52a">createTable</a>.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#aa4d0fd213fc0e4af1216b05fd17617e4">insert\_records\_from\_payload\_type\_id</a>: ID of a currently registered <a href="/content/concepts/types/">type</a>. The default value is ''. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a60a8bb4c3da3f3a7d3f220f02e406708">insert\_records\_from\_payload\_no\_error\_if\_exists</a>: If <a href="/content/api/cpp/namespacegpudb#a78005ef1c826e66f4d8e68fa30e17631">true</a>, prevents an error from occurring if the table already exists and is of the given type. If a table with the same ID but a different type exists, it is still an error. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a78005ef1c826e66f4d8e68fa30e17631">insert\_records\_from\_payload\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a0ef206a773661e5a31023163eca97109">insert\_records\_from\_payload\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a0ef206a773661e5a31023163eca97109">insert\_records\_from\_payload\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a0c58aa4d5b8a8c59f56732062f53e3e2">insert\_records\_from\_payload\_is\_replicated</a>: Affects the <a href="/content/concepts/tables/#distribution">distribution scheme</a> for the table's data. If <a href="/content/api/cpp/namespacegpudb#a78005ef1c826e66f4d8e68fa30e17631">true</a> and the given type has no explicit <a href="/content/concepts/tables/#shard-key">shard key</a> defined, the table will be <a href="/content/concepts/tables/#replication">replicated</a>. If <a href="/content/api/cpp/namespacegpudb#a0ef206a773661e5a31023163eca97109">false</a>, the table will be <a href="/content/concepts/tables/#sharding">sharded</a> according to the shard key specified in the given <a href="/content/api/cpp/namespacegpudb#aa4d0fd213fc0e4af1216b05fd17617e4">type\_id</a>, or <a href="/content/concepts/tables/#random-sharding">randomly sharded</a>, if no shard key is specified. Note that a type containing a shard key cannot be used to create a replicated table. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a78005ef1c826e66f4d8e68fa30e17631">insert\_records\_from\_payload\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a0ef206a773661e5a31023163eca97109">insert\_records\_from\_payload\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a0ef206a773661e5a31023163eca97109">insert\_records\_from\_payload\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#afa357c4062ac063e11670ab9724394d6">insert\_records\_from\_payload\_foreign\_keys</a>: Semicolon-separated list of <a href="/content/concepts/tables/#foreign-keys">foreign keys</a>, of the format '(source\_column\_name \[, ...]) references target\_table\_name(primary\_key\_column\_name \[, ...]) \[as foreign\_key\_name]'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#af549cbb3179d6d0e5a3a5678d110e905">insert\_records\_from\_payload\_foreign\_shard\_key</a>: Foreign shard key of the format 'source\_column references shard\_by\_column from target\_table(primary\_key\_column)'. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a8b54cbe638426a6d5ded3b9c8bb9fc00">insert\_records\_from\_payload\_partition\_type</a>: <a href="/content/concepts/tables/#partitioning">Partitioning</a> scheme to use. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#acc57c1c6ff89decb87d4c66f187667e9">insert\_records\_from\_payload\_RANGE</a>: Use <a href="/content/concepts/tables/#partitioning-by-range">range partitioning</a>. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a3a459184002de5520ac9a8ad7209a239">insert\_records\_from\_payload\_INTERVAL</a>: Use <a href="/content/concepts/tables/#partitioning-by-interval">interval partitioning</a>. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#af88dce18e0dd32c49e4c77de2b7220d4">insert\_records\_from\_payload\_LIST</a>: Use <a href="/content/concepts/tables/#partitioning-by-list">list partitioning</a>. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ac97e2d7817fc29e4f2aa43730da4dcec">insert\_records\_from\_payload\_HASH</a>: Use <a href="/content/concepts/tables/#partitioning-by-hash">hash partitioning</a>. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aceae0260d815d1175d683a28e9233046">insert\_records\_from\_payload\_SERIES</a>: Use <a href="/content/concepts/tables/#partitioning-by-series">series partitioning</a>. </li>
                      </ul>
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a8448beba36baa35711485282290126d6">insert\_records\_from\_payload\_partition\_keys</a>: Comma-separated list of partition keys, which are the columns or column expressions by which records will be assigned to partitions defined by <a href="/content/api/cpp/namespacegpudb#a55d42d427709421210b99040528a288b">partition\_definitions</a>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a55d42d427709421210b99040528a288b">insert\_records\_from\_payload\_partition\_definitions</a>: Comma-separated list of partition definitions, whose format depends on the choice of <a href="/content/api/cpp/namespacegpudb#a8b54cbe638426a6d5ded3b9c8bb9fc00">partition\_type</a>. See <a href="/content/concepts/tables/#partitioning-by-range">range partitioning</a>, <a href="/content/concepts/tables/#partitioning-by-interval">interval partitioning</a>, <a href="/content/concepts/tables/#partitioning-by-list">list partitioning</a>, <a href="/content/concepts/tables/#partitioning-by-hash">hash partitioning</a>, or <a href="/content/concepts/tables/#partitioning-by-series">series partitioning</a> for example formats. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a3d038f684f526276e3ff0d397511657e">insert\_records\_from\_payload\_is\_automatic\_partition</a>: If <a href="/content/api/cpp/namespacegpudb#a78005ef1c826e66f4d8e68fa30e17631">true</a>, a new partition will be created for values which don't fall into an existing partition. Currently only supported for <a href="/content/concepts/tables/#partitioning-by-list">list partitions</a>. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a78005ef1c826e66f4d8e68fa30e17631">insert\_records\_from\_payload\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a0ef206a773661e5a31023163eca97109">insert\_records\_from\_payload\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a0ef206a773661e5a31023163eca97109">insert\_records\_from\_payload\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a1d4318f168b65c5d7f5f1fe576a1f366">insert\_records\_from\_payload\_ttl</a>: Sets the <a href="/content/concepts/ttl/">TTL</a> of the table specified in <span>tableName</span>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a1e2cb36144a0f765649e0fa5ad073281">insert\_records\_from\_payload\_chunk\_size</a>: Indicates the number of records per chunk to be used for this table. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aa2d326eedfa9a328a03e678f64411141">insert\_records\_from\_payload\_chunk\_column\_max\_memory</a>: Indicates the target maximum data size for each column in a chunk to be used for this table. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ae2cd63a5edc8fc931e9865f4be650d5f">insert\_records\_from\_payload\_chunk\_max\_memory</a>: Indicates the target maximum data size for all columns in a chunk to be used for this table. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a2713e15530c844d27d8bc557840c8b2d">insert\_records\_from\_payload\_is\_result\_table</a>: Indicates whether the table is a <a href="/content/concepts/tables_memory_only/">memory-only table</a>. A result table cannot contain columns with text\_search <a href="/content/concepts/types/#data-handling">data-handling</a>, and it will not be retained if the server is restarted. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a78005ef1c826e66f4d8e68fa30e17631">insert\_records\_from\_payload\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a0ef206a773661e5a31023163eca97109">insert\_records\_from\_payload\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a0ef206a773661e5a31023163eca97109">insert\_records\_from\_payload\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a31567b7e2a81edce225fa1c540e9adec">insert\_records\_from\_payload\_strategy\_definition</a>: The <a href="/content/rm/concepts/#tier-strategies">tier strategy</a> for the table and its columns. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a6d79a5f8fc053e67ee50424303dd875b">insert\_records\_from\_payload\_compression\_codec</a>: The default <a href="/content/concepts/column_compression/">compression codec</a> for this table's columns. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a63f44b1f3899f15e8188c913721601d4">insert\_records\_from\_payload\_bad\_record\_table\_name</a>: Name of a table to which records that were rejected are written. The bad-record-table has the following columns: line\_number (long), line\_rejected (string), error\_message (string). </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a384e434eecbcc274185014e1aac0b03a">insert\_records\_from\_payload\_bad\_record\_table\_limit</a>: A positive integer indicating the maximum number of records that can be written to the bad-record-table. Default value is 10000. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#adf4f57f49c8467029f8f598efd136066">insert\_records\_from\_payload\_bad\_record\_table\_limit\_per\_input</a>: For subscriptions: A positive integer indicating the maximum number of records that can be written to the bad-record-table per file/payload. Default value will be 'bad\_record\_table\_limit' and total size of the table per rank is limited to 'bad\_record\_table\_limit'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a1aa95851b0c4abe643f86773d364e95e">insert\_records\_from\_payload\_batch\_size</a>: Internal tuning parameter–number of records per batch when inserting data. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ac8dcd6b92a1f4a32c4b5b6ac37c1070a">insert\_records\_from\_payload\_column\_formats</a>: For each target column specified, applies the column-property-bound format to the source data loaded into that column. Each column format will contain a mapping of one or more of its column properties to an appropriate format for each property. Currently supported column properties include date, time, and datetime. The parameter value must be formatted as a JSON string of maps of column names to maps of column properties to their corresponding column formats, e.g., ' "order\_date" :  "date" : "%Y.%m.%d" , "order\_time" :  "time" : "%H:%M:%S"  '. See <a href="/content/api/cpp/namespacegpudb#ac2783a49fdc4187fe02e48735ae83728">default\_column\_formats</a> for valid format syntax. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ae3f7d0a27c78dfb32dcd085eb602213c">insert\_records\_from\_payload\_columns\_to\_load</a>: Specifies a comma-delimited list of columns from the source data to load. If more than one file is being loaded, this list applies to all files. Column numbers can be specified discretely or as a range. For example, a value of '5,7,1..3' will insert values from the fifth column in the source data into the first column in the target table, from the seventh column in the source data into the second column in the target table, and from the first through third columns in the source data into the third through fifth columns in the target table. If the source data contains a header, column names matching the file header names may be provided instead of column numbers. If the target table doesn't exist, the table will be created with the columns in this order. If the target table does exist with columns in a different order than the source data, this list can be used to match the order of the target table. For example, a value of 'C, B, A' will create a three column table with column C, followed by column B, followed by column A; or will insert those fields in that order into a table created with columns in that order. If the target table exists, the column names must match the source data field names for a name-mapping to be successful. Mutually exclusive with <a href="/content/api/cpp/namespacegpudb#a7dbfb76c7194bfcecb4310b8e59f971b">columns\_to\_skip</a>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a7dbfb76c7194bfcecb4310b8e59f971b">insert\_records\_from\_payload\_columns\_to\_skip</a>: Specifies a comma-delimited list of columns from the source data to skip. Mutually exclusive with <a href="/content/api/cpp/namespacegpudb#ae3f7d0a27c78dfb32dcd085eb602213c">columns\_to\_load</a>. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a4bceb63ac5765fb632e772823c2be3b8">insert\_records\_from\_payload\_compression\_type</a>: Payload compression type. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#afa312524759995c30a5b09a7ee09d7cc">insert\_records\_from\_payload\_none</a>: Uncompressed. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ae5c0c5f8e8723b5c3bb1d6746a3f94e8">insert\_records\_from\_payload\_auto</a>: Default. Auto detect compression type. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aaf82f7bff346db8a22c4b215ebf0d842">insert\_records\_from\_payload\_gzip</a>: gzip file compression. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#af55806cd7ba59adc8e1e895d9077c4bb">insert\_records\_from\_payload\_bzip2</a>: bzip2 file compression. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ae5c0c5f8e8723b5c3bb1d6746a3f94e8">insert\_records\_from\_payload\_auto</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#ac2783a49fdc4187fe02e48735ae83728">insert\_records\_from\_payload\_default\_column\_formats</a>: Specifies the default format to be applied to source data loaded into columns with the corresponding column property. Currently supported column properties include date, time, and datetime. This default column-property-bound format can be overridden by specifying a column property and format for a given target column in <a href="/content/api/cpp/namespacegpudb#ac8dcd6b92a1f4a32c4b5b6ac37c1070a">column\_formats</a>. For each specified annotation, the format will apply to all columns with that annotation unless a custom <a href="/content/api/cpp/namespacegpudb#ac8dcd6b92a1f4a32c4b5b6ac37c1070a">column\_formats</a> for that annotation is specified. The parameter value must be formatted as a JSON string that is a map of column properties to their respective column formats, e.g., ' "date" : "%Y.%m.%d", "time" : "%H:%M:%S" '. Column formats are specified as a string of control characters and plain text. The supported control characters are 'Y', 'm', 'd', 'H', 'M', 'S', and 's', which follow the Linux 'strptime()' specification, as well as 's', which specifies seconds and fractional seconds (though the fractional component will be truncated past milliseconds). Formats for the 'date' annotation must include the 'Y', 'm', and 'd' control characters. Formats for the 'time' annotation must include the 'H', 'M', and either 'S' or 's' (but not both) control characters. Formats for the 'datetime' annotation meet both the 'date' and 'time' control character requirements. For example, '"datetime" : "%m/%d/%Y %H:%M:%S" ' would be used to interpret text as "05/04/2000 12:12:11" </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a8e9826f8e1411ed8da73ccc56eaf0421">insert\_records\_from\_payload\_error\_handling</a>: Specifies how errors should be handled upon insertion. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ac6a1e9c8c505f345e8f1c29ff7bd012a">insert\_records\_from\_payload\_permissive</a>: Records with missing columns are populated with nulls if possible; otherwise, the malformed records are skipped. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aa640437d4443c36dc8795e70d3354d41">insert\_records\_from\_payload\_skip</a>: Malformed records are skipped. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a015190aca87838fe579d27db54a2f6b7">insert\_records\_from\_payload\_ignore\_bad\_records</a>: Deprecated. Alias for <a href="/content/api/cpp/namespacegpudb#aa640437d4443c36dc8795e70d3354d41">skip</a>. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#acd6ab046e85ee3666411a6b82df7ca36">insert\_records\_from\_payload\_abort</a>: Stops current insertion and aborts entire operation when an error is encountered. Primary key collisions are considered abortable errors in this mode. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#acd6ab046e85ee3666411a6b82df7ca36">insert\_records\_from\_payload\_abort</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#af469d1b9f94100ec0f18cd29a4574533">insert\_records\_from\_payload\_file\_type</a>: Specifies the type of the file(s) whose records will be inserted. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a11770387f9b8eaad0703b86f745cf11f">insert\_records\_from\_payload\_avro</a>: Avro file format. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad549b432974fea84740166221365e8c5">insert\_records\_from\_payload\_delimited\_text</a>: Delimited text file format; e.g., CSV, TSV, PSV, etc. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a3eb969c7b8fca7e6b9db489880db0bac">insert\_records\_from\_payload\_gdb</a>: Esri/GDB file format. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a9731ab150427b25def518f86f3983d56">insert\_records\_from\_payload\_json</a>: JSON file format. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ae135fe9ddba7784d52e1df5d3cc6e664">insert\_records\_from\_payload\_parquet</a>: Apache Parquet file format. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aad939c8532cf7ff365f94ee03f34b985">insert\_records\_from\_payload\_shapefile</a>: ShapeFile file format. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ad549b432974fea84740166221365e8c5">insert\_records\_from\_payload\_delimited\_text</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a3566403c3260e1fb5192ebb9ab966c14">insert\_records\_from\_payload\_flatten\_columns</a>: Specifies how to handle nested columns. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a78005ef1c826e66f4d8e68fa30e17631">insert\_records\_from\_payload\_true</a>: Break up nested columns to multiple columns. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a0ef206a773661e5a31023163eca97109">insert\_records\_from\_payload\_false</a>: Treat nested columns as JSON columns instead of flattening. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a0ef206a773661e5a31023163eca97109">insert\_records\_from\_payload\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a73a88e497895a447a4801d21d36118fa">insert\_records\_from\_payload\_gdal\_configuration\_options</a>: Comma separated list of gdal conf options, for the specific requests: key=value. The default value is ''. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a9aa361d328fa3b0fa9bf72dbf2f3a016">insert\_records\_from\_payload\_pk\_conflict\_predicate\_higher</a>: The record with higher value for the column resolves the primary-key insert conflict. The default value is ''. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a9c1d05cebcc8ede2d4e83a9af0666f56">insert\_records\_from\_payload\_pk\_conflict\_predicate\_lower</a>: The record with lower value for the column resolves the primary-key insert conflict. The default value is ''. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a7987c9d97ef4b28f79fada2e3b2bdce3">insert\_records\_from\_payload\_ignore\_existing\_pk</a>: Specifies the record collision error-suppression policy for inserting into a table with a <a href="/content/concepts/tables/#primary-keys">primary key</a>, only used when not in upsert mode (upsert mode is disabled when <a href="/content/api/cpp/namespacegpudb#a9a3bc53a0c4ff2da15a1dc290fe44e27">update\_on\_existing\_pk</a> is <a href="/content/api/cpp/namespacegpudb#a0ef206a773661e5a31023163eca97109">false</a>). If set to <a href="/content/api/cpp/namespacegpudb#a78005ef1c826e66f4d8e68fa30e17631">true</a>, any record being inserted that is rejected for having primary key values that match those of an existing table record will be ignored with no error generated. If <a href="/content/api/cpp/namespacegpudb#a0ef206a773661e5a31023163eca97109">false</a>, the rejection of any record for having primary key values matching an existing record will result in an error being reported, as determined by <a href="/content/api/cpp/namespacegpudb#a8e9826f8e1411ed8da73ccc56eaf0421">error\_handling</a>. If the specified table does not have a primary key or if upsert mode is in effect (<a href="/content/api/cpp/namespacegpudb#a9a3bc53a0c4ff2da15a1dc290fe44e27">update\_on\_existing\_pk</a> is <a href="/content/api/cpp/namespacegpudb#a78005ef1c826e66f4d8e68fa30e17631">true</a>), then this option has no effect. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a78005ef1c826e66f4d8e68fa30e17631">insert\_records\_from\_payload\_true</a>: Ignore new records whose primary key values collide with those of existing records. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a0ef206a773661e5a31023163eca97109">insert\_records\_from\_payload\_false</a>: Treat as errors any new records whose primary key values collide with those of existing records. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a0ef206a773661e5a31023163eca97109">insert\_records\_from\_payload\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a6e617f555b1b1c7832d1a2446276a58c">insert\_records\_from\_payload\_ingestion\_mode</a>: Whether to do a full load, dry run, or perform a type inference on the source data. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a2995e0d4487e80a3d81fcdec12543a9b">insert\_records\_from\_payload\_full</a>: Run a type inference on the source data (if needed) and ingest. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a0162f3652dab6fd87066def1c8f55be5">insert\_records\_from\_payload\_dry\_run</a>: Does not load data, but walks through the source data and determines the number of valid records, taking into account the current mode of <a href="/content/api/cpp/namespacegpudb#a8e9826f8e1411ed8da73ccc56eaf0421">error\_handling</a>. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a2acfa2b0d17c83c79f5e15c7dc276967">insert\_records\_from\_payload\_type\_inference\_only</a>: Infer the type of the source data and return, without ingesting any data. The inferred type is returned in the response. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a2995e0d4487e80a3d81fcdec12543a9b">insert\_records\_from\_payload\_full</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#afad8c56fd17d303501cd893dbb293b21">insert\_records\_from\_payload\_layer</a>: Geo files layer(s) name(s): comma separated. The default value is ''. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#afe793724c127a2f2887aa8031c3f0769">insert\_records\_from\_payload\_loading\_mode</a>: Scheme for distributing the extraction and loading of data from the source data file(s). This option applies only when loading files that are local to the database. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a5536608476aa9c649f021c0631ff867a">insert\_records\_from\_payload\_head</a>: The head node loads all data. All files must be available to the head node. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a3c5427ee0891c2e00ebb592464dc1653">insert\_records\_from\_payload\_distributed\_shared</a>: The head node coordinates loading data by worker processes across all nodes from shared files available to all workers. NOTE: Instead of existing on a shared source, the files can be duplicated on a source local to each host to improve performance, though the files must appear as the same data set from the perspective of all hosts performing the load. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a84dc243b0aefd8996c748bf52699bf25">insert\_records\_from\_payload\_distributed\_local</a>: A single worker process on each node loads all files that are available to it. This option works best when each worker loads files from its own file system, to maximize performance. In order to avoid data duplication, either each worker performing the load needs to have visibility to a set of files unique to it (no file is visible to more than one node) or the target table needs to have a primary key (which will allow the worker to automatically deduplicate data). NOTE: If the target table doesn't exist, the table structure will be determined by the head node. If the head node has no files local to it, it will be unable to determine the structure and the request will fail. If the head node is configured to have no worker processes, no data strictly accessible to the head node will be loaded. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a5536608476aa9c649f021c0631ff867a">insert\_records\_from\_payload\_head</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a5fb2536b13e4d39f7742ca217fb58d17">insert\_records\_from\_payload\_local\_time\_offset</a>: For Avro local timestamp columns. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a85a17cce157ce11ccff355c55ca25bb3">insert\_records\_from\_payload\_max\_records\_to\_load</a>: Limit the number of records to load in this request: If this number is larger than a batch\_size, then the number of records loaded will be limited to the next whole number of batch\_size (per working thread). The default value is ''. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#afe3ce87853f7a5a70e8f6c859bf83204">insert\_records\_from\_payload\_name\_columns\_from\_file</a>: Specifies a comma-delimited list of column names to be used as the source-data column names. If the payload has a header row (i.e., <a href="/content/api/cpp/namespacegpudb#a8bed20dd14624ce1c826dd82a8e52a25">text\_has\_header</a> is <a href="/content/api/cpp/namespacegpudb#a78005ef1c826e66f4d8e68fa30e17631">true</a>), these names override the payload's header names. If the payload has no header row, these names are used as the source-data column names. Either way, the i-th name in this list applies to the i-th column in the payload, enabling name-based matching against the target table's columns (and use with <a href="/content/api/cpp/namespacegpudb#ae3f7d0a27c78dfb32dcd085eb602213c">columns\_to\_load</a> / <a href="/content/api/cpp/namespacegpudb#a7dbfb76c7194bfcecb4310b8e59f971b">columns\_to\_skip</a>). </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a8a5d1d97e9dad8359e6481f20f87b449">insert\_records\_from\_payload\_num\_tasks\_per\_rank</a>: Number of tasks for reading file per rank. Default will be external\_file\_reader\_num\_tasks. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a6085ff820f26e1dc19e82b8f45427906">insert\_records\_from\_payload\_poll\_interval</a>: If <a href="/content/api/cpp/namespacegpudb#a78005ef1c826e66f4d8e68fa30e17631">true</a>, the number of seconds between attempts to load external files into the table. If zero, polling will be continuous as long as data is found. If no data is found, the interval will steadily increase to a maximum of 60 seconds. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#af84c749c12f185930b74615d32183caa">insert\_records\_from\_payload\_primary\_keys</a>: Comma separated list of column names, to set as primary keys, when not specified in the type. The default value is ''. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a55a3864eb96a19f3cf1060f959a63b8b">insert\_records\_from\_payload\_schema\_registry\_connection\_retries</a>: Confluent Schema registry connection timeout (in secs). </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a40a3cb11bd75fe95e00af49e47d1a8fa">insert\_records\_from\_payload\_schema\_registry\_connection\_timeout</a>: Confluent Schema registry connection timeout (in secs). </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a48ffbb278e471f3813ad8002cd912cb1">insert\_records\_from\_payload\_schema\_registry\_max\_consecutive\_connection\_failures</a>: Max records to skip due to SR connection failures, before failing. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a8f356eed58b51e88ce3c36a7573ae2bf">insert\_records\_from\_payload\_max\_consecutive\_invalid\_schema\_failure</a>: Max records to skip due to schema related errors, before failing. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a1b8679ec671bb80df173a739cfe69cc2">insert\_records\_from\_payload\_schema\_registry\_schema\_name</a>: Name of the Avro schema in the schema registry to use when reading Avro records. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a3a4e3583db566c05d58efdd6370f7887">insert\_records\_from\_payload\_shard\_keys</a>: Comma separated list of column names, to set as shard keys, when not specified in the type. The default value is ''. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a07104e2cfb3ba3e7cc87ad454e61179c">insert\_records\_from\_payload\_skip\_lines</a>: Skip a number of lines from the beginning of the file. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a86e754f48e1b2fe7097a4ce16eac68f2">insert\_records\_from\_payload\_subscribe</a>: Continuously poll the data source to check for new data and load it into the table. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a78005ef1c826e66f4d8e68fa30e17631">insert\_records\_from\_payload\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a0ef206a773661e5a31023163eca97109">insert\_records\_from\_payload\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a0ef206a773661e5a31023163eca97109">insert\_records\_from\_payload\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a845c78173b76de9218b43ecb2c11f55d">insert\_records\_from\_payload\_table\_insert\_mode</a>: When inserting records from multiple files: if <a href="/content/api/cpp/namespacegpudb#a76b3686eed7526a608e58a7e92a273c7">table\_per\_file</a>, then insert from each file into a new table. Currently supported only for shapefiles. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a90b0389823c5d824b1d431a35a636298">insert\_records\_from\_payload\_single</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a76b3686eed7526a608e58a7e92a273c7">insert\_records\_from\_payload\_table\_per\_file</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a90b0389823c5d824b1d431a35a636298">insert\_records\_from\_payload\_single</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a251cf030230c518364e5110fea26f8b2">insert\_records\_from\_payload\_text\_comment\_string</a>: Specifies the character string that should be interpreted as a comment line prefix in the source data. All lines in the data starting with the provided string are ignored. For <a href="/content/api/cpp/namespacegpudb#ad549b432974fea84740166221365e8c5">delimited\_text</a> <a href="/content/api/cpp/namespacegpudb#af469d1b9f94100ec0f18cd29a4574533">file\_type</a> only. The default value is '#'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ae709ee514d716730e9bcc82604aee81a">insert\_records\_from\_payload\_text\_delimiter</a>: Specifies the character delimiting field values in the source data and field names in the header (if present). For <a href="/content/api/cpp/namespacegpudb#ad549b432974fea84740166221365e8c5">delimited\_text</a> <a href="/content/api/cpp/namespacegpudb#af469d1b9f94100ec0f18cd29a4574533">file\_type</a> only. The default value is ','. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aed7c7588ba80963bd447591fcc26d3ed">insert\_records\_from\_payload\_text\_escape\_character</a>: Specifies the character that is used to escape other characters in the source data. An 'a', 'b', 'f', 'n', 'r', 't', or 'v' preceded by an escape character will be interpreted as the ASCII bell, backspace, form feed, line feed, carriage return, horizontal tab, and vertical tab, respectively. For example, the escape character followed by an 'n' will be interpreted as a newline within a field value. The escape character can also be used to escape the quoting character, and will be treated as an escape character whether it is within a quoted field value or not. For <a href="/content/api/cpp/namespacegpudb#ad549b432974fea84740166221365e8c5">delimited\_text</a> <a href="/content/api/cpp/namespacegpudb#af469d1b9f94100ec0f18cd29a4574533">file\_type</a> only. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a8bed20dd14624ce1c826dd82a8e52a25">insert\_records\_from\_payload\_text\_has\_header</a>: Indicates whether the source data contains a header row. For <a href="/content/api/cpp/namespacegpudb#ad549b432974fea84740166221365e8c5">delimited\_text</a><a href="/content/api/cpp/namespacegpudb#af469d1b9f94100ec0f18cd29a4574533">file\_type</a> only. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a78005ef1c826e66f4d8e68fa30e17631">insert\_records\_from\_payload\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a0ef206a773661e5a31023163eca97109">insert\_records\_from\_payload\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a78005ef1c826e66f4d8e68fa30e17631">insert\_records\_from\_payload\_true</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#aa69bd32df1474aa16a41a8a9ceb44df4">insert\_records\_from\_payload\_text\_header\_property\_delimiter</a>: Specifies the delimiter for <a href="/content/concepts/types/#column-properties">column properties</a> in the header row (if present). Cannot be set to same value as <a href="/content/api/cpp/namespacegpudb#ae709ee514d716730e9bcc82604aee81a">text\_delimiter</a>. For <a href="/content/api/cpp/namespacegpudb#ad549b432974fea84740166221365e8c5">delimited\_text</a> <a href="/content/api/cpp/namespacegpudb#af469d1b9f94100ec0f18cd29a4574533">file\_type</a> only. The default value is '|'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ab94aa04d59b1969ee5fe928acebff03c">insert\_records\_from\_payload\_text\_null\_string</a>: Specifies the character string that should be interpreted as a null value in the source data. For <a href="/content/api/cpp/namespacegpudb#ad549b432974fea84740166221365e8c5">delimited\_text</a> <a href="/content/api/cpp/namespacegpudb#af469d1b9f94100ec0f18cd29a4574533">file\_type</a> only. The default value is '\N'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#acbcd50ae7705c29fb73c261a62893742">insert\_records\_from\_payload\_text\_quote\_character</a>: Specifies the character that should be interpreted as a field value quoting character in the source data. The character must appear at beginning and end of field value to take effect. Delimiters within quoted fields are treated as literals and not delimiters. Within a quoted field, two consecutive quote characters will be interpreted as a single literal quote character, effectively escaping it. To not have a quote character, specify an empty string. For <a href="/content/api/cpp/namespacegpudb#ad549b432974fea84740166221365e8c5">delimited\_text</a> <a href="/content/api/cpp/namespacegpudb#af469d1b9f94100ec0f18cd29a4574533">file\_type</a> only. The default value is '"'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a860776d027cc4ec6dba5af4e307eafa1">insert\_records\_from\_payload\_text\_search\_columns</a>: Add 'text\_search' property to internally inferenced string columns. Comma separated list of column names or '\*' for all columns. To add text\_search property only to string columns of minimum size, set also the option 'text\_search\_min\_column\_length'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a99b99818e0a6ef387e0a94bff01571a1">insert\_records\_from\_payload\_text\_search\_min\_column\_length</a>: Set minimum column size. Used only when 'text\_search\_columns' has a value. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a7468fe743e490e9875dcd142ed97e784">insert\_records\_from\_payload\_trim\_space</a>: If set to <a href="/content/api/cpp/namespacegpudb#a78005ef1c826e66f4d8e68fa30e17631">true</a>, remove leading or trailing space from fields. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a78005ef1c826e66f4d8e68fa30e17631">insert\_records\_from\_payload\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a0ef206a773661e5a31023163eca97109">insert\_records\_from\_payload\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a0ef206a773661e5a31023163eca97109">insert\_records\_from\_payload\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a6b68955643210874e3af8e90d5b4b6df">insert\_records\_from\_payload\_truncate\_strings</a>: If set to <a href="/content/api/cpp/namespacegpudb#a78005ef1c826e66f4d8e68fa30e17631">true</a>, truncate string values that are longer than the column's type size. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a78005ef1c826e66f4d8e68fa30e17631">insert\_records\_from\_payload\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a0ef206a773661e5a31023163eca97109">insert\_records\_from\_payload\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a0ef206a773661e5a31023163eca97109">insert\_records\_from\_payload\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ad00fb5c9c0c87a8e44b842f1a5e2e1a6">insert\_records\_from\_payload\_truncate\_table</a>: If set to <a href="/content/api/cpp/namespacegpudb#a78005ef1c826e66f4d8e68fa30e17631">true</a>, truncates the table specified by <span>tableName</span> prior to loading the file(s). Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a78005ef1c826e66f4d8e68fa30e17631">insert\_records\_from\_payload\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a0ef206a773661e5a31023163eca97109">insert\_records\_from\_payload\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a0ef206a773661e5a31023163eca97109">insert\_records\_from\_payload\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#ab79642b491dd62f4f363052b07f66636">insert\_records\_from\_payload\_type\_inference\_max\_records\_read</a>: The default value is ''. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ac3b0fd2d2d5dc9685947135e49d22151">insert\_records\_from\_payload\_type\_inference\_mode</a>: Optimize type inference mode. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a56a6ee9757c7b50e10db20ab9cbd5e3d">insert\_records\_from\_payload\_accuracy</a>: Scans data to get exactly-typed and sized columns for all data scanned. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#adf117fd856d49f9e97c72ed85e790685">insert\_records\_from\_payload\_speed</a>: Scans data and picks the widest possible column types so that 'all' values will fit with minimum data scanned. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a56a6ee9757c7b50e10db20ab9cbd5e3d">insert\_records\_from\_payload\_accuracy</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a3637f00bc68ecf09694be649e4df6043">insert\_records\_from\_payload\_enable\_inplace\_updates</a>: Applies only when upserting (when update\_on\_existing\_pk is true). If set to true (the default), an existing record matched by primary key is modified in place. If set to false, the matched record is updated by deleting it and inserting a replacement (delete and insert), which prevents the change from being reflected in dependent materialized views until they are refreshed. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a78005ef1c826e66f4d8e68fa30e17631">insert\_records\_from\_payload\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a0ef206a773661e5a31023163eca97109">insert\_records\_from\_payload\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a78005ef1c826e66f4d8e68fa30e17631">insert\_records\_from\_payload\_true</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a9a3bc53a0c4ff2da15a1dc290fe44e27">insert\_records\_from\_payload\_update\_on\_existing\_pk</a>: Specifies the record collision policy for inserting into a table with a <a href="/content/concepts/tables/#primary-keys">primary key</a>. If set to <a href="/content/api/cpp/namespacegpudb#a78005ef1c826e66f4d8e68fa30e17631">true</a>, any existing table record with primary key values that match those of a record being inserted will be replaced by that new record (the new data will be "upserted"). If set to <a href="/content/api/cpp/namespacegpudb#a0ef206a773661e5a31023163eca97109">false</a>, any existing table record with primary key values that match those of a record being inserted will remain unchanged, while the new record will be rejected and the error handled as determined by <a href="/content/api/cpp/namespacegpudb#a7987c9d97ef4b28f79fada2e3b2bdce3">ignore\_existing\_pk</a> and <a href="/content/api/cpp/namespacegpudb#a8e9826f8e1411ed8da73ccc56eaf0421">error\_handling</a>. If the specified table does not have a primary key, then this option has no effect. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a78005ef1c826e66f4d8e68fa30e17631">insert\_records\_from\_payload\_true</a>: Upsert new records when primary keys match existing records. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a0ef206a773661e5a31023163eca97109">insert\_records\_from\_payload\_false</a>: Reject new records when primary keys match existing records. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a0ef206a773661e5a31023163eca97109">insert\_records\_from\_payload\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#ab97e4380863293a1252d6df89dd27805">insert\_records\_from\_payload\_transformations</a>: Comma-separated expressions, one per target table column. Each expression is evaluated per record. Empty entries (two consecutive commas) mean no transformation for that column – the value is resolved from the input record, table default, NULL, or an error. Expressions may reference input columns by name or by position ($1 for the first input column, $2 for the second, etc.). The default value is ''. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1InsertRecordsFromPayloadResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a5857ec840451085103cec9ed3f96ea0c">◆ </a></span>insertRecordsFromPayload() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1InsertRecordsFromPayloadResponse">InsertRecordsFromPayloadResponse</a> & gpudb::GPUdb::insertRecordsFromPayload </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>dataText</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< uint8\_t > &</td>
            <td><span><span>dataBytes</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::map\< std::string, std::string > > &</td>
            <td><span><span>modifyColumns</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>createTableOptions</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1InsertRecordsFromPayloadResponse">InsertRecordsFromPayloadResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Reads from the given text-based or binary payload and inserts the data into a new or existing table. </p>
        <p>The table will be created if it doesn't already exist.</p>
        <p>Returns once all records are processed.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of the table into which the data will be inserted, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. If the table does not exist, the table will be created using either an existing <a href="/content/api/cpp/namespacegpudb#aa4d0fd213fc0e4af1216b05fd17617e4">type\_id</a> or the type inferred from the payload, and the new table name will have to meet standard <a href="/content/concepts/tables/#table-naming-criteria">table naming criteria</a>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>dataText</td>
                <td>Records formatted as delimited text. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>dataBytes</td>
                <td>Records formatted as binary data. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>modifyColumns</td>
                <td>Not implemented yet. The default value is an empty map. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>createTableOptions</td>

                <td>
                  <a href="/content/api/cpp/classgpudb_1_1GPUdb_1_1Options">Options</a> used when creating the target table. Includes type to use. The other options match those in <a href="#afa4ded9fdb07b49b4b1cb0835b5ac52a">createTable</a>.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#aa4d0fd213fc0e4af1216b05fd17617e4">insert\_records\_from\_payload\_type\_id</a>: ID of a currently registered <a href="/content/concepts/types/">type</a>. The default value is ''. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a60a8bb4c3da3f3a7d3f220f02e406708">insert\_records\_from\_payload\_no\_error\_if\_exists</a>: If <a href="/content/api/cpp/namespacegpudb#a78005ef1c826e66f4d8e68fa30e17631">true</a>, prevents an error from occurring if the table already exists and is of the given type. If a table with the same ID but a different type exists, it is still an error. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a78005ef1c826e66f4d8e68fa30e17631">insert\_records\_from\_payload\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a0ef206a773661e5a31023163eca97109">insert\_records\_from\_payload\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a0ef206a773661e5a31023163eca97109">insert\_records\_from\_payload\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a0c58aa4d5b8a8c59f56732062f53e3e2">insert\_records\_from\_payload\_is\_replicated</a>: Affects the <a href="/content/concepts/tables/#distribution">distribution scheme</a> for the table's data. If <a href="/content/api/cpp/namespacegpudb#a78005ef1c826e66f4d8e68fa30e17631">true</a> and the given type has no explicit <a href="/content/concepts/tables/#shard-key">shard key</a> defined, the table will be <a href="/content/concepts/tables/#replication">replicated</a>. If <a href="/content/api/cpp/namespacegpudb#a0ef206a773661e5a31023163eca97109">false</a>, the table will be <a href="/content/concepts/tables/#sharding">sharded</a> according to the shard key specified in the given <a href="/content/api/cpp/namespacegpudb#aa4d0fd213fc0e4af1216b05fd17617e4">type\_id</a>, or <a href="/content/concepts/tables/#random-sharding">randomly sharded</a>, if no shard key is specified. Note that a type containing a shard key cannot be used to create a replicated table. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a78005ef1c826e66f4d8e68fa30e17631">insert\_records\_from\_payload\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a0ef206a773661e5a31023163eca97109">insert\_records\_from\_payload\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a0ef206a773661e5a31023163eca97109">insert\_records\_from\_payload\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#afa357c4062ac063e11670ab9724394d6">insert\_records\_from\_payload\_foreign\_keys</a>: Semicolon-separated list of <a href="/content/concepts/tables/#foreign-keys">foreign keys</a>, of the format '(source\_column\_name \[, ...]) references target\_table\_name(primary\_key\_column\_name \[, ...]) \[as foreign\_key\_name]'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#af549cbb3179d6d0e5a3a5678d110e905">insert\_records\_from\_payload\_foreign\_shard\_key</a>: Foreign shard key of the format 'source\_column references shard\_by\_column from target\_table(primary\_key\_column)'. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a8b54cbe638426a6d5ded3b9c8bb9fc00">insert\_records\_from\_payload\_partition\_type</a>: <a href="/content/concepts/tables/#partitioning">Partitioning</a> scheme to use. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#acc57c1c6ff89decb87d4c66f187667e9">insert\_records\_from\_payload\_RANGE</a>: Use <a href="/content/concepts/tables/#partitioning-by-range">range partitioning</a>. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a3a459184002de5520ac9a8ad7209a239">insert\_records\_from\_payload\_INTERVAL</a>: Use <a href="/content/concepts/tables/#partitioning-by-interval">interval partitioning</a>. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#af88dce18e0dd32c49e4c77de2b7220d4">insert\_records\_from\_payload\_LIST</a>: Use <a href="/content/concepts/tables/#partitioning-by-list">list partitioning</a>. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ac97e2d7817fc29e4f2aa43730da4dcec">insert\_records\_from\_payload\_HASH</a>: Use <a href="/content/concepts/tables/#partitioning-by-hash">hash partitioning</a>. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aceae0260d815d1175d683a28e9233046">insert\_records\_from\_payload\_SERIES</a>: Use <a href="/content/concepts/tables/#partitioning-by-series">series partitioning</a>. </li>
                      </ul>
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a8448beba36baa35711485282290126d6">insert\_records\_from\_payload\_partition\_keys</a>: Comma-separated list of partition keys, which are the columns or column expressions by which records will be assigned to partitions defined by <a href="/content/api/cpp/namespacegpudb#a55d42d427709421210b99040528a288b">partition\_definitions</a>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a55d42d427709421210b99040528a288b">insert\_records\_from\_payload\_partition\_definitions</a>: Comma-separated list of partition definitions, whose format depends on the choice of <a href="/content/api/cpp/namespacegpudb#a8b54cbe638426a6d5ded3b9c8bb9fc00">partition\_type</a>. See <a href="/content/concepts/tables/#partitioning-by-range">range partitioning</a>, <a href="/content/concepts/tables/#partitioning-by-interval">interval partitioning</a>, <a href="/content/concepts/tables/#partitioning-by-list">list partitioning</a>, <a href="/content/concepts/tables/#partitioning-by-hash">hash partitioning</a>, or <a href="/content/concepts/tables/#partitioning-by-series">series partitioning</a> for example formats. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a3d038f684f526276e3ff0d397511657e">insert\_records\_from\_payload\_is\_automatic\_partition</a>: If <a href="/content/api/cpp/namespacegpudb#a78005ef1c826e66f4d8e68fa30e17631">true</a>, a new partition will be created for values which don't fall into an existing partition. Currently only supported for <a href="/content/concepts/tables/#partitioning-by-list">list partitions</a>. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a78005ef1c826e66f4d8e68fa30e17631">insert\_records\_from\_payload\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a0ef206a773661e5a31023163eca97109">insert\_records\_from\_payload\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a0ef206a773661e5a31023163eca97109">insert\_records\_from\_payload\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a1d4318f168b65c5d7f5f1fe576a1f366">insert\_records\_from\_payload\_ttl</a>: Sets the <a href="/content/concepts/ttl/">TTL</a> of the table specified in <span>tableName</span>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a1e2cb36144a0f765649e0fa5ad073281">insert\_records\_from\_payload\_chunk\_size</a>: Indicates the number of records per chunk to be used for this table. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aa2d326eedfa9a328a03e678f64411141">insert\_records\_from\_payload\_chunk\_column\_max\_memory</a>: Indicates the target maximum data size for each column in a chunk to be used for this table. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ae2cd63a5edc8fc931e9865f4be650d5f">insert\_records\_from\_payload\_chunk\_max\_memory</a>: Indicates the target maximum data size for all columns in a chunk to be used for this table. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a2713e15530c844d27d8bc557840c8b2d">insert\_records\_from\_payload\_is\_result\_table</a>: Indicates whether the table is a <a href="/content/concepts/tables_memory_only/">memory-only table</a>. A result table cannot contain columns with text\_search <a href="/content/concepts/types/#data-handling">data-handling</a>, and it will not be retained if the server is restarted. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a78005ef1c826e66f4d8e68fa30e17631">insert\_records\_from\_payload\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a0ef206a773661e5a31023163eca97109">insert\_records\_from\_payload\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a0ef206a773661e5a31023163eca97109">insert\_records\_from\_payload\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a31567b7e2a81edce225fa1c540e9adec">insert\_records\_from\_payload\_strategy\_definition</a>: The <a href="/content/rm/concepts/#tier-strategies">tier strategy</a> for the table and its columns. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a6d79a5f8fc053e67ee50424303dd875b">insert\_records\_from\_payload\_compression\_codec</a>: The default <a href="/content/concepts/column_compression/">compression codec</a> for this table's columns. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a63f44b1f3899f15e8188c913721601d4">insert\_records\_from\_payload\_bad\_record\_table\_name</a>: Name of a table to which records that were rejected are written. The bad-record-table has the following columns: line\_number (long), line\_rejected (string), error\_message (string). </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a384e434eecbcc274185014e1aac0b03a">insert\_records\_from\_payload\_bad\_record\_table\_limit</a>: A positive integer indicating the maximum number of records that can be written to the bad-record-table. Default value is 10000. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#adf4f57f49c8467029f8f598efd136066">insert\_records\_from\_payload\_bad\_record\_table\_limit\_per\_input</a>: For subscriptions: A positive integer indicating the maximum number of records that can be written to the bad-record-table per file/payload. Default value will be 'bad\_record\_table\_limit' and total size of the table per rank is limited to 'bad\_record\_table\_limit'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a1aa95851b0c4abe643f86773d364e95e">insert\_records\_from\_payload\_batch\_size</a>: Internal tuning parameter–number of records per batch when inserting data. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ac8dcd6b92a1f4a32c4b5b6ac37c1070a">insert\_records\_from\_payload\_column\_formats</a>: For each target column specified, applies the column-property-bound format to the source data loaded into that column. Each column format will contain a mapping of one or more of its column properties to an appropriate format for each property. Currently supported column properties include date, time, and datetime. The parameter value must be formatted as a JSON string of maps of column names to maps of column properties to their corresponding column formats, e.g., ' "order\_date" :  "date" : "%Y.%m.%d" , "order\_time" :  "time" : "%H:%M:%S"  '. See <a href="/content/api/cpp/namespacegpudb#ac2783a49fdc4187fe02e48735ae83728">default\_column\_formats</a> for valid format syntax. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ae3f7d0a27c78dfb32dcd085eb602213c">insert\_records\_from\_payload\_columns\_to\_load</a>: Specifies a comma-delimited list of columns from the source data to load. If more than one file is being loaded, this list applies to all files. Column numbers can be specified discretely or as a range. For example, a value of '5,7,1..3' will insert values from the fifth column in the source data into the first column in the target table, from the seventh column in the source data into the second column in the target table, and from the first through third columns in the source data into the third through fifth columns in the target table. If the source data contains a header, column names matching the file header names may be provided instead of column numbers. If the target table doesn't exist, the table will be created with the columns in this order. If the target table does exist with columns in a different order than the source data, this list can be used to match the order of the target table. For example, a value of 'C, B, A' will create a three column table with column C, followed by column B, followed by column A; or will insert those fields in that order into a table created with columns in that order. If the target table exists, the column names must match the source data field names for a name-mapping to be successful. Mutually exclusive with <a href="/content/api/cpp/namespacegpudb#a7dbfb76c7194bfcecb4310b8e59f971b">columns\_to\_skip</a>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a7dbfb76c7194bfcecb4310b8e59f971b">insert\_records\_from\_payload\_columns\_to\_skip</a>: Specifies a comma-delimited list of columns from the source data to skip. Mutually exclusive with <a href="/content/api/cpp/namespacegpudb#ae3f7d0a27c78dfb32dcd085eb602213c">columns\_to\_load</a>. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a4bceb63ac5765fb632e772823c2be3b8">insert\_records\_from\_payload\_compression\_type</a>: Payload compression type. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#afa312524759995c30a5b09a7ee09d7cc">insert\_records\_from\_payload\_none</a>: Uncompressed. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ae5c0c5f8e8723b5c3bb1d6746a3f94e8">insert\_records\_from\_payload\_auto</a>: Default. Auto detect compression type. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aaf82f7bff346db8a22c4b215ebf0d842">insert\_records\_from\_payload\_gzip</a>: gzip file compression. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#af55806cd7ba59adc8e1e895d9077c4bb">insert\_records\_from\_payload\_bzip2</a>: bzip2 file compression. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ae5c0c5f8e8723b5c3bb1d6746a3f94e8">insert\_records\_from\_payload\_auto</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#ac2783a49fdc4187fe02e48735ae83728">insert\_records\_from\_payload\_default\_column\_formats</a>: Specifies the default format to be applied to source data loaded into columns with the corresponding column property. Currently supported column properties include date, time, and datetime. This default column-property-bound format can be overridden by specifying a column property and format for a given target column in <a href="/content/api/cpp/namespacegpudb#ac8dcd6b92a1f4a32c4b5b6ac37c1070a">column\_formats</a>. For each specified annotation, the format will apply to all columns with that annotation unless a custom <a href="/content/api/cpp/namespacegpudb#ac8dcd6b92a1f4a32c4b5b6ac37c1070a">column\_formats</a> for that annotation is specified. The parameter value must be formatted as a JSON string that is a map of column properties to their respective column formats, e.g., ' "date" : "%Y.%m.%d", "time" : "%H:%M:%S" '. Column formats are specified as a string of control characters and plain text. The supported control characters are 'Y', 'm', 'd', 'H', 'M', 'S', and 's', which follow the Linux 'strptime()' specification, as well as 's', which specifies seconds and fractional seconds (though the fractional component will be truncated past milliseconds). Formats for the 'date' annotation must include the 'Y', 'm', and 'd' control characters. Formats for the 'time' annotation must include the 'H', 'M', and either 'S' or 's' (but not both) control characters. Formats for the 'datetime' annotation meet both the 'date' and 'time' control character requirements. For example, '"datetime" : "%m/%d/%Y %H:%M:%S" ' would be used to interpret text as "05/04/2000 12:12:11" </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a8e9826f8e1411ed8da73ccc56eaf0421">insert\_records\_from\_payload\_error\_handling</a>: Specifies how errors should be handled upon insertion. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ac6a1e9c8c505f345e8f1c29ff7bd012a">insert\_records\_from\_payload\_permissive</a>: Records with missing columns are populated with nulls if possible; otherwise, the malformed records are skipped. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aa640437d4443c36dc8795e70d3354d41">insert\_records\_from\_payload\_skip</a>: Malformed records are skipped. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a015190aca87838fe579d27db54a2f6b7">insert\_records\_from\_payload\_ignore\_bad\_records</a>: Deprecated. Alias for <a href="/content/api/cpp/namespacegpudb#aa640437d4443c36dc8795e70d3354d41">skip</a>. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#acd6ab046e85ee3666411a6b82df7ca36">insert\_records\_from\_payload\_abort</a>: Stops current insertion and aborts entire operation when an error is encountered. Primary key collisions are considered abortable errors in this mode. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#acd6ab046e85ee3666411a6b82df7ca36">insert\_records\_from\_payload\_abort</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#af469d1b9f94100ec0f18cd29a4574533">insert\_records\_from\_payload\_file\_type</a>: Specifies the type of the file(s) whose records will be inserted. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a11770387f9b8eaad0703b86f745cf11f">insert\_records\_from\_payload\_avro</a>: Avro file format. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad549b432974fea84740166221365e8c5">insert\_records\_from\_payload\_delimited\_text</a>: Delimited text file format; e.g., CSV, TSV, PSV, etc. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a3eb969c7b8fca7e6b9db489880db0bac">insert\_records\_from\_payload\_gdb</a>: Esri/GDB file format. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a9731ab150427b25def518f86f3983d56">insert\_records\_from\_payload\_json</a>: JSON file format. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ae135fe9ddba7784d52e1df5d3cc6e664">insert\_records\_from\_payload\_parquet</a>: Apache Parquet file format. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aad939c8532cf7ff365f94ee03f34b985">insert\_records\_from\_payload\_shapefile</a>: ShapeFile file format. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ad549b432974fea84740166221365e8c5">insert\_records\_from\_payload\_delimited\_text</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a3566403c3260e1fb5192ebb9ab966c14">insert\_records\_from\_payload\_flatten\_columns</a>: Specifies how to handle nested columns. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a78005ef1c826e66f4d8e68fa30e17631">insert\_records\_from\_payload\_true</a>: Break up nested columns to multiple columns. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a0ef206a773661e5a31023163eca97109">insert\_records\_from\_payload\_false</a>: Treat nested columns as JSON columns instead of flattening. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a0ef206a773661e5a31023163eca97109">insert\_records\_from\_payload\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a73a88e497895a447a4801d21d36118fa">insert\_records\_from\_payload\_gdal\_configuration\_options</a>: Comma separated list of gdal conf options, for the specific requests: key=value. The default value is ''. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a9aa361d328fa3b0fa9bf72dbf2f3a016">insert\_records\_from\_payload\_pk\_conflict\_predicate\_higher</a>: The record with higher value for the column resolves the primary-key insert conflict. The default value is ''. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a9c1d05cebcc8ede2d4e83a9af0666f56">insert\_records\_from\_payload\_pk\_conflict\_predicate\_lower</a>: The record with lower value for the column resolves the primary-key insert conflict. The default value is ''. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a7987c9d97ef4b28f79fada2e3b2bdce3">insert\_records\_from\_payload\_ignore\_existing\_pk</a>: Specifies the record collision error-suppression policy for inserting into a table with a <a href="/content/concepts/tables/#primary-keys">primary key</a>, only used when not in upsert mode (upsert mode is disabled when <a href="/content/api/cpp/namespacegpudb#a9a3bc53a0c4ff2da15a1dc290fe44e27">update\_on\_existing\_pk</a> is <a href="/content/api/cpp/namespacegpudb#a0ef206a773661e5a31023163eca97109">false</a>). If set to <a href="/content/api/cpp/namespacegpudb#a78005ef1c826e66f4d8e68fa30e17631">true</a>, any record being inserted that is rejected for having primary key values that match those of an existing table record will be ignored with no error generated. If <a href="/content/api/cpp/namespacegpudb#a0ef206a773661e5a31023163eca97109">false</a>, the rejection of any record for having primary key values matching an existing record will result in an error being reported, as determined by <a href="/content/api/cpp/namespacegpudb#a8e9826f8e1411ed8da73ccc56eaf0421">error\_handling</a>. If the specified table does not have a primary key or if upsert mode is in effect (<a href="/content/api/cpp/namespacegpudb#a9a3bc53a0c4ff2da15a1dc290fe44e27">update\_on\_existing\_pk</a> is <a href="/content/api/cpp/namespacegpudb#a78005ef1c826e66f4d8e68fa30e17631">true</a>), then this option has no effect. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a78005ef1c826e66f4d8e68fa30e17631">insert\_records\_from\_payload\_true</a>: Ignore new records whose primary key values collide with those of existing records. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a0ef206a773661e5a31023163eca97109">insert\_records\_from\_payload\_false</a>: Treat as errors any new records whose primary key values collide with those of existing records. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a0ef206a773661e5a31023163eca97109">insert\_records\_from\_payload\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a6e617f555b1b1c7832d1a2446276a58c">insert\_records\_from\_payload\_ingestion\_mode</a>: Whether to do a full load, dry run, or perform a type inference on the source data. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a2995e0d4487e80a3d81fcdec12543a9b">insert\_records\_from\_payload\_full</a>: Run a type inference on the source data (if needed) and ingest. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a0162f3652dab6fd87066def1c8f55be5">insert\_records\_from\_payload\_dry\_run</a>: Does not load data, but walks through the source data and determines the number of valid records, taking into account the current mode of <a href="/content/api/cpp/namespacegpudb#a8e9826f8e1411ed8da73ccc56eaf0421">error\_handling</a>. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a2acfa2b0d17c83c79f5e15c7dc276967">insert\_records\_from\_payload\_type\_inference\_only</a>: Infer the type of the source data and return, without ingesting any data. The inferred type is returned in the response. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a2995e0d4487e80a3d81fcdec12543a9b">insert\_records\_from\_payload\_full</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#afad8c56fd17d303501cd893dbb293b21">insert\_records\_from\_payload\_layer</a>: Geo files layer(s) name(s): comma separated. The default value is ''. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#afe793724c127a2f2887aa8031c3f0769">insert\_records\_from\_payload\_loading\_mode</a>: Scheme for distributing the extraction and loading of data from the source data file(s). This option applies only when loading files that are local to the database. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a5536608476aa9c649f021c0631ff867a">insert\_records\_from\_payload\_head</a>: The head node loads all data. All files must be available to the head node. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a3c5427ee0891c2e00ebb592464dc1653">insert\_records\_from\_payload\_distributed\_shared</a>: The head node coordinates loading data by worker processes across all nodes from shared files available to all workers. NOTE: Instead of existing on a shared source, the files can be duplicated on a source local to each host to improve performance, though the files must appear as the same data set from the perspective of all hosts performing the load. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a84dc243b0aefd8996c748bf52699bf25">insert\_records\_from\_payload\_distributed\_local</a>: A single worker process on each node loads all files that are available to it. This option works best when each worker loads files from its own file system, to maximize performance. In order to avoid data duplication, either each worker performing the load needs to have visibility to a set of files unique to it (no file is visible to more than one node) or the target table needs to have a primary key (which will allow the worker to automatically deduplicate data). NOTE: If the target table doesn't exist, the table structure will be determined by the head node. If the head node has no files local to it, it will be unable to determine the structure and the request will fail. If the head node is configured to have no worker processes, no data strictly accessible to the head node will be loaded. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a5536608476aa9c649f021c0631ff867a">insert\_records\_from\_payload\_head</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a5fb2536b13e4d39f7742ca217fb58d17">insert\_records\_from\_payload\_local\_time\_offset</a>: For Avro local timestamp columns. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a85a17cce157ce11ccff355c55ca25bb3">insert\_records\_from\_payload\_max\_records\_to\_load</a>: Limit the number of records to load in this request: If this number is larger than a batch\_size, then the number of records loaded will be limited to the next whole number of batch\_size (per working thread). The default value is ''. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#afe3ce87853f7a5a70e8f6c859bf83204">insert\_records\_from\_payload\_name\_columns\_from\_file</a>: Specifies a comma-delimited list of column names to be used as the source-data column names. If the payload has a header row (i.e., <a href="/content/api/cpp/namespacegpudb#a8bed20dd14624ce1c826dd82a8e52a25">text\_has\_header</a> is <a href="/content/api/cpp/namespacegpudb#a78005ef1c826e66f4d8e68fa30e17631">true</a>), these names override the payload's header names. If the payload has no header row, these names are used as the source-data column names. Either way, the i-th name in this list applies to the i-th column in the payload, enabling name-based matching against the target table's columns (and use with <a href="/content/api/cpp/namespacegpudb#ae3f7d0a27c78dfb32dcd085eb602213c">columns\_to\_load</a> / <a href="/content/api/cpp/namespacegpudb#a7dbfb76c7194bfcecb4310b8e59f971b">columns\_to\_skip</a>). </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a8a5d1d97e9dad8359e6481f20f87b449">insert\_records\_from\_payload\_num\_tasks\_per\_rank</a>: Number of tasks for reading file per rank. Default will be external\_file\_reader\_num\_tasks. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a6085ff820f26e1dc19e82b8f45427906">insert\_records\_from\_payload\_poll\_interval</a>: If <a href="/content/api/cpp/namespacegpudb#a78005ef1c826e66f4d8e68fa30e17631">true</a>, the number of seconds between attempts to load external files into the table. If zero, polling will be continuous as long as data is found. If no data is found, the interval will steadily increase to a maximum of 60 seconds. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#af84c749c12f185930b74615d32183caa">insert\_records\_from\_payload\_primary\_keys</a>: Comma separated list of column names, to set as primary keys, when not specified in the type. The default value is ''. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a55a3864eb96a19f3cf1060f959a63b8b">insert\_records\_from\_payload\_schema\_registry\_connection\_retries</a>: Confluent Schema registry connection timeout (in secs). </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a40a3cb11bd75fe95e00af49e47d1a8fa">insert\_records\_from\_payload\_schema\_registry\_connection\_timeout</a>: Confluent Schema registry connection timeout (in secs). </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a48ffbb278e471f3813ad8002cd912cb1">insert\_records\_from\_payload\_schema\_registry\_max\_consecutive\_connection\_failures</a>: Max records to skip due to SR connection failures, before failing. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a8f356eed58b51e88ce3c36a7573ae2bf">insert\_records\_from\_payload\_max\_consecutive\_invalid\_schema\_failure</a>: Max records to skip due to schema related errors, before failing. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a1b8679ec671bb80df173a739cfe69cc2">insert\_records\_from\_payload\_schema\_registry\_schema\_name</a>: Name of the Avro schema in the schema registry to use when reading Avro records. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a3a4e3583db566c05d58efdd6370f7887">insert\_records\_from\_payload\_shard\_keys</a>: Comma separated list of column names, to set as shard keys, when not specified in the type. The default value is ''. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a07104e2cfb3ba3e7cc87ad454e61179c">insert\_records\_from\_payload\_skip\_lines</a>: Skip a number of lines from the beginning of the file. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a86e754f48e1b2fe7097a4ce16eac68f2">insert\_records\_from\_payload\_subscribe</a>: Continuously poll the data source to check for new data and load it into the table. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a78005ef1c826e66f4d8e68fa30e17631">insert\_records\_from\_payload\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a0ef206a773661e5a31023163eca97109">insert\_records\_from\_payload\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a0ef206a773661e5a31023163eca97109">insert\_records\_from\_payload\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a845c78173b76de9218b43ecb2c11f55d">insert\_records\_from\_payload\_table\_insert\_mode</a>: When inserting records from multiple files: if <a href="/content/api/cpp/namespacegpudb#a76b3686eed7526a608e58a7e92a273c7">table\_per\_file</a>, then insert from each file into a new table. Currently supported only for shapefiles. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a90b0389823c5d824b1d431a35a636298">insert\_records\_from\_payload\_single</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a76b3686eed7526a608e58a7e92a273c7">insert\_records\_from\_payload\_table\_per\_file</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a90b0389823c5d824b1d431a35a636298">insert\_records\_from\_payload\_single</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a251cf030230c518364e5110fea26f8b2">insert\_records\_from\_payload\_text\_comment\_string</a>: Specifies the character string that should be interpreted as a comment line prefix in the source data. All lines in the data starting with the provided string are ignored. For <a href="/content/api/cpp/namespacegpudb#ad549b432974fea84740166221365e8c5">delimited\_text</a> <a href="/content/api/cpp/namespacegpudb#af469d1b9f94100ec0f18cd29a4574533">file\_type</a> only. The default value is '#'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ae709ee514d716730e9bcc82604aee81a">insert\_records\_from\_payload\_text\_delimiter</a>: Specifies the character delimiting field values in the source data and field names in the header (if present). For <a href="/content/api/cpp/namespacegpudb#ad549b432974fea84740166221365e8c5">delimited\_text</a> <a href="/content/api/cpp/namespacegpudb#af469d1b9f94100ec0f18cd29a4574533">file\_type</a> only. The default value is ','. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aed7c7588ba80963bd447591fcc26d3ed">insert\_records\_from\_payload\_text\_escape\_character</a>: Specifies the character that is used to escape other characters in the source data. An 'a', 'b', 'f', 'n', 'r', 't', or 'v' preceded by an escape character will be interpreted as the ASCII bell, backspace, form feed, line feed, carriage return, horizontal tab, and vertical tab, respectively. For example, the escape character followed by an 'n' will be interpreted as a newline within a field value. The escape character can also be used to escape the quoting character, and will be treated as an escape character whether it is within a quoted field value or not. For <a href="/content/api/cpp/namespacegpudb#ad549b432974fea84740166221365e8c5">delimited\_text</a> <a href="/content/api/cpp/namespacegpudb#af469d1b9f94100ec0f18cd29a4574533">file\_type</a> only. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a8bed20dd14624ce1c826dd82a8e52a25">insert\_records\_from\_payload\_text\_has\_header</a>: Indicates whether the source data contains a header row. For <a href="/content/api/cpp/namespacegpudb#ad549b432974fea84740166221365e8c5">delimited\_text</a><a href="/content/api/cpp/namespacegpudb#af469d1b9f94100ec0f18cd29a4574533">file\_type</a> only. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a78005ef1c826e66f4d8e68fa30e17631">insert\_records\_from\_payload\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a0ef206a773661e5a31023163eca97109">insert\_records\_from\_payload\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a78005ef1c826e66f4d8e68fa30e17631">insert\_records\_from\_payload\_true</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#aa69bd32df1474aa16a41a8a9ceb44df4">insert\_records\_from\_payload\_text\_header\_property\_delimiter</a>: Specifies the delimiter for <a href="/content/concepts/types/#column-properties">column properties</a> in the header row (if present). Cannot be set to same value as <a href="/content/api/cpp/namespacegpudb#ae709ee514d716730e9bcc82604aee81a">text\_delimiter</a>. For <a href="/content/api/cpp/namespacegpudb#ad549b432974fea84740166221365e8c5">delimited\_text</a> <a href="/content/api/cpp/namespacegpudb#af469d1b9f94100ec0f18cd29a4574533">file\_type</a> only. The default value is '|'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ab94aa04d59b1969ee5fe928acebff03c">insert\_records\_from\_payload\_text\_null\_string</a>: Specifies the character string that should be interpreted as a null value in the source data. For <a href="/content/api/cpp/namespacegpudb#ad549b432974fea84740166221365e8c5">delimited\_text</a> <a href="/content/api/cpp/namespacegpudb#af469d1b9f94100ec0f18cd29a4574533">file\_type</a> only. The default value is '\N'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#acbcd50ae7705c29fb73c261a62893742">insert\_records\_from\_payload\_text\_quote\_character</a>: Specifies the character that should be interpreted as a field value quoting character in the source data. The character must appear at beginning and end of field value to take effect. Delimiters within quoted fields are treated as literals and not delimiters. Within a quoted field, two consecutive quote characters will be interpreted as a single literal quote character, effectively escaping it. To not have a quote character, specify an empty string. For <a href="/content/api/cpp/namespacegpudb#ad549b432974fea84740166221365e8c5">delimited\_text</a> <a href="/content/api/cpp/namespacegpudb#af469d1b9f94100ec0f18cd29a4574533">file\_type</a> only. The default value is '"'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a860776d027cc4ec6dba5af4e307eafa1">insert\_records\_from\_payload\_text\_search\_columns</a>: Add 'text\_search' property to internally inferenced string columns. Comma separated list of column names or '\*' for all columns. To add text\_search property only to string columns of minimum size, set also the option 'text\_search\_min\_column\_length'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a99b99818e0a6ef387e0a94bff01571a1">insert\_records\_from\_payload\_text\_search\_min\_column\_length</a>: Set minimum column size. Used only when 'text\_search\_columns' has a value. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a7468fe743e490e9875dcd142ed97e784">insert\_records\_from\_payload\_trim\_space</a>: If set to <a href="/content/api/cpp/namespacegpudb#a78005ef1c826e66f4d8e68fa30e17631">true</a>, remove leading or trailing space from fields. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a78005ef1c826e66f4d8e68fa30e17631">insert\_records\_from\_payload\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a0ef206a773661e5a31023163eca97109">insert\_records\_from\_payload\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a0ef206a773661e5a31023163eca97109">insert\_records\_from\_payload\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a6b68955643210874e3af8e90d5b4b6df">insert\_records\_from\_payload\_truncate\_strings</a>: If set to <a href="/content/api/cpp/namespacegpudb#a78005ef1c826e66f4d8e68fa30e17631">true</a>, truncate string values that are longer than the column's type size. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a78005ef1c826e66f4d8e68fa30e17631">insert\_records\_from\_payload\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a0ef206a773661e5a31023163eca97109">insert\_records\_from\_payload\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a0ef206a773661e5a31023163eca97109">insert\_records\_from\_payload\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ad00fb5c9c0c87a8e44b842f1a5e2e1a6">insert\_records\_from\_payload\_truncate\_table</a>: If set to <a href="/content/api/cpp/namespacegpudb#a78005ef1c826e66f4d8e68fa30e17631">true</a>, truncates the table specified by <span>tableName</span> prior to loading the file(s). Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a78005ef1c826e66f4d8e68fa30e17631">insert\_records\_from\_payload\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a0ef206a773661e5a31023163eca97109">insert\_records\_from\_payload\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a0ef206a773661e5a31023163eca97109">insert\_records\_from\_payload\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#ab79642b491dd62f4f363052b07f66636">insert\_records\_from\_payload\_type\_inference\_max\_records\_read</a>: The default value is ''. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ac3b0fd2d2d5dc9685947135e49d22151">insert\_records\_from\_payload\_type\_inference\_mode</a>: Optimize type inference mode. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a56a6ee9757c7b50e10db20ab9cbd5e3d">insert\_records\_from\_payload\_accuracy</a>: Scans data to get exactly-typed and sized columns for all data scanned. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#adf117fd856d49f9e97c72ed85e790685">insert\_records\_from\_payload\_speed</a>: Scans data and picks the widest possible column types so that 'all' values will fit with minimum data scanned. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a56a6ee9757c7b50e10db20ab9cbd5e3d">insert\_records\_from\_payload\_accuracy</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a3637f00bc68ecf09694be649e4df6043">insert\_records\_from\_payload\_enable\_inplace\_updates</a>: Applies only when upserting (when update\_on\_existing\_pk is true). If set to true (the default), an existing record matched by primary key is modified in place. If set to false, the matched record is updated by deleting it and inserting a replacement (delete and insert), which prevents the change from being reflected in dependent materialized views until they are refreshed. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a78005ef1c826e66f4d8e68fa30e17631">insert\_records\_from\_payload\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a0ef206a773661e5a31023163eca97109">insert\_records\_from\_payload\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a78005ef1c826e66f4d8e68fa30e17631">insert\_records\_from\_payload\_true</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a9a3bc53a0c4ff2da15a1dc290fe44e27">insert\_records\_from\_payload\_update\_on\_existing\_pk</a>: Specifies the record collision policy for inserting into a table with a <a href="/content/concepts/tables/#primary-keys">primary key</a>. If set to <a href="/content/api/cpp/namespacegpudb#a78005ef1c826e66f4d8e68fa30e17631">true</a>, any existing table record with primary key values that match those of a record being inserted will be replaced by that new record (the new data will be "upserted"). If set to <a href="/content/api/cpp/namespacegpudb#a0ef206a773661e5a31023163eca97109">false</a>, any existing table record with primary key values that match those of a record being inserted will remain unchanged, while the new record will be rejected and the error handled as determined by <a href="/content/api/cpp/namespacegpudb#a7987c9d97ef4b28f79fada2e3b2bdce3">ignore\_existing\_pk</a> and <a href="/content/api/cpp/namespacegpudb#a8e9826f8e1411ed8da73ccc56eaf0421">error\_handling</a>. If the specified table does not have a primary key, then this option has no effect. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a78005ef1c826e66f4d8e68fa30e17631">insert\_records\_from\_payload\_true</a>: Upsert new records when primary keys match existing records. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a0ef206a773661e5a31023163eca97109">insert\_records\_from\_payload\_false</a>: Reject new records when primary keys match existing records. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a0ef206a773661e5a31023163eca97109">insert\_records\_from\_payload\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#ab97e4380863293a1252d6df89dd27805">insert\_records\_from\_payload\_transformations</a>: Comma-separated expressions, one per target table column. Each expression is evaluated per record. Empty entries (two consecutive commas) mean no transformation for that column – the value is resolved from the input record, table default, NULL, or an error. Expressions may reference input columns by name or by position ($1 for the first input column, $2 for the second, etc.). The default value is ''. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1InsertRecordsFromPayloadResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1InsertRecordsFromPayloadResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ab280346cc3e31d912f8becba8ddce40b">◆ </a></span>insertRecordsFromQuery() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1InsertRecordsFromQueryResponse">InsertRecordsFromQueryResponse</a> gpudb::GPUdb::insertRecordsFromQuery </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1InsertRecordsFromQueryRequest">InsertRecordsFromQueryRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Computes remote query result and inserts the result data into a new or existing table. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1InsertRecordsFromQueryRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1InsertRecordsFromQueryResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#aa2adafc8b425e0d820a624bef97140b9">◆ </a></span>insertRecordsFromQuery() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1InsertRecordsFromQueryResponse">InsertRecordsFromQueryResponse</a> & gpudb::GPUdb::insertRecordsFromQuery </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1InsertRecordsFromQueryRequest">InsertRecordsFromQueryRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1InsertRecordsFromQueryResponse">InsertRecordsFromQueryResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Computes remote query result and inserts the result data into a new or existing table. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1InsertRecordsFromQueryRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1InsertRecordsFromQueryResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1InsertRecordsFromQueryResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a489ffdaaa10e9059eaf4ff23cfd7e123">◆ </a></span>insertRecordsFromQuery() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1InsertRecordsFromQueryResponse">InsertRecordsFromQueryResponse</a> gpudb::GPUdb::insertRecordsFromQuery </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>remoteQuery</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::map\< std::string, std::string > > &</td>
            <td><span><span>modifyColumns</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>createTableOptions</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Computes remote query result and inserts the result data into a new or existing table. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of the table into which the data will be inserted, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. If the table does not exist, the table will be created using either an existing <a href="/content/api/cpp/namespacegpudb#a07163b84c65b95f54fdc98db5572f49f">type\_id</a> or the type inferred from the remote query, and the new table name will have to meet standard <a href="/content/concepts/tables/#table-naming-criteria">table naming criteria</a>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>remoteQuery</td>
                <td>Query for which result data needs to be imported. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>modifyColumns</td>
                <td>Not implemented yet. The default value is an empty map. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>createTableOptions</td>

                <td>
                  <a href="/content/api/cpp/classgpudb_1_1GPUdb_1_1Options">Options</a> used when creating the target table.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a07163b84c65b95f54fdc98db5572f49f">insert\_records\_from\_query\_type\_id</a>: ID of a currently registered <a href="/content/concepts/types/">type</a>. The default value is ''. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a2730e29cfb7c4e19b41e02ee7504cd6d">insert\_records\_from\_query\_no\_error\_if\_exists</a>: If <a href="/content/api/cpp/namespacegpudb#af9a8867bafd02eb084386ec29718ac2d">true</a>, prevents an error from occurring if the table already exists and is of the given type. If a table with the same ID but a different type exists, it is still an error. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#af9a8867bafd02eb084386ec29718ac2d">insert\_records\_from\_query\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a591e1eb7d162d2a1c7b31ac248805f38">insert\_records\_from\_query\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a591e1eb7d162d2a1c7b31ac248805f38">insert\_records\_from\_query\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a7539286d340f215aa2b03b4f32ff08ee">insert\_records\_from\_query\_is\_replicated</a>: Affects the <a href="/content/concepts/tables/#distribution">distribution scheme</a> for the table's data. If <a href="/content/api/cpp/namespacegpudb#af9a8867bafd02eb084386ec29718ac2d">true</a> and the given type has no explicit <a href="/content/concepts/tables/#shard-key">shard key</a> defined, the table will be <a href="/content/concepts/tables/#replication">replicated</a>. If <a href="/content/api/cpp/namespacegpudb#a591e1eb7d162d2a1c7b31ac248805f38">false</a>, the table will be <a href="/content/concepts/tables/#sharding">sharded</a> according to the shard key specified in the given <a href="/content/api/cpp/namespacegpudb#a07163b84c65b95f54fdc98db5572f49f">type\_id</a>, or <a href="/content/concepts/tables/#random-sharding">randomly sharded</a>, if no shard key is specified. Note that a type containing a shard key cannot be used to create a replicated table. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#af9a8867bafd02eb084386ec29718ac2d">insert\_records\_from\_query\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a591e1eb7d162d2a1c7b31ac248805f38">insert\_records\_from\_query\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a591e1eb7d162d2a1c7b31ac248805f38">insert\_records\_from\_query\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a785f3f233f4d4a58e8e6de22960dc35c">insert\_records\_from\_query\_foreign\_keys</a>: Semicolon-separated list of <a href="/content/concepts/tables/#foreign-keys">foreign keys</a>, of the format '(source\_column\_name \[, ...]) references target\_table\_name(primary\_key\_column\_name \[, ...]) \[as foreign\_key\_name]'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a401f414fee90012fb15c4bb535a8a4e6">insert\_records\_from\_query\_foreign\_shard\_key</a>: Foreign shard key of the format 'source\_column references shard\_by\_column from target\_table(primary\_key\_column)'. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ab34bb204000f58015d84df7969dc387b">insert\_records\_from\_query\_partition\_type</a>: <a href="/content/concepts/tables/#partitioning">Partitioning</a> scheme to use. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ab9c85afd596460c4d1b5b767c29de385">insert\_records\_from\_query\_RANGE</a>: Use <a href="/content/concepts/tables/#partitioning-by-range">range partitioning</a>. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a0cf63c2c4caa29dc76ec098d1f89b54f">insert\_records\_from\_query\_INTERVAL</a>: Use <a href="/content/concepts/tables/#partitioning-by-interval">interval partitioning</a>. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ab50419bae654618d3e5e58eba4f296af">insert\_records\_from\_query\_LIST</a>: Use <a href="/content/concepts/tables/#partitioning-by-list">list partitioning</a>. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a356b7c25224d91ba7495f90d78f27bca">insert\_records\_from\_query\_HASH</a>: Use <a href="/content/concepts/tables/#partitioning-by-hash">hash partitioning</a>. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a1389523a9a20cbb25a2858e6cf4e04b4">insert\_records\_from\_query\_SERIES</a>: Use <a href="/content/concepts/tables/#partitioning-by-series">series partitioning</a>. </li>
                      </ul>
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#abfbb97657da743665657a58efaaf7d1f">insert\_records\_from\_query\_partition\_keys</a>: Comma-separated list of partition keys, which are the columns or column expressions by which records will be assigned to partitions defined by <a href="/content/api/cpp/namespacegpudb#a3b9e1d3259503aeacc738adf7fb72d78">partition\_definitions</a>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a3b9e1d3259503aeacc738adf7fb72d78">insert\_records\_from\_query\_partition\_definitions</a>: Comma-separated list of partition definitions, whose format depends on the choice of <a href="/content/api/cpp/namespacegpudb#ab34bb204000f58015d84df7969dc387b">partition\_type</a>. See <a href="/content/concepts/tables/#partitioning-by-range">range partitioning</a>, <a href="/content/concepts/tables/#partitioning-by-interval">interval partitioning</a>, <a href="/content/concepts/tables/#partitioning-by-list">list partitioning</a>, <a href="/content/concepts/tables/#partitioning-by-hash">hash partitioning</a>, or <a href="/content/concepts/tables/#partitioning-by-series">series partitioning</a> for example formats. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#aa6400ecba5b5c4b6b6b97018e2393054">insert\_records\_from\_query\_is\_automatic\_partition</a>: If <a href="/content/api/cpp/namespacegpudb#af9a8867bafd02eb084386ec29718ac2d">true</a>, a new partition will be created for values which don't fall into an existing partition. Currently only supported for <a href="/content/concepts/tables/#partitioning-by-list">list partitions</a>. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#af9a8867bafd02eb084386ec29718ac2d">insert\_records\_from\_query\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a591e1eb7d162d2a1c7b31ac248805f38">insert\_records\_from\_query\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a591e1eb7d162d2a1c7b31ac248805f38">insert\_records\_from\_query\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a86f50aaaa04bc0c06432ad44fa6e23c1">insert\_records\_from\_query\_ttl</a>: Sets the <a href="/content/concepts/ttl/">TTL</a> of the table specified in <span>tableName</span>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a53076260ffd6d4574095d454a77da2ea">insert\_records\_from\_query\_chunk\_size</a>: Indicates the number of records per chunk to be used for this table. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#aae43d72868da35fcc78224765809a87a">insert\_records\_from\_query\_is\_result\_table</a>: Indicates whether the table is a <a href="/content/concepts/tables_memory_only/">memory-only table</a>. A result table cannot contain columns with text\_search <a href="/content/concepts/types/#data-handling">data-handling</a>, and it will not be retained if the server is restarted. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#af9a8867bafd02eb084386ec29718ac2d">insert\_records\_from\_query\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a591e1eb7d162d2a1c7b31ac248805f38">insert\_records\_from\_query\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a591e1eb7d162d2a1c7b31ac248805f38">insert\_records\_from\_query\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a573a0c8b1efd16eab7dc17c3b98e2785">insert\_records\_from\_query\_strategy\_definition</a>: The <a href="/content/rm/concepts/#tier-strategies">tier strategy</a> for the table and its columns. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a482c099d26a265d7ea658ec32eb0b61d">insert\_records\_from\_query\_compression\_codec</a>: The default <a href="/content/concepts/column_compression/">compression codec</a> for this table's columns. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a2d6f0330b8ad9010246d2f6eb66b16e8">insert\_records\_from\_query\_bad\_record\_table\_name</a>: Name of a table to which records that were rejected are written. The bad-record-table has the following columns: line\_number (long), line\_rejected (string), error\_message (string). When error handling is Abort, bad records table is not populated. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aaae27eaaf7e20f8ec06c24b82f03582d">insert\_records\_from\_query\_bad\_record\_table\_limit</a>: A positive integer indicating the maximum number of records that can be written to the bad-record-table. Default value is 10000. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ac04fb307b5405e0fb51f02d8f6ae1d1b">insert\_records\_from\_query\_batch\_size</a>: Number of records per batch when inserting data. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ae10afb2f635aad90decc85e668d58cdd">insert\_records\_from\_query\_datasource\_name</a>: Name of an existing external data source from which table will be loaded. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a2d5febc574fb0f509aabe93a0243f21e">insert\_records\_from\_query\_error\_handling</a>: Specifies how errors should be handled upon insertion. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ae163d5eb23e647a6a923e28699e7a2c3">insert\_records\_from\_query\_permissive</a>: Records with missing columns are populated with nulls if possible; otherwise, the malformed records are skipped. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ae0468d06ba5ae2d9293449bee0b36520">insert\_records\_from\_query\_skip</a>: Malformed records are skipped. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a99f1a3b55f4c2783e6cfdcb00e4edc4a">insert\_records\_from\_query\_ignore\_bad\_records</a>: Deprecated. Alias for <a href="/content/api/cpp/namespacegpudb#ae0468d06ba5ae2d9293449bee0b36520">skip</a>. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a197f2bef924eb4a671e3520d8ce86c24">insert\_records\_from\_query\_abort</a>: Stops current insertion and aborts entire operation when an error is encountered. Primary key collisions are considered abortable errors in this mode. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a197f2bef924eb4a671e3520d8ce86c24">insert\_records\_from\_query\_abort</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#aebbab474f03c4a77e7f4dc00c6cfc512">insert\_records\_from\_query\_pk\_conflict\_predicate\_higher</a>: The record with higher value for the column resolves the primary-key insert conflict. The default value is ''. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#af4ce5bbf5889bd74427d7f74041a231a">insert\_records\_from\_query\_pk\_conflict\_predicate\_lower</a>: The record with lower value for the column resolves the primary-key insert conflict. The default value is ''. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a08241916b40295dc73b427631f972e57">insert\_records\_from\_query\_ignore\_existing\_pk</a>: Specifies the record collision error-suppression policy for inserting into a table with a <a href="/content/concepts/tables/#primary-keys">primary key</a>, only used when not in upsert mode (upsert mode is disabled when <a href="/content/api/cpp/namespacegpudb#aae19adb0ae9c32ffade911607f09b597">update\_on\_existing\_pk</a> is <a href="/content/api/cpp/namespacegpudb#a591e1eb7d162d2a1c7b31ac248805f38">false</a>). If set to <a href="/content/api/cpp/namespacegpudb#af9a8867bafd02eb084386ec29718ac2d">true</a>, any record being inserted that is rejected for having primary key values that match those of an existing table record will be ignored with no error generated. If <a href="/content/api/cpp/namespacegpudb#a591e1eb7d162d2a1c7b31ac248805f38">false</a>, the rejection of any record for having primary key values matching an existing record will result in an error being reported, as determined by <a href="/content/api/cpp/namespacegpudb#a2d5febc574fb0f509aabe93a0243f21e">error\_handling</a>. If the specified table does not have a primary key or if upsert mode is in effect (<a href="/content/api/cpp/namespacegpudb#aae19adb0ae9c32ffade911607f09b597">update\_on\_existing\_pk</a> is <a href="/content/api/cpp/namespacegpudb#af9a8867bafd02eb084386ec29718ac2d">true</a>), then this option has no effect. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#af9a8867bafd02eb084386ec29718ac2d">insert\_records\_from\_query\_true</a>: Ignore new records whose primary key values collide with those of existing records. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a591e1eb7d162d2a1c7b31ac248805f38">insert\_records\_from\_query\_false</a>: Treat as errors any new records whose primary key values collide with those of existing records. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a591e1eb7d162d2a1c7b31ac248805f38">insert\_records\_from\_query\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ac89ec8ca7ceceac31faee2e45063db1b">insert\_records\_from\_query\_ingestion\_mode</a>: Whether to do a full load, dry run, or perform a type inference on the source data. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a4ff917f1abd9d20e633f1e86b009df03">insert\_records\_from\_query\_full</a>: Run a type inference on the source data (if needed) and ingest. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a9123d9e24b8520d5b2b5b2c27b03bd41">insert\_records\_from\_query\_dry\_run</a>: Does not load data, but walks through the source data and determines the number of valid records, taking into account the current mode of <a href="/content/api/cpp/namespacegpudb#a2d5febc574fb0f509aabe93a0243f21e">error\_handling</a>. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad4e903af2ff261ee7a25325b3d4a64f1">insert\_records\_from\_query\_type\_inference\_only</a>: Infer the type of the source data and return, without ingesting any data. The inferred type is returned in the response. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a4ff917f1abd9d20e633f1e86b009df03">insert\_records\_from\_query\_full</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#ad513a35b3c772403dfee7fd4730bbd64">insert\_records\_from\_query\_jdbc\_fetch\_size</a>: The JDBC fetch size, which determines how many rows to fetch per round trip. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#af2cf7d4ab4518b4067eb27651ad669de">insert\_records\_from\_query\_jdbc\_session\_init\_statement</a>: Executes the statement per each JDBC session before doing actual load. The default value is ''. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#abf59301c6a740c2c9ee9bc476ea8501d">insert\_records\_from\_query\_num\_splits\_per\_rank</a>: Number of splits for reading data per rank. Default will be external\_file\_reader\_num\_tasks. The default value is ''. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#af76b84ae26020f656f3a23582368332b">insert\_records\_from\_query\_num\_tasks\_per\_rank</a>: Number of tasks for reading data per rank. Default will be external\_file\_reader\_num\_tasks. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a88a0cf5837c0ac20a454a0f2322cb02e">insert\_records\_from\_query\_primary\_keys</a>: Comma separated list of column names, to set as primary keys, when not specified in the type. The default value is ''. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#afacec99602bdef49640004c22eeaee3f">insert\_records\_from\_query\_shard\_keys</a>: Comma separated list of column names, to set as shard keys, when not specified in the type. The default value is ''. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a8cb2f41e124b97e6350f4ca2159dfa87">insert\_records\_from\_query\_subscribe</a>: Continuously poll the data source to check for new data and load it into the table. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#af9a8867bafd02eb084386ec29718ac2d">insert\_records\_from\_query\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a591e1eb7d162d2a1c7b31ac248805f38">insert\_records\_from\_query\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a591e1eb7d162d2a1c7b31ac248805f38">insert\_records\_from\_query\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a90b92257ff7ba79db1774cb7fe6d79a8">insert\_records\_from\_query\_truncate\_table</a>: If set to <a href="/content/api/cpp/namespacegpudb#af9a8867bafd02eb084386ec29718ac2d">true</a>, truncates the table specified by <span>tableName</span> prior to loading the data. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#af9a8867bafd02eb084386ec29718ac2d">insert\_records\_from\_query\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a591e1eb7d162d2a1c7b31ac248805f38">insert\_records\_from\_query\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a591e1eb7d162d2a1c7b31ac248805f38">insert\_records\_from\_query\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#afb2f15ae23909bb1eeac3ffc2bd1d8b1">insert\_records\_from\_query\_remote\_query</a>: Remote SQL query from which data will be sourced. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a5fc7f9ac03bda53e8ba3fe8734203dbf">insert\_records\_from\_query\_remote\_query\_order\_by</a>: Name of column to be used for splitting the query into multiple sub-queries using ordering of given column. The default value is ''. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a7d8e00a8cff13e452c4a072928daa44a">insert\_records\_from\_query\_remote\_query\_filter\_column</a>: Name of column to be used for splitting the query into multiple sub-queries using the data distribution of given column. The default value is ''. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a2d9e138a12589f35a544e7319674c363">insert\_records\_from\_query\_remote\_query\_increasing\_column</a>: Column on subscribed remote query result that will increase for new records (e.g., TIMESTAMP). The default value is ''. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#acd574e41206f0ef45c51a829cbd8fdb5">insert\_records\_from\_query\_remote\_query\_partition\_column</a>: Alias name for <a href="/content/api/cpp/namespacegpudb#a7d8e00a8cff13e452c4a072928daa44a">remote\_query\_filter\_column</a>. The default value is ''. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#aacd3d139b8e593fec9dc3b5cb5397088">insert\_records\_from\_query\_truncate\_strings</a>: If set to <a href="/content/api/cpp/namespacegpudb#af9a8867bafd02eb084386ec29718ac2d">true</a>, truncate string values that are longer than the column's type size. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#af9a8867bafd02eb084386ec29718ac2d">insert\_records\_from\_query\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a591e1eb7d162d2a1c7b31ac248805f38">insert\_records\_from\_query\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a591e1eb7d162d2a1c7b31ac248805f38">insert\_records\_from\_query\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#af2981d5c4228c4b6a503f1079d49398a">insert\_records\_from\_query\_enable\_inplace\_updates</a>: Applies only when upserting (when update\_on\_existing\_pk is true). If set to true (the default), an existing record matched by primary key is modified in place. If set to false, the matched record is updated by deleting it and inserting a replacement (delete and insert), which prevents the change from being reflected in dependent materialized views until they are refreshed. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#af9a8867bafd02eb084386ec29718ac2d">insert\_records\_from\_query\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a591e1eb7d162d2a1c7b31ac248805f38">insert\_records\_from\_query\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#af9a8867bafd02eb084386ec29718ac2d">insert\_records\_from\_query\_true</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#aae19adb0ae9c32ffade911607f09b597">insert\_records\_from\_query\_update\_on\_existing\_pk</a>: Specifies the record collision policy for inserting into a table with a <a href="/content/concepts/tables/#primary-keys">primary key</a>. If set to <a href="/content/api/cpp/namespacegpudb#af9a8867bafd02eb084386ec29718ac2d">true</a>, any existing table record with primary key values that match those of a record being inserted will be replaced by that new record (the new data will be "upserted"). If set to <a href="/content/api/cpp/namespacegpudb#a591e1eb7d162d2a1c7b31ac248805f38">false</a>, any existing table record with primary key values that match those of a record being inserted will remain unchanged, while the new record will be rejected and the error handled as determined by <a href="/content/api/cpp/namespacegpudb#a08241916b40295dc73b427631f972e57">ignore\_existing\_pk</a> and <a href="/content/api/cpp/namespacegpudb#a2d5febc574fb0f509aabe93a0243f21e">error\_handling</a>. If the specified table does not have a primary key, then this option has no effect. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#af9a8867bafd02eb084386ec29718ac2d">insert\_records\_from\_query\_true</a>: Upsert new records when primary keys match existing records. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a591e1eb7d162d2a1c7b31ac248805f38">insert\_records\_from\_query\_false</a>: Reject new records when primary keys match existing records. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a591e1eb7d162d2a1c7b31ac248805f38">insert\_records\_from\_query\_false</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1InsertRecordsFromQueryResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a5f9ff3451e098f6e68a11ddc4ddcfe7b">◆ </a></span>insertRecordsFromQuery() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1InsertRecordsFromQueryResponse">InsertRecordsFromQueryResponse</a> & gpudb::GPUdb::insertRecordsFromQuery </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>remoteQuery</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::map\< std::string, std::string > > &</td>
            <td><span><span>modifyColumns</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>createTableOptions</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1InsertRecordsFromQueryResponse">InsertRecordsFromQueryResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Computes remote query result and inserts the result data into a new or existing table. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of the table into which the data will be inserted, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. If the table does not exist, the table will be created using either an existing <a href="/content/api/cpp/namespacegpudb#a07163b84c65b95f54fdc98db5572f49f">type\_id</a> or the type inferred from the remote query, and the new table name will have to meet standard <a href="/content/concepts/tables/#table-naming-criteria">table naming criteria</a>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>remoteQuery</td>
                <td>Query for which result data needs to be imported. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>modifyColumns</td>
                <td>Not implemented yet. The default value is an empty map. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>createTableOptions</td>

                <td>
                  <a href="/content/api/cpp/classgpudb_1_1GPUdb_1_1Options">Options</a> used when creating the target table.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a07163b84c65b95f54fdc98db5572f49f">insert\_records\_from\_query\_type\_id</a>: ID of a currently registered <a href="/content/concepts/types/">type</a>. The default value is ''. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a2730e29cfb7c4e19b41e02ee7504cd6d">insert\_records\_from\_query\_no\_error\_if\_exists</a>: If <a href="/content/api/cpp/namespacegpudb#af9a8867bafd02eb084386ec29718ac2d">true</a>, prevents an error from occurring if the table already exists and is of the given type. If a table with the same ID but a different type exists, it is still an error. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#af9a8867bafd02eb084386ec29718ac2d">insert\_records\_from\_query\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a591e1eb7d162d2a1c7b31ac248805f38">insert\_records\_from\_query\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a591e1eb7d162d2a1c7b31ac248805f38">insert\_records\_from\_query\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a7539286d340f215aa2b03b4f32ff08ee">insert\_records\_from\_query\_is\_replicated</a>: Affects the <a href="/content/concepts/tables/#distribution">distribution scheme</a> for the table's data. If <a href="/content/api/cpp/namespacegpudb#af9a8867bafd02eb084386ec29718ac2d">true</a> and the given type has no explicit <a href="/content/concepts/tables/#shard-key">shard key</a> defined, the table will be <a href="/content/concepts/tables/#replication">replicated</a>. If <a href="/content/api/cpp/namespacegpudb#a591e1eb7d162d2a1c7b31ac248805f38">false</a>, the table will be <a href="/content/concepts/tables/#sharding">sharded</a> according to the shard key specified in the given <a href="/content/api/cpp/namespacegpudb#a07163b84c65b95f54fdc98db5572f49f">type\_id</a>, or <a href="/content/concepts/tables/#random-sharding">randomly sharded</a>, if no shard key is specified. Note that a type containing a shard key cannot be used to create a replicated table. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#af9a8867bafd02eb084386ec29718ac2d">insert\_records\_from\_query\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a591e1eb7d162d2a1c7b31ac248805f38">insert\_records\_from\_query\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a591e1eb7d162d2a1c7b31ac248805f38">insert\_records\_from\_query\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a785f3f233f4d4a58e8e6de22960dc35c">insert\_records\_from\_query\_foreign\_keys</a>: Semicolon-separated list of <a href="/content/concepts/tables/#foreign-keys">foreign keys</a>, of the format '(source\_column\_name \[, ...]) references target\_table\_name(primary\_key\_column\_name \[, ...]) \[as foreign\_key\_name]'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a401f414fee90012fb15c4bb535a8a4e6">insert\_records\_from\_query\_foreign\_shard\_key</a>: Foreign shard key of the format 'source\_column references shard\_by\_column from target\_table(primary\_key\_column)'. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ab34bb204000f58015d84df7969dc387b">insert\_records\_from\_query\_partition\_type</a>: <a href="/content/concepts/tables/#partitioning">Partitioning</a> scheme to use. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ab9c85afd596460c4d1b5b767c29de385">insert\_records\_from\_query\_RANGE</a>: Use <a href="/content/concepts/tables/#partitioning-by-range">range partitioning</a>. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a0cf63c2c4caa29dc76ec098d1f89b54f">insert\_records\_from\_query\_INTERVAL</a>: Use <a href="/content/concepts/tables/#partitioning-by-interval">interval partitioning</a>. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ab50419bae654618d3e5e58eba4f296af">insert\_records\_from\_query\_LIST</a>: Use <a href="/content/concepts/tables/#partitioning-by-list">list partitioning</a>. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a356b7c25224d91ba7495f90d78f27bca">insert\_records\_from\_query\_HASH</a>: Use <a href="/content/concepts/tables/#partitioning-by-hash">hash partitioning</a>. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a1389523a9a20cbb25a2858e6cf4e04b4">insert\_records\_from\_query\_SERIES</a>: Use <a href="/content/concepts/tables/#partitioning-by-series">series partitioning</a>. </li>
                      </ul>
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#abfbb97657da743665657a58efaaf7d1f">insert\_records\_from\_query\_partition\_keys</a>: Comma-separated list of partition keys, which are the columns or column expressions by which records will be assigned to partitions defined by <a href="/content/api/cpp/namespacegpudb#a3b9e1d3259503aeacc738adf7fb72d78">partition\_definitions</a>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a3b9e1d3259503aeacc738adf7fb72d78">insert\_records\_from\_query\_partition\_definitions</a>: Comma-separated list of partition definitions, whose format depends on the choice of <a href="/content/api/cpp/namespacegpudb#ab34bb204000f58015d84df7969dc387b">partition\_type</a>. See <a href="/content/concepts/tables/#partitioning-by-range">range partitioning</a>, <a href="/content/concepts/tables/#partitioning-by-interval">interval partitioning</a>, <a href="/content/concepts/tables/#partitioning-by-list">list partitioning</a>, <a href="/content/concepts/tables/#partitioning-by-hash">hash partitioning</a>, or <a href="/content/concepts/tables/#partitioning-by-series">series partitioning</a> for example formats. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#aa6400ecba5b5c4b6b6b97018e2393054">insert\_records\_from\_query\_is\_automatic\_partition</a>: If <a href="/content/api/cpp/namespacegpudb#af9a8867bafd02eb084386ec29718ac2d">true</a>, a new partition will be created for values which don't fall into an existing partition. Currently only supported for <a href="/content/concepts/tables/#partitioning-by-list">list partitions</a>. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#af9a8867bafd02eb084386ec29718ac2d">insert\_records\_from\_query\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a591e1eb7d162d2a1c7b31ac248805f38">insert\_records\_from\_query\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a591e1eb7d162d2a1c7b31ac248805f38">insert\_records\_from\_query\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a86f50aaaa04bc0c06432ad44fa6e23c1">insert\_records\_from\_query\_ttl</a>: Sets the <a href="/content/concepts/ttl/">TTL</a> of the table specified in <span>tableName</span>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a53076260ffd6d4574095d454a77da2ea">insert\_records\_from\_query\_chunk\_size</a>: Indicates the number of records per chunk to be used for this table. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#aae43d72868da35fcc78224765809a87a">insert\_records\_from\_query\_is\_result\_table</a>: Indicates whether the table is a <a href="/content/concepts/tables_memory_only/">memory-only table</a>. A result table cannot contain columns with text\_search <a href="/content/concepts/types/#data-handling">data-handling</a>, and it will not be retained if the server is restarted. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#af9a8867bafd02eb084386ec29718ac2d">insert\_records\_from\_query\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a591e1eb7d162d2a1c7b31ac248805f38">insert\_records\_from\_query\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a591e1eb7d162d2a1c7b31ac248805f38">insert\_records\_from\_query\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a573a0c8b1efd16eab7dc17c3b98e2785">insert\_records\_from\_query\_strategy\_definition</a>: The <a href="/content/rm/concepts/#tier-strategies">tier strategy</a> for the table and its columns. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a482c099d26a265d7ea658ec32eb0b61d">insert\_records\_from\_query\_compression\_codec</a>: The default <a href="/content/concepts/column_compression/">compression codec</a> for this table's columns. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a2d6f0330b8ad9010246d2f6eb66b16e8">insert\_records\_from\_query\_bad\_record\_table\_name</a>: Name of a table to which records that were rejected are written. The bad-record-table has the following columns: line\_number (long), line\_rejected (string), error\_message (string). When error handling is Abort, bad records table is not populated. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aaae27eaaf7e20f8ec06c24b82f03582d">insert\_records\_from\_query\_bad\_record\_table\_limit</a>: A positive integer indicating the maximum number of records that can be written to the bad-record-table. Default value is 10000. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ac04fb307b5405e0fb51f02d8f6ae1d1b">insert\_records\_from\_query\_batch\_size</a>: Number of records per batch when inserting data. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ae10afb2f635aad90decc85e668d58cdd">insert\_records\_from\_query\_datasource\_name</a>: Name of an existing external data source from which table will be loaded. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a2d5febc574fb0f509aabe93a0243f21e">insert\_records\_from\_query\_error\_handling</a>: Specifies how errors should be handled upon insertion. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ae163d5eb23e647a6a923e28699e7a2c3">insert\_records\_from\_query\_permissive</a>: Records with missing columns are populated with nulls if possible; otherwise, the malformed records are skipped. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ae0468d06ba5ae2d9293449bee0b36520">insert\_records\_from\_query\_skip</a>: Malformed records are skipped. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a99f1a3b55f4c2783e6cfdcb00e4edc4a">insert\_records\_from\_query\_ignore\_bad\_records</a>: Deprecated. Alias for <a href="/content/api/cpp/namespacegpudb#ae0468d06ba5ae2d9293449bee0b36520">skip</a>. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a197f2bef924eb4a671e3520d8ce86c24">insert\_records\_from\_query\_abort</a>: Stops current insertion and aborts entire operation when an error is encountered. Primary key collisions are considered abortable errors in this mode. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a197f2bef924eb4a671e3520d8ce86c24">insert\_records\_from\_query\_abort</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#aebbab474f03c4a77e7f4dc00c6cfc512">insert\_records\_from\_query\_pk\_conflict\_predicate\_higher</a>: The record with higher value for the column resolves the primary-key insert conflict. The default value is ''. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#af4ce5bbf5889bd74427d7f74041a231a">insert\_records\_from\_query\_pk\_conflict\_predicate\_lower</a>: The record with lower value for the column resolves the primary-key insert conflict. The default value is ''. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a08241916b40295dc73b427631f972e57">insert\_records\_from\_query\_ignore\_existing\_pk</a>: Specifies the record collision error-suppression policy for inserting into a table with a <a href="/content/concepts/tables/#primary-keys">primary key</a>, only used when not in upsert mode (upsert mode is disabled when <a href="/content/api/cpp/namespacegpudb#aae19adb0ae9c32ffade911607f09b597">update\_on\_existing\_pk</a> is <a href="/content/api/cpp/namespacegpudb#a591e1eb7d162d2a1c7b31ac248805f38">false</a>). If set to <a href="/content/api/cpp/namespacegpudb#af9a8867bafd02eb084386ec29718ac2d">true</a>, any record being inserted that is rejected for having primary key values that match those of an existing table record will be ignored with no error generated. If <a href="/content/api/cpp/namespacegpudb#a591e1eb7d162d2a1c7b31ac248805f38">false</a>, the rejection of any record for having primary key values matching an existing record will result in an error being reported, as determined by <a href="/content/api/cpp/namespacegpudb#a2d5febc574fb0f509aabe93a0243f21e">error\_handling</a>. If the specified table does not have a primary key or if upsert mode is in effect (<a href="/content/api/cpp/namespacegpudb#aae19adb0ae9c32ffade911607f09b597">update\_on\_existing\_pk</a> is <a href="/content/api/cpp/namespacegpudb#af9a8867bafd02eb084386ec29718ac2d">true</a>), then this option has no effect. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#af9a8867bafd02eb084386ec29718ac2d">insert\_records\_from\_query\_true</a>: Ignore new records whose primary key values collide with those of existing records. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a591e1eb7d162d2a1c7b31ac248805f38">insert\_records\_from\_query\_false</a>: Treat as errors any new records whose primary key values collide with those of existing records. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a591e1eb7d162d2a1c7b31ac248805f38">insert\_records\_from\_query\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ac89ec8ca7ceceac31faee2e45063db1b">insert\_records\_from\_query\_ingestion\_mode</a>: Whether to do a full load, dry run, or perform a type inference on the source data. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a4ff917f1abd9d20e633f1e86b009df03">insert\_records\_from\_query\_full</a>: Run a type inference on the source data (if needed) and ingest. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a9123d9e24b8520d5b2b5b2c27b03bd41">insert\_records\_from\_query\_dry\_run</a>: Does not load data, but walks through the source data and determines the number of valid records, taking into account the current mode of <a href="/content/api/cpp/namespacegpudb#a2d5febc574fb0f509aabe93a0243f21e">error\_handling</a>. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad4e903af2ff261ee7a25325b3d4a64f1">insert\_records\_from\_query\_type\_inference\_only</a>: Infer the type of the source data and return, without ingesting any data. The inferred type is returned in the response. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a4ff917f1abd9d20e633f1e86b009df03">insert\_records\_from\_query\_full</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#ad513a35b3c772403dfee7fd4730bbd64">insert\_records\_from\_query\_jdbc\_fetch\_size</a>: The JDBC fetch size, which determines how many rows to fetch per round trip. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#af2cf7d4ab4518b4067eb27651ad669de">insert\_records\_from\_query\_jdbc\_session\_init\_statement</a>: Executes the statement per each JDBC session before doing actual load. The default value is ''. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#abf59301c6a740c2c9ee9bc476ea8501d">insert\_records\_from\_query\_num\_splits\_per\_rank</a>: Number of splits for reading data per rank. Default will be external\_file\_reader\_num\_tasks. The default value is ''. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#af76b84ae26020f656f3a23582368332b">insert\_records\_from\_query\_num\_tasks\_per\_rank</a>: Number of tasks for reading data per rank. Default will be external\_file\_reader\_num\_tasks. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a88a0cf5837c0ac20a454a0f2322cb02e">insert\_records\_from\_query\_primary\_keys</a>: Comma separated list of column names, to set as primary keys, when not specified in the type. The default value is ''. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#afacec99602bdef49640004c22eeaee3f">insert\_records\_from\_query\_shard\_keys</a>: Comma separated list of column names, to set as shard keys, when not specified in the type. The default value is ''. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a8cb2f41e124b97e6350f4ca2159dfa87">insert\_records\_from\_query\_subscribe</a>: Continuously poll the data source to check for new data and load it into the table. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#af9a8867bafd02eb084386ec29718ac2d">insert\_records\_from\_query\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a591e1eb7d162d2a1c7b31ac248805f38">insert\_records\_from\_query\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a591e1eb7d162d2a1c7b31ac248805f38">insert\_records\_from\_query\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a90b92257ff7ba79db1774cb7fe6d79a8">insert\_records\_from\_query\_truncate\_table</a>: If set to <a href="/content/api/cpp/namespacegpudb#af9a8867bafd02eb084386ec29718ac2d">true</a>, truncates the table specified by <span>tableName</span> prior to loading the data. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#af9a8867bafd02eb084386ec29718ac2d">insert\_records\_from\_query\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a591e1eb7d162d2a1c7b31ac248805f38">insert\_records\_from\_query\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a591e1eb7d162d2a1c7b31ac248805f38">insert\_records\_from\_query\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#afb2f15ae23909bb1eeac3ffc2bd1d8b1">insert\_records\_from\_query\_remote\_query</a>: Remote SQL query from which data will be sourced. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a5fc7f9ac03bda53e8ba3fe8734203dbf">insert\_records\_from\_query\_remote\_query\_order\_by</a>: Name of column to be used for splitting the query into multiple sub-queries using ordering of given column. The default value is ''. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a7d8e00a8cff13e452c4a072928daa44a">insert\_records\_from\_query\_remote\_query\_filter\_column</a>: Name of column to be used for splitting the query into multiple sub-queries using the data distribution of given column. The default value is ''. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a2d9e138a12589f35a544e7319674c363">insert\_records\_from\_query\_remote\_query\_increasing\_column</a>: Column on subscribed remote query result that will increase for new records (e.g., TIMESTAMP). The default value is ''. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#acd574e41206f0ef45c51a829cbd8fdb5">insert\_records\_from\_query\_remote\_query\_partition\_column</a>: Alias name for <a href="/content/api/cpp/namespacegpudb#a7d8e00a8cff13e452c4a072928daa44a">remote\_query\_filter\_column</a>. The default value is ''. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#aacd3d139b8e593fec9dc3b5cb5397088">insert\_records\_from\_query\_truncate\_strings</a>: If set to <a href="/content/api/cpp/namespacegpudb#af9a8867bafd02eb084386ec29718ac2d">true</a>, truncate string values that are longer than the column's type size. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#af9a8867bafd02eb084386ec29718ac2d">insert\_records\_from\_query\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a591e1eb7d162d2a1c7b31ac248805f38">insert\_records\_from\_query\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a591e1eb7d162d2a1c7b31ac248805f38">insert\_records\_from\_query\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#af2981d5c4228c4b6a503f1079d49398a">insert\_records\_from\_query\_enable\_inplace\_updates</a>: Applies only when upserting (when update\_on\_existing\_pk is true). If set to true (the default), an existing record matched by primary key is modified in place. If set to false, the matched record is updated by deleting it and inserting a replacement (delete and insert), which prevents the change from being reflected in dependent materialized views until they are refreshed. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#af9a8867bafd02eb084386ec29718ac2d">insert\_records\_from\_query\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a591e1eb7d162d2a1c7b31ac248805f38">insert\_records\_from\_query\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#af9a8867bafd02eb084386ec29718ac2d">insert\_records\_from\_query\_true</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#aae19adb0ae9c32ffade911607f09b597">insert\_records\_from\_query\_update\_on\_existing\_pk</a>: Specifies the record collision policy for inserting into a table with a <a href="/content/concepts/tables/#primary-keys">primary key</a>. If set to <a href="/content/api/cpp/namespacegpudb#af9a8867bafd02eb084386ec29718ac2d">true</a>, any existing table record with primary key values that match those of a record being inserted will be replaced by that new record (the new data will be "upserted"). If set to <a href="/content/api/cpp/namespacegpudb#a591e1eb7d162d2a1c7b31ac248805f38">false</a>, any existing table record with primary key values that match those of a record being inserted will remain unchanged, while the new record will be rejected and the error handled as determined by <a href="/content/api/cpp/namespacegpudb#a08241916b40295dc73b427631f972e57">ignore\_existing\_pk</a> and <a href="/content/api/cpp/namespacegpudb#a2d5febc574fb0f509aabe93a0243f21e">error\_handling</a>. If the specified table does not have a primary key, then this option has no effect. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#af9a8867bafd02eb084386ec29718ac2d">insert\_records\_from\_query\_true</a>: Upsert new records when primary keys match existing records. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a591e1eb7d162d2a1c7b31ac248805f38">insert\_records\_from\_query\_false</a>: Reject new records when primary keys match existing records. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a591e1eb7d162d2a1c7b31ac248805f38">insert\_records\_from\_query\_false</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1InsertRecordsFromQueryResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1InsertRecordsFromQueryResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a5609aacb2f2c2a35c82db9f69747404a">◆ </a></span>insertRecordsRandom() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1InsertRecordsRandomResponse">InsertRecordsRandomResponse</a> gpudb::GPUdb::insertRecordsRandom </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1InsertRecordsRandomRequest">InsertRecordsRandomRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Generates a specified number of random records and adds them to the given table. </p>
        <p>There is an optional parameter that allows the user to customize the ranges of the column values. It also allows the user to specify linear profiles for some or all columns in which case linear values are generated rather than random ones. Only individual tables are supported for this operation.</p>
        <p>This operation is synchronous, meaning that a response will not be returned until all random records are fully available.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1InsertRecordsRandomRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1InsertRecordsRandomResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a2731d20cecb1dc84074c01cd45ddb7a9">◆ </a></span>insertRecordsRandom() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1InsertRecordsRandomResponse">InsertRecordsRandomResponse</a> & gpudb::GPUdb::insertRecordsRandom </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1InsertRecordsRandomRequest">InsertRecordsRandomRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1InsertRecordsRandomResponse">InsertRecordsRandomResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Generates a specified number of random records and adds them to the given table. </p>
        <p>There is an optional parameter that allows the user to customize the ranges of the column values. It also allows the user to specify linear profiles for some or all columns in which case linear values are generated rather than random ones. Only individual tables are supported for this operation.</p>
        <p>This operation is synchronous, meaning that a response will not be returned until all random records are fully available.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1InsertRecordsRandomRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1InsertRecordsRandomResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1InsertRecordsRandomResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a88ab670876d6ac282d90baeb96478956">◆ </a></span>insertRecordsRandom() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1InsertRecordsRandomResponse">InsertRecordsRandomResponse</a> gpudb::GPUdb::insertRecordsRandom </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const int64\_t</td>
            <td><span><span>count</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::map\< std::string, double > > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Generates a specified number of random records and adds them to the given table. </p>
        <p>There is an optional parameter that allows the user to customize the ranges of the column values. It also allows the user to specify linear profiles for some or all columns in which case linear values are generated rather than random ones. Only individual tables are supported for this operation.</p>
        <p>This operation is synchronous, meaning that a response will not be returned until all random records are fully available.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Table to which random records will be added, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. Must be an existing table, not a view. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>count</td>
                <td>Number of records to generate. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameter to pass in specifications for the randomness of the values. This map is different from the <span>options</span> parameter of most other endpoints in that it is a map of string to map of string to doubles, while most others are maps of string to string. In this map, the top level keys represent which column's parameters are being specified, while the internal keys represents which parameter is being specified. These parameters take on different meanings depending on the type of the column.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a3a47eb3c9717d32bdf6246b09d314b5e">insert\_records\_random\_seed</a>: If provided, the internal random number generator will be initialized with the given value. The minimum is 0. This allows for the same set of random numbers to be generated across invocation of this endpoint in case the user wants to repeat the test. Since <span>options</span>, is a map of maps, we need an internal map to provide the seed value. For example, to pass 100 as the seed value through this parameter, you need something equivalent to: 'options' = 'seed':  'value': 100  .

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a14f89f731b7bebf0b3b4b0eb663d1aff">insert\_records\_random\_value</a>: The seed value to use. </li>
                      </ul>
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a61dab5043197b18dc5aa502b03a488ae">insert\_records\_random\_all</a>: This key indicates that the specifications relayed in the internal map are to be applied to all columns of the records.

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a7212fd8f4d59b0a3e48df5a5e11af914">insert\_records\_random\_min</a>: For numerical columns, the minimum of the generated values is set to this value. Default is -99999. For point, shape, and track columns, min for numeric 'x' and 'y' columns needs to be within \[-180, 180] and \[-90, 90], respectively. The default minimum possible values for these columns in such cases are -180.0 and -90.0. For the 'TIMESTAMP' column, the default minimum corresponds to Jan 1, 2010. For string columns, the minimum length of the randomly generated strings is set to this value (default is 0). If both minimum and maximum are provided, minimum must be less than or equal to max. If the min is outside the accepted ranges for strings columns and 'x' and 'y' columns for point/shape/track, then those parameters will not be set; however, an error will not be thrown in such a case. It is the responsibility of the user to use the <a href="/content/api/cpp/namespacegpudb#a61dab5043197b18dc5aa502b03a488ae">all</a> parameter judiciously. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aa014ca0414df10ca93297b0356c99a3b">insert\_records\_random\_max</a>: For numerical columns, the maximum of the generated values is set to this value. Default is 99999. For point, shape, and track columns, max for numeric 'x' and 'y' columns needs to be within \[-180, 180] and \[-90, 90], respectively. The default minimum possible values for these columns in such cases are 180.0 and 90.0. For string columns, the maximum length of the randomly generated strings. If both minimum and maximum are provided, <span>max</span> must be greater than or equal to <span>min</span>. If the <span>max</span> is outside the accepted ranges for strings columns and 'x' and 'y' columns for point/shape/track, then those parameters will not be set; however, an error will not be thrown in such a case. It is the responsibility of the user to use the <a href="/content/api/cpp/namespacegpudb#a61dab5043197b18dc5aa502b03a488ae">all</a> parameter judiciously. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a573bb4a6db42fe84c90d6783ec3ce584">insert\_records\_random\_interval</a>: If specified, generate values for all columns evenly spaced with the given interval value. If a max value is specified for a given column the data is randomly generated between min and max and decimated down to the interval. If no max is provided the data is linearly generated starting at the minimum value (instead of generating random data). For non-decimated string-type columns the interval value is ignored. Instead the values are generated following the pattern: 'attrname\_creationIndex#', i.e. the column name suffixed with an underscore and a running counter (starting at 0). For string types with limited size (e.g. char4) the prefix is dropped. No nulls will be generated for nullable columns. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#adc4e1a54ee77b5a6d4707127aca1e92d">insert\_records\_random\_null\_percentage</a>: If specified, then generate the given percentage of the count as nulls for all nullable columns. This option will be ignored for non-nullable columns. The value must be within the range \[0, 1.0]. The default value is 5% (0.05). </li>

                        <li>
                          <a href="/content/api/cpp/namespacegpudb#a49bcb2ef666ae4f8179ddfbf603817ce">insert\_records\_random\_cardinality</a>: If specified, limit the randomly generated values to a fixed set. Not allowed on a column with interval specified, and is not applicable to WKT or Track-specific columns. The value must be greater than

                          <ol type="1">
                            <li>This option is disabled by default. </li>
                          </ol>
                        </li>
                      </ul>
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a5078ef6cf8caab1135d620e1373eb288">insert\_records\_random\_attr\_name</a>: Use the desired column name in place of <a href="/content/api/cpp/namespacegpudb#a5078ef6cf8caab1135d620e1373eb288">attr\_name</a>, and set the following parameters for the column specified. This overrides any parameter set by <a href="/content/api/cpp/namespacegpudb#a61dab5043197b18dc5aa502b03a488ae">all</a>.

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a7212fd8f4d59b0a3e48df5a5e11af914">insert\_records\_random\_min</a>: For numerical columns, the minimum of the generated values is set to this value. Default is -99999. For point, shape, and track columns, min for numeric 'x' and 'y' columns needs to be within \[-180, 180] and \[-90, 90], respectively. The default minimum possible values for these columns in such cases are -180.0 and -90.0. For the 'TIMESTAMP' column, the default minimum corresponds to Jan 1, 2010. For string columns, the minimum length of the randomly generated strings is set to this value (default is 0). If both minimum and maximum are provided, minimum must be less than or equal to max. If the min is outside the accepted ranges for strings columns and 'x' and 'y' columns for point/shape/track, then those parameters will not be set; however, an error will not be thrown in such a case. It is the responsibility of the user to use the <a href="/content/api/cpp/namespacegpudb#a61dab5043197b18dc5aa502b03a488ae">all</a> parameter judiciously. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aa014ca0414df10ca93297b0356c99a3b">insert\_records\_random\_max</a>: For numerical columns, the maximum of the generated values is set to this value. Default is 99999. For point, shape, and track columns, max for numeric 'x' and 'y' columns needs to be within \[-180, 180] and \[-90, 90], respectively. The default minimum possible values for these columns in such cases are 180.0 and 90.0. For string columns, the maximum length of the randomly generated strings. If both minimum and maximum are provided, <span>max</span> must be greater than or equal to <span>min</span>. If the <span>max</span> is outside the accepted ranges for strings columns and 'x' and 'y' columns for point/shape/track, then those parameters will not be set; however, an error will not be thrown in such a case. It is the responsibility of the user to use the <a href="/content/api/cpp/namespacegpudb#a61dab5043197b18dc5aa502b03a488ae">all</a> parameter judiciously. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a573bb4a6db42fe84c90d6783ec3ce584">insert\_records\_random\_interval</a>: If specified, generate values for all columns evenly spaced with the given interval value. If a max value is specified for a given column the data is randomly generated between min and max and decimated down to the interval. If no max is provided the data is linearly generated starting at the minimum value (instead of generating random data). For non-decimated string-type columns the interval value is ignored. Instead the values are generated following the pattern: 'attrname\_creationIndex#', i.e. the column name suffixed with an underscore and a running counter (starting at 0). For string types with limited size (e.g. char4) the prefix is dropped. No nulls will be generated for nullable columns. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#adc4e1a54ee77b5a6d4707127aca1e92d">insert\_records\_random\_null\_percentage</a>: If specified and if this column is nullable, then generate the given percentage of the count as nulls. This option will result in an error if the column is not nullable. The value must be within the range \[0, 1.0]. The default value is 5% (0.05). </li>

                        <li>
                          <a href="/content/api/cpp/namespacegpudb#a49bcb2ef666ae4f8179ddfbf603817ce">insert\_records\_random\_cardinality</a>: If specified, limit the randomly generated values to a fixed set. Not allowed on a column with interval specified, and is not applicable to WKT or Track-specific columns. The value must be greater than

                          <ol type="1">
                            <li>This option is disabled by default. </li>
                          </ol>
                        </li>
                      </ul>
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a33761bebd725c71887ad15f1064d9cdd">insert\_records\_random\_track\_length</a>: This key-map pair is only valid for track data sets (an error is thrown otherwise). No nulls would be generated for nullable columns.

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a7212fd8f4d59b0a3e48df5a5e11af914">insert\_records\_random\_min</a>: Minimum possible length for generated series; default is 100 records per series. Must be an integral value within the range \[1, 500]. If both min and max are specified, min must be less than or equal to max. The minimum allowed value is 1. The maximum allowed value is 500. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aa014ca0414df10ca93297b0356c99a3b">insert\_records\_random\_max</a>: Maximum possible length for generated series; default is 500 records per series. Must be an integral value within the range \[1, 500]. If both min and max are specified, max must be greater than or equal to min. The minimum allowed value is 1. The maximum allowed value is 500. </li>
                      </ul>
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1InsertRecordsRandomResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#af2dfe3668aed5e4912b1f8feba700c37">◆ </a></span>insertRecordsRandom() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1InsertRecordsRandomResponse">InsertRecordsRandomResponse</a> & gpudb::GPUdb::insertRecordsRandom </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const int64\_t</td>
            <td><span><span>count</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::map\< std::string, double > > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1InsertRecordsRandomResponse">InsertRecordsRandomResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Generates a specified number of random records and adds them to the given table. </p>
        <p>There is an optional parameter that allows the user to customize the ranges of the column values. It also allows the user to specify linear profiles for some or all columns in which case linear values are generated rather than random ones. Only individual tables are supported for this operation.</p>
        <p>This operation is synchronous, meaning that a response will not be returned until all random records are fully available.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Table to which random records will be added, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. Must be an existing table, not a view. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>count</td>
                <td>Number of records to generate. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameter to pass in specifications for the randomness of the values. This map is different from the <span>options</span> parameter of most other endpoints in that it is a map of string to map of string to doubles, while most others are maps of string to string. In this map, the top level keys represent which column's parameters are being specified, while the internal keys represents which parameter is being specified. These parameters take on different meanings depending on the type of the column.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a3a47eb3c9717d32bdf6246b09d314b5e">insert\_records\_random\_seed</a>: If provided, the internal random number generator will be initialized with the given value. The minimum is 0. This allows for the same set of random numbers to be generated across invocation of this endpoint in case the user wants to repeat the test. Since <span>options</span>, is a map of maps, we need an internal map to provide the seed value. For example, to pass 100 as the seed value through this parameter, you need something equivalent to: 'options' = 'seed':  'value': 100  .

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a14f89f731b7bebf0b3b4b0eb663d1aff">insert\_records\_random\_value</a>: The seed value to use. </li>
                      </ul>
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a61dab5043197b18dc5aa502b03a488ae">insert\_records\_random\_all</a>: This key indicates that the specifications relayed in the internal map are to be applied to all columns of the records.

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a7212fd8f4d59b0a3e48df5a5e11af914">insert\_records\_random\_min</a>: For numerical columns, the minimum of the generated values is set to this value. Default is -99999. For point, shape, and track columns, min for numeric 'x' and 'y' columns needs to be within \[-180, 180] and \[-90, 90], respectively. The default minimum possible values for these columns in such cases are -180.0 and -90.0. For the 'TIMESTAMP' column, the default minimum corresponds to Jan 1, 2010. For string columns, the minimum length of the randomly generated strings is set to this value (default is 0). If both minimum and maximum are provided, minimum must be less than or equal to max. If the min is outside the accepted ranges for strings columns and 'x' and 'y' columns for point/shape/track, then those parameters will not be set; however, an error will not be thrown in such a case. It is the responsibility of the user to use the <a href="/content/api/cpp/namespacegpudb#a61dab5043197b18dc5aa502b03a488ae">all</a> parameter judiciously. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aa014ca0414df10ca93297b0356c99a3b">insert\_records\_random\_max</a>: For numerical columns, the maximum of the generated values is set to this value. Default is 99999. For point, shape, and track columns, max for numeric 'x' and 'y' columns needs to be within \[-180, 180] and \[-90, 90], respectively. The default minimum possible values for these columns in such cases are 180.0 and 90.0. For string columns, the maximum length of the randomly generated strings. If both minimum and maximum are provided, <span>max</span> must be greater than or equal to <span>min</span>. If the <span>max</span> is outside the accepted ranges for strings columns and 'x' and 'y' columns for point/shape/track, then those parameters will not be set; however, an error will not be thrown in such a case. It is the responsibility of the user to use the <a href="/content/api/cpp/namespacegpudb#a61dab5043197b18dc5aa502b03a488ae">all</a> parameter judiciously. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a573bb4a6db42fe84c90d6783ec3ce584">insert\_records\_random\_interval</a>: If specified, generate values for all columns evenly spaced with the given interval value. If a max value is specified for a given column the data is randomly generated between min and max and decimated down to the interval. If no max is provided the data is linearly generated starting at the minimum value (instead of generating random data). For non-decimated string-type columns the interval value is ignored. Instead the values are generated following the pattern: 'attrname\_creationIndex#', i.e. the column name suffixed with an underscore and a running counter (starting at 0). For string types with limited size (e.g. char4) the prefix is dropped. No nulls will be generated for nullable columns. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#adc4e1a54ee77b5a6d4707127aca1e92d">insert\_records\_random\_null\_percentage</a>: If specified, then generate the given percentage of the count as nulls for all nullable columns. This option will be ignored for non-nullable columns. The value must be within the range \[0, 1.0]. The default value is 5% (0.05). </li>

                        <li>
                          <a href="/content/api/cpp/namespacegpudb#a49bcb2ef666ae4f8179ddfbf603817ce">insert\_records\_random\_cardinality</a>: If specified, limit the randomly generated values to a fixed set. Not allowed on a column with interval specified, and is not applicable to WKT or Track-specific columns. The value must be greater than

                          <ol type="1">
                            <li>This option is disabled by default. </li>
                          </ol>
                        </li>
                      </ul>
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a5078ef6cf8caab1135d620e1373eb288">insert\_records\_random\_attr\_name</a>: Use the desired column name in place of <a href="/content/api/cpp/namespacegpudb#a5078ef6cf8caab1135d620e1373eb288">attr\_name</a>, and set the following parameters for the column specified. This overrides any parameter set by <a href="/content/api/cpp/namespacegpudb#a61dab5043197b18dc5aa502b03a488ae">all</a>.

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a7212fd8f4d59b0a3e48df5a5e11af914">insert\_records\_random\_min</a>: For numerical columns, the minimum of the generated values is set to this value. Default is -99999. For point, shape, and track columns, min for numeric 'x' and 'y' columns needs to be within \[-180, 180] and \[-90, 90], respectively. The default minimum possible values for these columns in such cases are -180.0 and -90.0. For the 'TIMESTAMP' column, the default minimum corresponds to Jan 1, 2010. For string columns, the minimum length of the randomly generated strings is set to this value (default is 0). If both minimum and maximum are provided, minimum must be less than or equal to max. If the min is outside the accepted ranges for strings columns and 'x' and 'y' columns for point/shape/track, then those parameters will not be set; however, an error will not be thrown in such a case. It is the responsibility of the user to use the <a href="/content/api/cpp/namespacegpudb#a61dab5043197b18dc5aa502b03a488ae">all</a> parameter judiciously. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aa014ca0414df10ca93297b0356c99a3b">insert\_records\_random\_max</a>: For numerical columns, the maximum of the generated values is set to this value. Default is 99999. For point, shape, and track columns, max for numeric 'x' and 'y' columns needs to be within \[-180, 180] and \[-90, 90], respectively. The default minimum possible values for these columns in such cases are 180.0 and 90.0. For string columns, the maximum length of the randomly generated strings. If both minimum and maximum are provided, <span>max</span> must be greater than or equal to <span>min</span>. If the <span>max</span> is outside the accepted ranges for strings columns and 'x' and 'y' columns for point/shape/track, then those parameters will not be set; however, an error will not be thrown in such a case. It is the responsibility of the user to use the <a href="/content/api/cpp/namespacegpudb#a61dab5043197b18dc5aa502b03a488ae">all</a> parameter judiciously. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a573bb4a6db42fe84c90d6783ec3ce584">insert\_records\_random\_interval</a>: If specified, generate values for all columns evenly spaced with the given interval value. If a max value is specified for a given column the data is randomly generated between min and max and decimated down to the interval. If no max is provided the data is linearly generated starting at the minimum value (instead of generating random data). For non-decimated string-type columns the interval value is ignored. Instead the values are generated following the pattern: 'attrname\_creationIndex#', i.e. the column name suffixed with an underscore and a running counter (starting at 0). For string types with limited size (e.g. char4) the prefix is dropped. No nulls will be generated for nullable columns. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#adc4e1a54ee77b5a6d4707127aca1e92d">insert\_records\_random\_null\_percentage</a>: If specified and if this column is nullable, then generate the given percentage of the count as nulls. This option will result in an error if the column is not nullable. The value must be within the range \[0, 1.0]. The default value is 5% (0.05). </li>

                        <li>
                          <a href="/content/api/cpp/namespacegpudb#a49bcb2ef666ae4f8179ddfbf603817ce">insert\_records\_random\_cardinality</a>: If specified, limit the randomly generated values to a fixed set. Not allowed on a column with interval specified, and is not applicable to WKT or Track-specific columns. The value must be greater than

                          <ol type="1">
                            <li>This option is disabled by default. </li>
                          </ol>
                        </li>
                      </ul>
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a33761bebd725c71887ad15f1064d9cdd">insert\_records\_random\_track\_length</a>: This key-map pair is only valid for track data sets (an error is thrown otherwise). No nulls would be generated for nullable columns.

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a7212fd8f4d59b0a3e48df5a5e11af914">insert\_records\_random\_min</a>: Minimum possible length for generated series; default is 100 records per series. Must be an integral value within the range \[1, 500]. If both min and max are specified, min must be less than or equal to max. The minimum allowed value is 1. The maximum allowed value is 500. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aa014ca0414df10ca93297b0356c99a3b">insert\_records\_random\_max</a>: Maximum possible length for generated series; default is 500 records per series. Must be an integral value within the range \[1, 500]. If both min and max are specified, max must be greater than or equal to min. The minimum allowed value is 1. The maximum allowed value is 500. </li>
                      </ul>
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1InsertRecordsRandomResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1InsertRecordsRandomResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a1ec81d92f949358379266d42ae12bae7">◆ </a></span>insertRecordsRaw() <span>\[1/2]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1InsertRecordsResponse">InsertRecordsResponse</a> gpudb::GPUdb::insertRecordsRaw </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1RawInsertRecordsRequest">RawInsertRecordsRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Adds multiple records to the specified table. </p>
        <p>The operation is synchronous, meaning that a response will not be returned until all the records are fully inserted and available. The response payload provides the counts of the number of records actually inserted and/or updated, and can provide the unique identifier of each added record.</p>
        <p>The <a href="/content/api/cpp/structgpudb_1_1RawInsertRecordsRequest#a3d1a456679d9a00cfd53ff7d08f8a06f">options</a> parameter can be used to customize this function's behavior.</p>
        <p>The <a href="/content/api/cpp/namespacegpudb#aced7e07b232676a8e62a6da2adc83110">update\_on\_existing\_pk</a> option specifies the record collision policy for inserting into a table with a <a href="/content/concepts/tables/#primary-keys">primary key</a>, but is ignored if no primary key exists.</p>
        <p>The <a href="/content/api/cpp/namespacegpudb#a856c802e8393a8a5771f4200845b3d00">return\_record\_ids</a> option indicates that the database should return the unique identifiers of inserted records.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1RawInsertRecordsRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1InsertRecordsResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a9cd9f31f32e8aeacb99efecd5c23ffe7">◆ </a></span>insertRecordsRaw() <span>\[2/2]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1InsertRecordsResponse">InsertRecordsResponse</a> & gpudb::GPUdb::insertRecordsRaw </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1RawInsertRecordsRequest">RawInsertRecordsRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1InsertRecordsResponse">InsertRecordsResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Adds multiple records to the specified table. </p>
        <p>The operation is synchronous, meaning that a response will not be returned until all the records are fully inserted and available. The response payload provides the counts of the number of records actually inserted and/or updated, and can provide the unique identifier of each added record.</p>
        <p>The <a href="/content/api/cpp/structgpudb_1_1RawInsertRecordsRequest#a3d1a456679d9a00cfd53ff7d08f8a06f">options</a> parameter can be used to customize this function's behavior.</p>
        <p>The <a href="/content/api/cpp/namespacegpudb#aced7e07b232676a8e62a6da2adc83110">update\_on\_existing\_pk</a> option specifies the record collision policy for inserting into a table with a <a href="/content/concepts/tables/#primary-keys">primary key</a>, but is ignored if no primary key exists.</p>
        <p>The <a href="/content/api/cpp/namespacegpudb#a856c802e8393a8a5771f4200845b3d00">return\_record\_ids</a> option indicates that the database should return the unique identifiers of inserted records.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1RawInsertRecordsRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1InsertRecordsResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1InsertRecordsResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a33ff57e8504882376321fa9a5537fedf">◆ </a></span>insertSymbol() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1InsertSymbolResponse">InsertSymbolResponse</a> gpudb::GPUdb::insertSymbol </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1InsertSymbolRequest">InsertSymbolRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Adds a symbol or icon (i.e. an image) to represent data points when data is rendered visually. </p>
        <p>Users must provide the symbol identifier (string), a format (currently supported: 'svg' and 'svg\_path'), the data for the symbol, and any additional optional parameter (e.g. color). To have a symbol used for rendering create a table with a string column named 'SYMBOLCODE' (along with 'x' or 'y' for example). Then when the table is rendered (via <a href="/content/api/rest/wms_rest/">WMS</a>) if the 'dosymbology' parameter is 'true' then the value of the 'SYMBOLCODE' column is used to pick the symbol displayed for each point.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1InsertSymbolRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1InsertSymbolResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a859126a4b037a7689ae7b7a2ac742129">◆ </a></span>insertSymbol() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1InsertSymbolResponse">InsertSymbolResponse</a> & gpudb::GPUdb::insertSymbol </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1InsertSymbolRequest">InsertSymbolRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1InsertSymbolResponse">InsertSymbolResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Adds a symbol or icon (i.e. an image) to represent data points when data is rendered visually. </p>
        <p>Users must provide the symbol identifier (string), a format (currently supported: 'svg' and 'svg\_path'), the data for the symbol, and any additional optional parameter (e.g. color). To have a symbol used for rendering create a table with a string column named 'SYMBOLCODE' (along with 'x' or 'y' for example). Then when the table is rendered (via <a href="/content/api/rest/wms_rest/">WMS</a>) if the 'dosymbology' parameter is 'true' then the value of the 'SYMBOLCODE' column is used to pick the symbol displayed for each point.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1InsertSymbolRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1InsertSymbolResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1InsertSymbolResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a15ce82e07d56b203892660f07d65c610">◆ </a></span>insertSymbol() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1InsertSymbolResponse">InsertSymbolResponse</a> gpudb::GPUdb::insertSymbol </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>symbolId</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>symbolFormat</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< uint8\_t > &</td>
            <td><span><span>symbolData</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Adds a symbol or icon (i.e. an image) to represent data points when data is rendered visually. </p>
        <p>Users must provide the symbol identifier (string), a format (currently supported: 'svg' and 'svg\_path'), the data for the symbol, and any additional optional parameter (e.g. color). To have a symbol used for rendering create a table with a string column named 'SYMBOLCODE' (along with 'x' or 'y' for example). Then when the table is rendered (via <a href="/content/api/rest/wms_rest/">WMS</a>) if the 'dosymbology' parameter is 'true' then the value of the 'SYMBOLCODE' column is used to pick the symbol displayed for each point.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>symbolId</td>
                <td>The id of the symbol being added. This is the same id that should be in the 'SYMBOLCODE' column for objects using this symbol. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>symbolFormat</td>

                <td>
                  Specifies the symbol format. Must be either 'svg' or 'svg\_path'. Supported values:

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a4b4767cc88e5802e9fb5c5e64ec4533c">insert\_symbol\_svg</a> </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a120aa00c7ac2c865877b5481680c55b3">insert\_symbol\_svg\_path</a> </li>
                  </ul>
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>symbolData</td>
                <td>The actual symbol data. If <span>symbolFormat</span> is 'svg' then this should be the raw bytes representing an svg file. If <span>symbolFormat</span> is svg path then this should be an svg path string; for example: 'M25.979,12.896,5.979,12.896,5.979,19.562,25.979,19.562z'. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a04f5c6609cb43f0dc7d7371fcc5f8a97">insert\_symbol\_color</a>: If <span>symbolFormat</span> is 'svg' this is ignored. If <span>symbolFormat</span> is 'svg\_path' then this option specifies the color (in RRGGBB hex format) of the path. For example, to have the path rendered in red, used 'FF0000'. If 'color' is not provided then '00FF00' (i.e. green) is used by default. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1InsertSymbolResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#aad297dd0e66db2d92e3a213b989a0040">◆ </a></span>insertSymbol() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1InsertSymbolResponse">InsertSymbolResponse</a> & gpudb::GPUdb::insertSymbol </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>symbolId</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>symbolFormat</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< uint8\_t > &</td>
            <td><span><span>symbolData</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1InsertSymbolResponse">InsertSymbolResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Adds a symbol or icon (i.e. an image) to represent data points when data is rendered visually. </p>
        <p>Users must provide the symbol identifier (string), a format (currently supported: 'svg' and 'svg\_path'), the data for the symbol, and any additional optional parameter (e.g. color). To have a symbol used for rendering create a table with a string column named 'SYMBOLCODE' (along with 'x' or 'y' for example). Then when the table is rendered (via <a href="/content/api/rest/wms_rest/">WMS</a>) if the 'dosymbology' parameter is 'true' then the value of the 'SYMBOLCODE' column is used to pick the symbol displayed for each point.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>symbolId</td>
                <td>The id of the symbol being added. This is the same id that should be in the 'SYMBOLCODE' column for objects using this symbol. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>symbolFormat</td>

                <td>
                  Specifies the symbol format. Must be either 'svg' or 'svg\_path'. Supported values:

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a4b4767cc88e5802e9fb5c5e64ec4533c">insert\_symbol\_svg</a> </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a120aa00c7ac2c865877b5481680c55b3">insert\_symbol\_svg\_path</a> </li>
                  </ul>
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>symbolData</td>
                <td>The actual symbol data. If <span>symbolFormat</span> is 'svg' then this should be the raw bytes representing an svg file. If <span>symbolFormat</span> is svg path then this should be an svg path string; for example: 'M25.979,12.896,5.979,12.896,5.979,19.562,25.979,19.562z'. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a04f5c6609cb43f0dc7d7371fcc5f8a97">insert\_symbol\_color</a>: If <span>symbolFormat</span> is 'svg' this is ignored. If <span>symbolFormat</span> is 'svg\_path' then this option specifies the color (in RRGGBB hex format) of the path. For example, to have the path rendered in red, used 'FF0000'. If 'color' is not provided then '00FF00' (i.e. green) is used by default. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1InsertSymbolResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1InsertSymbolResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ac8fff6e61ada09d2fdb3bb336ccc321a">◆ </a></span>killProc() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1KillProcResponse">KillProcResponse</a> gpudb::GPUdb::killProc </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1KillProcRequest">KillProcRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Kills a running proc instance. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1KillProcRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1KillProcResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a0ad300665d452250337bcac23674ca8c">◆ </a></span>killProc() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1KillProcResponse">KillProcResponse</a> & gpudb::GPUdb::killProc </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1KillProcRequest">KillProcRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1KillProcResponse">KillProcResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Kills a running proc instance. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1KillProcRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1KillProcResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1KillProcResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a8272ee33e4bfe2ef6c5d225a7f151ada">◆ </a></span>killProc() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1KillProcResponse">KillProcResponse</a> gpudb::GPUdb::killProc </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>runId</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Kills a running proc instance. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>runId</td>
                <td>The run ID of a running proc instance. If a proc with a matching run ID is not found or the proc instance has already completed, no procs will be killed. If not specified, all running proc instances will be killed. The default value is ''. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#aec0d2b5c75f858fa90d8935dcf288ac0">kill\_proc\_run\_tag</a>: If <span>runId</span> is specified, kill the proc instance that has a matching run ID and a matching run tag that was provided to <a href="#a19f569cb61a53022021bbfd9e031468d">executeProc</a>. If <span>runId</span> is not specified, kill the proc instance(s) where a matching run tag was provided to <a href="#a19f569cb61a53022021bbfd9e031468d">executeProc</a>. The default value is ''. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#af2eb09468a7ca309a0d5e9a58e7f900c">kill\_proc\_clear\_execute\_at\_startup</a>: If <a href="/content/api/cpp/namespacegpudb#aa6b24f35474865925a838ba784a12015">true</a>, kill and remove the instance of the proc matching the auto-start run ID that was created to run when the database is started. The auto-start run ID was returned from <a href="#a19f569cb61a53022021bbfd9e031468d">executeProc</a> and can be retrieved using <a href="#a4ff6de0d6b70a356a1995b973c9811dc">showProc</a>. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#aa6b24f35474865925a838ba784a12015">kill\_proc\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#acaafc8026f131f4d72fe8c3a87e094a6">kill\_proc\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#acaafc8026f131f4d72fe8c3a87e094a6">kill\_proc\_false</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1KillProcResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#aa634787e5186e9266ac859a2ac344fcc">◆ </a></span>killProc() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1KillProcResponse">KillProcResponse</a> & gpudb::GPUdb::killProc </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>runId</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1KillProcResponse">KillProcResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Kills a running proc instance. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>runId</td>
                <td>The run ID of a running proc instance. If a proc with a matching run ID is not found or the proc instance has already completed, no procs will be killed. If not specified, all running proc instances will be killed. The default value is ''. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#aec0d2b5c75f858fa90d8935dcf288ac0">kill\_proc\_run\_tag</a>: If <span>runId</span> is specified, kill the proc instance that has a matching run ID and a matching run tag that was provided to <a href="#a19f569cb61a53022021bbfd9e031468d">executeProc</a>. If <span>runId</span> is not specified, kill the proc instance(s) where a matching run tag was provided to <a href="#a19f569cb61a53022021bbfd9e031468d">executeProc</a>. The default value is ''. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#af2eb09468a7ca309a0d5e9a58e7f900c">kill\_proc\_clear\_execute\_at\_startup</a>: If <a href="/content/api/cpp/namespacegpudb#aa6b24f35474865925a838ba784a12015">true</a>, kill and remove the instance of the proc matching the auto-start run ID that was created to run when the database is started. The auto-start run ID was returned from <a href="#a19f569cb61a53022021bbfd9e031468d">executeProc</a> and can be retrieved using <a href="#a4ff6de0d6b70a356a1995b973c9811dc">showProc</a>. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#aa6b24f35474865925a838ba784a12015">kill\_proc\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#acaafc8026f131f4d72fe8c3a87e094a6">kill\_proc\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#acaafc8026f131f4d72fe8c3a87e094a6">kill\_proc\_false</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1KillProcResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1KillProcResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ae6ac44ea2b9603bbad231212560ab451">◆ </a></span>lockTable() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1LockTableResponse">LockTableResponse</a> gpudb::GPUdb::lockTable </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1LockTableRequest">LockTableRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Manages global access to a table's data. </p>
        <p>By default a table has a <a href="/content/api/cpp/structgpudb_1_1LockTableRequest#ad0ceaa81ab3b5a95ec82e47f37cfb008">lockType</a> of <a href="/content/api/cpp/namespacegpudb#a3850006e51cb92262ee99c33e236be8e">read\_write</a>, indicating all operations are permitted. A user may request a <a href="/content/api/cpp/namespacegpudb#a13f9c3cae84296683c96fee7fc9d0559">read\_only</a> or a <a href="/content/api/cpp/namespacegpudb#a778a0ff86149e98e2801e79e77a9d808">write\_only</a> lock, after which only read or write operations, respectively, are permitted on the table until the lock is removed. When <a href="/content/api/cpp/structgpudb_1_1LockTableRequest#ad0ceaa81ab3b5a95ec82e47f37cfb008">lockType</a> is <a href="/content/api/cpp/namespacegpudb#a1765927f79afe041ba87edf363884e26">no\_access</a> then no operations are permitted on the table. The lock status can be queried by setting <a href="/content/api/cpp/structgpudb_1_1LockTableRequest#ad0ceaa81ab3b5a95ec82e47f37cfb008">lockType</a> to <a href="/content/api/cpp/namespacegpudb#aaea6e5cd5925eb2a89b9f638432e8055">status</a>.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1LockTableRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1LockTableResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a6f2620490cc2084a66dcfdad2ab3f65d">◆ </a></span>lockTable() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1LockTableResponse">LockTableResponse</a> & gpudb::GPUdb::lockTable </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1LockTableRequest">LockTableRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1LockTableResponse">LockTableResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Manages global access to a table's data. </p>
        <p>By default a table has a <a href="/content/api/cpp/structgpudb_1_1LockTableRequest#ad0ceaa81ab3b5a95ec82e47f37cfb008">lockType</a> of <a href="/content/api/cpp/namespacegpudb#a3850006e51cb92262ee99c33e236be8e">read\_write</a>, indicating all operations are permitted. A user may request a <a href="/content/api/cpp/namespacegpudb#a13f9c3cae84296683c96fee7fc9d0559">read\_only</a> or a <a href="/content/api/cpp/namespacegpudb#a778a0ff86149e98e2801e79e77a9d808">write\_only</a> lock, after which only read or write operations, respectively, are permitted on the table until the lock is removed. When <a href="/content/api/cpp/structgpudb_1_1LockTableRequest#ad0ceaa81ab3b5a95ec82e47f37cfb008">lockType</a> is <a href="/content/api/cpp/namespacegpudb#a1765927f79afe041ba87edf363884e26">no\_access</a> then no operations are permitted on the table. The lock status can be queried by setting <a href="/content/api/cpp/structgpudb_1_1LockTableRequest#ad0ceaa81ab3b5a95ec82e47f37cfb008">lockType</a> to <a href="/content/api/cpp/namespacegpudb#aaea6e5cd5925eb2a89b9f638432e8055">status</a>.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1LockTableRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1LockTableResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1LockTableResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a52f7405279172f1207c78fc5dae5b7ba">◆ </a></span>lockTable() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1LockTableResponse">LockTableResponse</a> gpudb::GPUdb::lockTable </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>lockType</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Manages global access to a table's data. </p>
        <p>By default a table has a <span>lockType</span> of <a href="/content/api/cpp/namespacegpudb#a3850006e51cb92262ee99c33e236be8e">read\_write</a>, indicating all operations are permitted. A user may request a <a href="/content/api/cpp/namespacegpudb#a13f9c3cae84296683c96fee7fc9d0559">read\_only</a> or a <a href="/content/api/cpp/namespacegpudb#a778a0ff86149e98e2801e79e77a9d808">write\_only</a> lock, after which only read or write operations, respectively, are permitted on the table until the lock is removed. When <span>lockType</span> is <a href="/content/api/cpp/namespacegpudb#a1765927f79afe041ba87edf363884e26">no\_access</a> then no operations are permitted on the table. The lock status can be queried by setting <span>lockType</span> to <a href="/content/api/cpp/namespacegpudb#aaea6e5cd5925eb2a89b9f638432e8055">status</a>.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of the table to be locked, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. It must be a currently existing table or view. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>lockType</td>

                <td>
                  The type of lock being applied to the table. Setting it to <a href="/content/api/cpp/namespacegpudb#aaea6e5cd5925eb2a89b9f638432e8055">status</a> will return the current lock status of the table without changing it. Supported values:

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#aaea6e5cd5925eb2a89b9f638432e8055">lock\_table\_status</a>: Show locked status. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a1765927f79afe041ba87edf363884e26">lock\_table\_no\_access</a>: Allow no read/write operations. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a13f9c3cae84296683c96fee7fc9d0559">lock\_table\_read\_only</a>: Allow only read operations. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a778a0ff86149e98e2801e79e77a9d808">lock\_table\_write\_only</a>: Allow only write operations. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a3850006e51cb92262ee99c33e236be8e">lock\_table\_read\_write</a>: Allow all read/write operations. </li>
                  </ul>

                  The default value is <a href="/content/api/cpp/namespacegpudb#aaea6e5cd5925eb2a89b9f638432e8055">lock\_table\_status</a>.
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1LockTableResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a91fbe8cf1b51394ad50fa063020d9e5a">◆ </a></span>lockTable() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1LockTableResponse">LockTableResponse</a> & gpudb::GPUdb::lockTable </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>lockType</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1LockTableResponse">LockTableResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Manages global access to a table's data. </p>
        <p>By default a table has a <span>lockType</span> of <a href="/content/api/cpp/namespacegpudb#a3850006e51cb92262ee99c33e236be8e">read\_write</a>, indicating all operations are permitted. A user may request a <a href="/content/api/cpp/namespacegpudb#a13f9c3cae84296683c96fee7fc9d0559">read\_only</a> or a <a href="/content/api/cpp/namespacegpudb#a778a0ff86149e98e2801e79e77a9d808">write\_only</a> lock, after which only read or write operations, respectively, are permitted on the table until the lock is removed. When <span>lockType</span> is <a href="/content/api/cpp/namespacegpudb#a1765927f79afe041ba87edf363884e26">no\_access</a> then no operations are permitted on the table. The lock status can be queried by setting <span>lockType</span> to <a href="/content/api/cpp/namespacegpudb#aaea6e5cd5925eb2a89b9f638432e8055">status</a>.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of the table to be locked, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. It must be a currently existing table or view. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>lockType</td>

                <td>
                  The type of lock being applied to the table. Setting it to <a href="/content/api/cpp/namespacegpudb#aaea6e5cd5925eb2a89b9f638432e8055">status</a> will return the current lock status of the table without changing it. Supported values:

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#aaea6e5cd5925eb2a89b9f638432e8055">lock\_table\_status</a>: Show locked status. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a1765927f79afe041ba87edf363884e26">lock\_table\_no\_access</a>: Allow no read/write operations. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a13f9c3cae84296683c96fee7fc9d0559">lock\_table\_read\_only</a>: Allow only read operations. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a778a0ff86149e98e2801e79e77a9d808">lock\_table\_write\_only</a>: Allow only write operations. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a3850006e51cb92262ee99c33e236be8e">lock\_table\_read\_write</a>: Allow all read/write operations. </li>
                  </ul>

                  The default value is <a href="/content/api/cpp/namespacegpudb#aaea6e5cd5925eb2a89b9f638432e8055">lock\_table\_status</a>.
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1LockTableResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1LockTableResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#aa906b4367c2f812aabd089ad7d0d8f3b">◆ </a></span>matchGraph() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1MatchGraphResponse">MatchGraphResponse</a> gpudb::GPUdb::matchGraph </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1MatchGraphRequest">MatchGraphRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Matches a directed route implied by a given set of latitude/longitude points to an existing underlying road network graph using a given solution type. </p>
        <p>IMPORTANT: It's highly recommended that you review the <a href="/content/graph_solver/network_graph_solver/">Graphs and Solvers</a> concepts documentation, the <a href="/content/guides/graph_rest_guide/">Graph REST Tutorial</a>, and/or some <a href="/content/guides/tags/graph-match">/match/graph examples</a> before using this endpoint.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1MatchGraphRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1MatchGraphResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ab7861deefa995b131fb4c5d093a7826d">◆ </a></span>matchGraph() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1MatchGraphResponse">MatchGraphResponse</a> & gpudb::GPUdb::matchGraph </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1MatchGraphRequest">MatchGraphRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1MatchGraphResponse">MatchGraphResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Matches a directed route implied by a given set of latitude/longitude points to an existing underlying road network graph using a given solution type. </p>
        <p>IMPORTANT: It's highly recommended that you review the <a href="/content/graph_solver/network_graph_solver/">Graphs and Solvers</a> concepts documentation, the <a href="/content/guides/graph_rest_guide/">Graph REST Tutorial</a>, and/or some <a href="/content/guides/tags/graph-match">/match/graph examples</a> before using this endpoint.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1MatchGraphRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1MatchGraphResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1MatchGraphResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a4096961ee9d30e9c523568a5c238c379">◆ </a></span>matchGraph() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1MatchGraphResponse">MatchGraphResponse</a> gpudb::GPUdb::matchGraph </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>graphName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< std::string > &</td>
            <td><span><span>samplePoints</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>solveMethod</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>solutionTable</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Matches a directed route implied by a given set of latitude/longitude points to an existing underlying road network graph using a given solution type. </p>
        <p>IMPORTANT: It's highly recommended that you review the <a href="/content/graph_solver/network_graph_solver/">Graphs and Solvers</a> concepts documentation, the <a href="/content/guides/graph_rest_guide/">Graph REST Tutorial</a>, and/or some <a href="/content/guides/tags/graph-match">/match/graph examples</a> before using this endpoint.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>graphName</td>
                <td>Name of the underlying geospatial graph resource to match to using <span>samplePoints</span>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>samplePoints</td>
                <td>Sample points used to match to an underlying geospatial graph. Sample points must be specified using <a href="/content/graph_solver/network_graph_solver/#match-identifiers">identifiers</a>; identifiers are grouped as <a href="/content/graph_solver/network_graph_solver/#match-combinations">combinations</a>. Identifiers can be used with: existing column names, e.g., 'table.column AS SAMPLE\_X'; expressions, e.g., 'ST\_MAKEPOINT(table.x, table.y) AS SAMPLE\_WKTPOINT'; or constant values, e.g., '1, 2, 10 AS SAMPLE\_TRIPID'. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>solveMethod</td>

                <td>
                  The type of solver to use for graph matching. Supported values:

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a7ad0718b76016b8c9b0a0de88ac84c7d">match\_graph\_markov\_chain</a>: Matches <span>samplePoints</span> to the graph using the Hidden Markov Model (HMM)-based method, which conducts a range-tree closest-edge search to find the best combinations of possible road segments (<a href="/content/api/cpp/namespacegpudb#a51c5de5ff0dfc27dbf854ef34c2b0c22">num\_segments</a>) for each sample point to create the best route. The route is secured one point at a time while looking ahead <a href="/content/api/cpp/namespacegpudb#a08b6ea9775a4bb3dc42b9eb705d02426">chain\_width</a> number of points, so the prediction is corrected after each point. This solution type is the most accurate but also the most computationally intensive. Related options: <a href="/content/api/cpp/namespacegpudb#a51c5de5ff0dfc27dbf854ef34c2b0c22">num\_segments</a> and <a href="/content/api/cpp/namespacegpudb#a08b6ea9775a4bb3dc42b9eb705d02426">chain\_width</a>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a7e679642af2dff0fbc9ca0a45e2f1952">match\_graph\_match\_od\_pairs</a>: Matches <span>samplePoints</span> to find the most probable path between origin and destination pairs with cost constraints. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a8f80b8e394deafc5d34236b69d6f9b73">match\_graph\_match\_supply\_demand</a>: Matches <span>samplePoints</span> to optimize scheduling multiple supplies (trucks) with varying sizes to varying demand sites with varying capacities per depot. Related options: <a href="/content/api/cpp/namespacegpudb#a5ca9626de28542759a1b6293be8189f7">partial\_loading</a> and <a href="/content/api/cpp/namespacegpudb#a6bf775bf9a24a15eac91bccc03962882">max\_combinations</a>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a0f0ad2148c66745ae0326d8ffa1feeda">match\_graph\_match\_batch\_solves</a>: Matches <span>samplePoints</span> source and destination pairs for the shortest path solves in batch mode. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a870028a40aeeb32489b1ed2ac124ea51">match\_graph\_match\_loops</a>: Matches closed loops (Eulerian paths) originating and ending at each graph node within min and max hops (levels). </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ace6c6283dc6cd2d9e29afea68c79b942">match\_graph\_match\_charging\_stations</a>: Matches an optimal path across a number of ev-charging stations between source and target locations. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a6f36f390b7dad827b2adbc627ee8a057">match\_graph\_match\_similarity</a>: Matches the intersection set(s) by computing the Jaccard similarity score between node pairs. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a6ed1924b6d396735845214ea5312acad">match\_graph\_match\_pickup\_dropoff</a>: Matches the pickups and dropoffs by optimizing the total trip costs. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a93ed321a55a284d86e5f0a755dea35d8">match\_graph\_match\_clusters</a>: Matches the graph nodes with a cluster index using Louvain clustering algorithm. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ad5033e349cb6279334df27d2217259a1">match\_graph\_match\_pattern</a>: Matches a pattern in the graph. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aa7d68e4514106fd078269ca284fcaeb3">match\_graph\_match\_embedding</a>: Creates vector node embeddings. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ace7e2fec0b9a36ad6466bd61daabd542">match\_graph\_match\_isochrone</a>: Solves for isochrones for a set of input sources. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a99341caade4262a70954f23065993c3c">match\_graph\_match\_route\_detour</a>: Computes detour costs for nearby stations at a mark point along each source-target route. </li>
                  </ul>

                  The default value is <a href="/content/api/cpp/namespacegpudb#a7ad0718b76016b8c9b0a0de88ac84c7d">match\_graph\_markov\_chain</a>.
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>solutionTable</td>
                <td>The name of the table used to store the results, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a> and meeting <a href="/content/concepts/tables/#table-naming-criteria">table naming criteria</a>. This table contains a <a href="/content/location_intelligence/geo_objects/#geospatial-tracks">track</a> of geospatial points for the matched portion of the graph, a track ID, and a score value. Also outputs a details table containing a trip ID (that matches the track ID), the latitude/longitude pair, the timestamp the point was recorded at, and an edge ID corresponding to the matched road segment. Must not be an existing table of the same name. The default value is ''. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Additional parameters.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#ad8c2393aa951e413d74140c9243ad46c">match\_graph\_gps\_noise</a>: GPS noise value (in meters) to remove redundant sample points. Use -1 to disable noise reduction. The default value accounts for 95% of point variation (+ or -5 meters). The default value is '5.0'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a51c5de5ff0dfc27dbf854ef34c2b0c22">match\_graph\_num\_segments</a>: Maximum number of potentially matching road segments for each sample point. For the <a href="/content/api/cpp/namespacegpudb#a7ad0718b76016b8c9b0a0de88ac84c7d">markov\_chain</a> solver, the default is 3. The default value is '3'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aa4abfa1bc622e1f880aa968b3ec4df79">match\_graph\_search\_radius</a>: Maximum search radius used when snapping sample points onto potentially matching surrounding segments. The default value corresponds to approximately 100 meters. The default value is '0.001'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a08b6ea9775a4bb3dc42b9eb705d02426">match\_graph\_chain\_width</a>: For the <a href="/content/api/cpp/namespacegpudb#a7ad0718b76016b8c9b0a0de88ac84c7d">markov\_chain</a> solver only. Length of the sample points lookahead window within the Markov kernel; the larger the number, the more accurate the solution. The default value is '9'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aa13f9aae1c0b832c9506157b470b9dfd">match\_graph\_source</a>: WKT starting point from <span>samplePoints</span> for the solver. The default behavior for the endpoint is to use time to determine the starting point. The default value is 'POINT NULL'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ac287130305b0c5735894459b1e06b818">match\_graph\_destination</a>: WKT ending point from <span>samplePoints</span> for the solver. The default behavior for the endpoint is to use time to determine the destination point. The default value is 'POINT NULL'. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a5ca9626de28542759a1b6293be8189f7">match\_graph\_partial\_loading</a>: For the <a href="/content/api/cpp/namespacegpudb#a8f80b8e394deafc5d34236b69d6f9b73">match\_supply\_demand</a> solver only. When false (non-default), trucks do not off-load at the demand (store) side if the remainder is less than the store's need. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a332768f0618485847fd2dd66e18a1360">match\_graph\_true</a>: Partial off-loading at multiple store (demand) locations. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a594706f400701e02491d2a648558713b">match\_graph\_false</a>: No partial off-loading allowed if supply is less than the store's demand. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a332768f0618485847fd2dd66e18a1360">match\_graph\_true</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a6bf775bf9a24a15eac91bccc03962882">match\_graph\_max\_combinations</a>: For the <a href="/content/api/cpp/namespacegpudb#a8f80b8e394deafc5d34236b69d6f9b73">match\_supply\_demand</a> solver only. This is the cutoff for the number of generated combinations for sequencing the demand locations - can increase this up to 2M. The default value is '10000'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a971fbf1a96c6de0556c761e0fe354340">match\_graph\_max\_supply\_combinations</a>: For the <a href="/content/api/cpp/namespacegpudb#a8f80b8e394deafc5d34236b69d6f9b73">match\_supply\_demand</a> solver only. This is the cutoff for the number of generated combinations for sequencing the supply locations if/when 'permute\_supplies' is true. The default value is '10000'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#abeb53a7d9333b1208c7fde1345fe6f1b">match\_graph\_left\_turn\_penalty</a>: This will add an additional weight over the edges labeled as 'left turn' if the 'add\_turn' option parameter of the <a href="#a025f78582e1d24c590888a3d29e19f36">createGraph</a> was invoked at graph creation. The default value is '0.0'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a53c95f648987f6dfbf14963ace75acda">match\_graph\_right\_turn\_penalty</a>: This will add an additional weight over the edges labeled as' right turn' if the 'add\_turn' option parameter of the <a href="#a025f78582e1d24c590888a3d29e19f36">createGraph</a> was invoked at graph creation. The default value is '0.0'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a91d7e1185eca82260060fc03b8b9cb70">match\_graph\_intersection\_penalty</a>: This will add an additional weight over the edges labeled as 'intersection' if the 'add\_turn' option parameter of the <a href="#a025f78582e1d24c590888a3d29e19f36">createGraph</a> was invoked at graph creation. The default value is '0.0'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a989bc4180d02a248bb2ff5d3fc8e9bb5">match\_graph\_sharp\_turn\_penalty</a>: This will add an additional weight over the edges labeled as 'sharp turn' or 'u-turn' if the 'add\_turn' option parameter of the <a href="#a025f78582e1d24c590888a3d29e19f36">createGraph</a> was invoked at graph creation. The default value is '0.0'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a1b490d7e39262bd9349877fb8ad66b8e">match\_graph\_aggregated\_output</a>: For the <a href="/content/api/cpp/namespacegpudb#a8f80b8e394deafc5d34236b69d6f9b73">match\_supply\_demand</a> solver only. When it is true (default), each record in the output table shows a particular truck's scheduled cumulative round trip path (MULTILINESTRING) and the corresponding aggregated cost. Otherwise, each record shows a single scheduled truck route (LINESTRING) towards a particular demand location (store id) with its corresponding cost. The default value is 'true'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a18beb8acfc468d20f22377c5be05f029">match\_graph\_output\_tracks</a>: For the <a href="/content/api/cpp/namespacegpudb#a8f80b8e394deafc5d34236b69d6f9b73">match\_supply\_demand</a> solver only. When it is true (non-default), the output will be in tracks format for all the round trips of each truck in which the timestamps are populated directly from the edge weights starting from their originating depots. The default value is 'false'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a7621c1ba624f18e8c86333c60223b772">match\_graph\_max\_trip\_cost</a>: For the <a href="/content/api/cpp/namespacegpudb#a8f80b8e394deafc5d34236b69d6f9b73">match\_supply\_demand</a> and <a href="/content/api/cpp/namespacegpudb#a6ed1924b6d396735845214ea5312acad">match\_pickup\_dropoff</a> solvers only. If this constraint is greater than zero (default) then the trucks/rides will skip traveling from one demand/pick location to another if the cost between them is greater than this number (distance or time). Zero (default) value means no check is performed. The default value is '0.0'. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a016cdaf483664a97e8e986171d4c9e70">match\_graph\_filter\_folding\_paths</a>: For the <a href="/content/api/cpp/namespacegpudb#a7ad0718b76016b8c9b0a0de88ac84c7d">markov\_chain</a> solver only. When true (non-default), the paths per sequence combination is checked for folding over patterns and can significantly increase the execution time depending on the chain width and the number of GPS samples. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a332768f0618485847fd2dd66e18a1360">match\_graph\_true</a>: Filter out the folded paths. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a594706f400701e02491d2a648558713b">match\_graph\_false</a>: Do not filter out the folded paths. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a594706f400701e02491d2a648558713b">match\_graph\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a2fb796fe2d1559637cecf613444a2723">match\_graph\_unit\_unloading\_cost</a>: For the <a href="/content/api/cpp/namespacegpudb#a8f80b8e394deafc5d34236b69d6f9b73">match\_supply\_demand</a> solver only. The unit cost per load amount to be delivered. If this value is greater than zero (default) then the additional cost of this unit load multiplied by the total dropped load will be added over to the trip cost to the demand location. The default value is '0.0'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#af1c8e83e2626252fb4fbb7fa1de96ff7">match\_graph\_max\_num\_threads</a>: For the <a href="/content/api/cpp/namespacegpudb#a7ad0718b76016b8c9b0a0de88ac84c7d">markov\_chain</a> solver only. If specified (greater than zero), the maximum number of threads will not be greater than the specified value. It can be lower due to the memory and the number cores available. Default value of zero allows the algorithm to set the maximal number of threads within these constraints. The default value is '0'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aebec37ca89d6862bc0164a812a702502">match\_graph\_service\_limit</a>: For the <a href="/content/api/cpp/namespacegpudb#a8f80b8e394deafc5d34236b69d6f9b73">match\_supply\_demand</a> solver only. If specified (greater than zero), any supply actor's total service cost (distance or time) will be limited by the specified value including multiple rounds (if set). The default value is '0.0'. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a89beaba01481555200436e4bbeb01b17">match\_graph\_enable\_reuse</a>: For the <a href="/content/api/cpp/namespacegpudb#a8f80b8e394deafc5d34236b69d6f9b73">match\_supply\_demand</a> solver only. If specified (true), all supply actors can be scheduled for second rounds from their originating depots. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a332768f0618485847fd2dd66e18a1360">match\_graph\_true</a>: Allows reusing supply actors (trucks, e.g.) for scheduling again. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a594706f400701e02491d2a648558713b">match\_graph\_false</a>: Supply actors are scheduled only once from their depots. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a594706f400701e02491d2a648558713b">match\_graph\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a2102a4d9d59fa0e14ab4735ca4c64cd1">match\_graph\_max\_stops</a>: For the <a href="/content/api/cpp/namespacegpudb#a8f80b8e394deafc5d34236b69d6f9b73">match\_supply\_demand</a> solver only. If specified (greater than zero), a supply actor (truck) can at most have this many stops (demand locations) in one round trip. Otherwise, it is unlimited. If 'enable\_truck\_reuse' is on, this condition will be applied separately at each round trip use of the same truck. The default value is '0'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a72af04f919d7ada465cba47d6f4a8d21">match\_graph\_service\_radius</a>: For the <a href="/content/api/cpp/namespacegpudb#a8f80b8e394deafc5d34236b69d6f9b73">match\_supply\_demand</a> and <a href="/content/api/cpp/namespacegpudb#a6ed1924b6d396735845214ea5312acad">match\_pickup\_dropoff</a> solvers only. If specified (greater than zero), it filters the demands/picks outside this radius centered around the supply actor/ride's originating location (distance or time). The default value is '0.0'. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a6a4f125d6f9f714999a850a6bc3c4f42">match\_graph\_permute\_supplies</a>: For the <a href="/content/api/cpp/namespacegpudb#a8f80b8e394deafc5d34236b69d6f9b73">match\_supply\_demand</a> solver only. If specified (true), supply side actors are permuted for the demand combinations during MSDO optimization - note that this option increases optimization time significantly - use of 'max\_combinations' option is recommended to prevent prohibitively long runs. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a332768f0618485847fd2dd66e18a1360">match\_graph\_true</a>: Generates sequences over supply side permutations if total supply is less than twice the total demand. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a594706f400701e02491d2a648558713b">match\_graph\_false</a>: Permutations are not performed, rather a specific order of supplies based on capacity is computed. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a332768f0618485847fd2dd66e18a1360">match\_graph\_true</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a62d319d5df3e175b485da6e488588eff">match\_graph\_batch\_tsm\_mode</a>: For the <a href="/content/api/cpp/namespacegpudb#a8f80b8e394deafc5d34236b69d6f9b73">match\_supply\_demand</a> solver only. When enabled, it sets the number of visits on each demand location by a single salesman at each trip is considered to be (one) 1, otherwise there is no bound. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a332768f0618485847fd2dd66e18a1360">match\_graph\_true</a>: Sets only one visit per demand location by a salesman (TSM mode). </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a594706f400701e02491d2a648558713b">match\_graph\_false</a>: No preset limit (usual MSDO mode). </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a594706f400701e02491d2a648558713b">match\_graph\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ac4970d95192ea73ebecce943f5a6ebbf">match\_graph\_round\_trip</a>: For the <a href="/content/api/cpp/namespacegpudb#a8f80b8e394deafc5d34236b69d6f9b73">match\_supply\_demand</a> solver only. When enabled, the supply will have to return back to the origination location. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a332768f0618485847fd2dd66e18a1360">match\_graph\_true</a>: The optimization is done for trips in round trip manner always returning to originating locations. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a594706f400701e02491d2a648558713b">match\_graph\_false</a>: Supplies do not have to come back to their originating locations in their routes. The routes are considered finished at the final dropoff. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a332768f0618485847fd2dd66e18a1360">match\_graph\_true</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#af0b603a4b13584254318fa48df41d5bb">match\_graph\_num\_cycles</a>: For the <a href="/content/api/cpp/namespacegpudb#a93ed321a55a284d86e5f0a755dea35d8">match\_clusters</a> solver only. Terminates the cluster exchange iterations across 2-step-cycles (outer loop) when quality does not improve during iterations. The default value is '10'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a1c923bea5f46c4fe81b5d8e9fac31d80">match\_graph\_num\_loops\_per\_cycle</a>: For the <a href="/content/api/cpp/namespacegpudb#a93ed321a55a284d86e5f0a755dea35d8">match\_clusters</a> and <a href="/content/api/cpp/namespacegpudb#aa7d68e4514106fd078269ca284fcaeb3">match\_embedding</a> solvers only. Terminates the cluster exchanges within the first step iterations of a cycle (inner loop) unless convergence is reached. The default value is '10'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a6e6c37c6bd88fba0581a8b2e57e444fa">match\_graph\_num\_output\_clusters</a>: For the <a href="/content/api/cpp/namespacegpudb#a93ed321a55a284d86e5f0a755dea35d8">match\_clusters</a> solver only. Limits the output to the top 'num\_output\_clusters' clusters based on density. Default value of zero outputs all clusters. The default value is '0'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a6f6379cc5e8d66ca04dc5928197c842a">match\_graph\_max\_num\_clusters</a>: For the <a href="/content/api/cpp/namespacegpudb#a93ed321a55a284d86e5f0a755dea35d8">match\_clusters</a> and <a href="/content/api/cpp/namespacegpudb#aa7d68e4514106fd078269ca284fcaeb3">match\_embedding</a> solvers only. If set (value greater than zero), it terminates when the number of clusters goes below than this number. For embedding solver the default is 8. The default value is '0'. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#af0ff68eb99414c31f51da71c94ec1b08">match\_graph\_cluster\_quality\_metric</a>: For the <a href="/content/api/cpp/namespacegpudb#a93ed321a55a284d86e5f0a755dea35d8">match\_clusters</a> solver only. The quality metric for Louvain modularity optimization solver. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad843e2dfb092b5a005307d82b83a2c2a">match\_graph\_girvan</a>: Uses the Newman Girvan quality metric for cluster solver. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a19b4ab1cdbf377ac8dc0bda2f34a5f68">match\_graph\_spectral</a>: Applies recursive spectral bisection (RSB) partitioning solver. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ad843e2dfb092b5a005307d82b83a2c2a">match\_graph\_girvan</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ad5deb77689e7cf556eda927e2428e70a">match\_graph\_restricted\_type</a>: For the <a href="/content/api/cpp/namespacegpudb#a8f80b8e394deafc5d34236b69d6f9b73">match\_supply\_demand</a> solver only. Optimization is performed by restricting routes labeled by 'MSDO\_ODDEVEN\_RESTRICTED' only for this supply actor (truck) type. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a123b8f4a4a431562e437d715a896dc68">match\_graph\_odd</a>: Applies odd/even rule restrictions to odd tagged vehicles. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a3bfcdfd90e856815affb223f4335beec">match\_graph\_even</a>: Applies odd/even rule restrictions to even tagged vehicles. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a30b83b4be166e847127eb9be2efb553c">match\_graph\_none</a>: Does not apply odd/even rule restrictions to any vehicles. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a30b83b4be166e847127eb9be2efb553c">match\_graph\_none</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a4715ea8776985c4b99946348eae49e23">match\_graph\_server\_id</a>: Indicates which graph server(s) to send the request to. Default is to send to the server, amongst those containing the corresponding graph, that has the most computational bandwidth. The default value is ''. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a5a0230ee82aed9b0d5eb4000a14a245d">match\_graph\_inverse\_solve</a>: For the <a href="/content/api/cpp/namespacegpudb#a0f0ad2148c66745ae0326d8ffa1feeda">match\_batch\_solves</a> solver only. Solves source-destination pairs using inverse shortest path solver. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a332768f0618485847fd2dd66e18a1360">match\_graph\_true</a>: Solves using inverse shortest path solver. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a594706f400701e02491d2a648558713b">match\_graph\_false</a>: Solves using direct shortest path solver. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a594706f400701e02491d2a648558713b">match\_graph\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#ae7a3065edf17d1aefa1fb8f41821b68c">match\_graph\_min\_loop\_level</a>: For the <a href="/content/api/cpp/namespacegpudb#a870028a40aeeb32489b1ed2ac124ea51">match\_loops</a> solver only. Finds closed loops around each node deducible not less than this minimal hop (level) deep. The default value is '0'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a1b0414e388b87a93bef650c389db43cc">match\_graph\_max\_loop\_level</a>: For the <a href="/content/api/cpp/namespacegpudb#a870028a40aeeb32489b1ed2ac124ea51">match\_loops</a> solver only. Finds closed loops around each node deducible not more than this maximal hop (level) deep. The default value is '5'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a9e6acb8c9fc3b45ddfa0d0e70d30e074">match\_graph\_search\_limit</a>: For the <a href="/content/api/cpp/namespacegpudb#a870028a40aeeb32489b1ed2ac124ea51">match\_loops</a> solver only. Searches within this limit of nodes per vertex to detect loops. The value zero means there is no limit. The default value is '10000'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#af9419a4b85e0d3ba72fe5b1d4a9101b4">match\_graph\_output\_batch\_size</a>: For the <a href="/content/api/cpp/namespacegpudb#a870028a40aeeb32489b1ed2ac124ea51">match\_loops</a> solver only. Uses this value as the batch size of the number of loops in flushing(inserting) to the output table. The default value is '1000'. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a5617e18e8dc732c2bd222dad1ee4c5e9">match\_graph\_multi\_step</a>: For the <a href="/content/api/cpp/namespacegpudb#a8f80b8e394deafc5d34236b69d6f9b73">match\_supply\_demand</a> solver only. Runs multiple supply demand solver repeatedly in a multi step cycle by switching supplies to demands until it reaches the main hub supply. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a332768f0618485847fd2dd66e18a1360">match\_graph\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a594706f400701e02491d2a648558713b">match\_graph\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a594706f400701e02491d2a648558713b">match\_graph\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#ac4a701b547a8b1ba709ad1c13efc8ebc">match\_graph\_charging\_capacity</a>: For the <a href="/content/api/cpp/namespacegpudb#ace6c6283dc6cd2d9e29afea68c79b942">match\_charging\_stations</a> solver only. This is the maximum ev-charging capacity of a vehicle (distance in meters or time in seconds depending on the unit of the graph weights). The default value is '300000.0'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aabcacea13d04641f0ad1b0b693a93d9d">match\_graph\_charging\_candidates</a>: For the <a href="/content/api/cpp/namespacegpudb#ace6c6283dc6cd2d9e29afea68c79b942">match\_charging\_stations</a> solver only. Solver searches for this many number of stations closest around each base charging location found by capacity. The default value is '10'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ae8844e5dbc4c8870b01a3ec503dff5e8">match\_graph\_charging\_penalty</a>: For the <a href="/content/api/cpp/namespacegpudb#ace6c6283dc6cd2d9e29afea68c79b942">match\_charging\_stations</a> solver only. This is the penalty for full charging. The default value is '30000.0'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a9a688ea818e7b2ed01dd35257e8290fc">match\_graph\_detour\_mark\_cost</a>: For the <a href="/content/api/cpp/namespacegpudb#a99341caade4262a70954f23065993c3c">match\_route\_detour</a> solver only. Cost along the route at which to search for nearby stations If zero, it solves along the trip sliding the 3 SSSP cycle kernel by radius amount. The default value is '3600.0'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a2ef4994cf6d1e3baf767237d7b3debe6">match\_graph\_detour\_reentry\_factor</a>: For the <a href="/content/api/cpp/namespacegpudb#a99341caade4262a70954f23065993c3c">match\_route\_detour</a> solver only. Multiplier on detour\_mark\_cost to determine the reentry point on the route (default 1.2 means 20% further along). The default value is '1.2'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a3aed260768bf89964c7338f13a4e6039">match\_graph\_detour\_search\_radius</a>: For the <a href="/content/api/cpp/namespacegpudb#a99341caade4262a70954f23065993c3c">match\_route\_detour</a> solver only. Search radius around the mark point for finding nearby prospective stations (e.g. cafes, pit stops, EV charging stations). The default value is '600.0'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ac9da44dd69b388ff96ec77967a87385f">match\_graph\_detour\_search\_limit</a>: For the <a href="/content/api/cpp/namespacegpudb#a99341caade4262a70954f23065993c3c">match\_route\_detour</a> solver only. Maximum number of nearby stations to consider within the search radius around the mark point. The default value is '10'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ad33b839a557feca1020bb3a4841bb863">match\_graph\_max\_hops</a>: For the <a href="/content/api/cpp/namespacegpudb#a6f36f390b7dad827b2adbc627ee8a057">match\_similarity</a> and <a href="/content/api/cpp/namespacegpudb#aa7d68e4514106fd078269ca284fcaeb3">match\_embedding</a> solvers only. Searches within this maximum hops for source and target node pairs to compute the Jaccard scores. The default value is '3'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a8681e9fa5406b008c35620d0faee1ed9">match\_graph\_traversal\_node\_limit</a>: For the <a href="/content/api/cpp/namespacegpudb#a6f36f390b7dad827b2adbc627ee8a057">match\_similarity</a> solver only. Limits the traversal depth if it reaches this many number of nodes. The default value is '1000'. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a9642089436c6909ed1a8398d5dfa1958">match\_graph\_paired\_similarity</a>: For the <a href="/content/api/cpp/namespacegpudb#a6f36f390b7dad827b2adbc627ee8a057">match\_similarity</a> solver only. If true, it computes Jaccard score between each pair, otherwise it will compute Jaccard from the intersection set between the source and target nodes. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a332768f0618485847fd2dd66e18a1360">match\_graph\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a594706f400701e02491d2a648558713b">match\_graph\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a332768f0618485847fd2dd66e18a1360">match\_graph\_true</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a97fe0269a8e022e0a9bb12c4ae0a4856">match\_graph\_force\_undirected</a>: For the <a href="/content/api/cpp/namespacegpudb#ad5033e349cb6279334df27d2217259a1">match\_pattern</a> and <a href="/content/api/cpp/namespacegpudb#aa7d68e4514106fd078269ca284fcaeb3">match\_embedding</a> solvers only. Pattern matching will be using both pattern and graph as undirected if set to true. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a332768f0618485847fd2dd66e18a1360">match\_graph\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a594706f400701e02491d2a648558713b">match\_graph\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a594706f400701e02491d2a648558713b">match\_graph\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a30da5b563985edf135a7a3cc161e351f">match\_graph\_max\_vector\_dimension</a>: For the <a href="/content/api/cpp/namespacegpudb#aa7d68e4514106fd078269ca284fcaeb3">match\_embedding</a> solver only. Limits the number of dimensions in node vector embeddings. The default value is '1000'. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a151e4380fc84c0a9093364ef6cac1def">match\_graph\_optimize\_embedding\_weights</a>: For the <a href="/content/api/cpp/namespacegpudb#aa7d68e4514106fd078269ca284fcaeb3">match\_embedding</a> solvers only. Solves to find the optimal weights per sub feature in vector embeddings. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a332768f0618485847fd2dd66e18a1360">match\_graph\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a594706f400701e02491d2a648558713b">match\_graph\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a594706f400701e02491d2a648558713b">match\_graph\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a74df0c496679cba30fe0717d339a34bb">match\_graph\_embedding\_weights</a>: For the <a href="/content/api/cpp/namespacegpudb#aa7d68e4514106fd078269ca284fcaeb3">match\_embedding</a> solver only. User specified weights per sub feature in vector embeddings. The string contains the comma separated float values for each sub-feature in the vector space. These values will ONLY be used if 'optimize\_embedding\_weights' is false. The default value is '1.0,1.0,1.0,1.0'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a525917edc2588120657f36ddfcbf3278">match\_graph\_optimization\_sampling\_size</a>: For the <a href="/content/api/cpp/namespacegpudb#aa7d68e4514106fd078269ca284fcaeb3">match\_embedding</a> solver only. Sets the number of random nodes from the graph for solving the weights using stochastic gradient descent. The default value is '1000'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#adb12f28ff3c95dc31c6c7fdfcf881ed0">match\_graph\_optimization\_max\_iterations</a>: For the <a href="/content/api/cpp/namespacegpudb#aa7d68e4514106fd078269ca284fcaeb3">match\_embedding</a> solver only. When the iterations (epochs) for the convergence of the stochastic gradient descent algorithm reaches this number it bails out unless relative error between consecutive iterations is below the 'optimization\_error\_tolerance' option. The default value is '1000'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ad57a45a4806326703138daecd26d3c47">match\_graph\_optimization\_error\_tolerance</a>: For the <a href="/content/api/cpp/namespacegpudb#aa7d68e4514106fd078269ca284fcaeb3">match\_embedding</a> solver only. When the relative error between all of the weights' consecutive iterations falls below this threshold the optimization cycle is interrupted unless the number of iterations reaches the limit set by the option 'max\_optimization\_iterations'. The default value is '0.001'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a1a93db4bd4d845c7a7704efe837dc900">match\_graph\_optimization\_iteration\_rate</a>: For the <a href="/content/api/cpp/namespacegpudb#aa7d68e4514106fd078269ca284fcaeb3">match\_embedding</a> solver only. It is otherwise known as the learning rate, which is the proportionality constant in front of the gradient term in successive iterations. The default value is '0.3'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a373218af523994eac0135cb813e2a593">match\_graph\_max\_radius</a>: For the <a href="/content/api/cpp/namespacegpudb#ace7e2fec0b9a36ad6466bd61daabd542">match\_isochrone</a> solver only. Sets the maximal reachability limit for computing isochrones. Zero means no limit. The default value is '0.0'. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1MatchGraphResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#aeb993c1264ec7a5f42202f699a978a95">◆ </a></span>matchGraph() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1MatchGraphResponse">MatchGraphResponse</a> & gpudb::GPUdb::matchGraph </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>graphName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< std::string > &</td>
            <td><span><span>samplePoints</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>solveMethod</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>solutionTable</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1MatchGraphResponse">MatchGraphResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Matches a directed route implied by a given set of latitude/longitude points to an existing underlying road network graph using a given solution type. </p>
        <p>IMPORTANT: It's highly recommended that you review the <a href="/content/graph_solver/network_graph_solver/">Graphs and Solvers</a> concepts documentation, the <a href="/content/guides/graph_rest_guide/">Graph REST Tutorial</a>, and/or some <a href="/content/guides/tags/graph-match">/match/graph examples</a> before using this endpoint.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>graphName</td>
                <td>Name of the underlying geospatial graph resource to match to using <span>samplePoints</span>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>samplePoints</td>
                <td>Sample points used to match to an underlying geospatial graph. Sample points must be specified using <a href="/content/graph_solver/network_graph_solver/#match-identifiers">identifiers</a>; identifiers are grouped as <a href="/content/graph_solver/network_graph_solver/#match-combinations">combinations</a>. Identifiers can be used with: existing column names, e.g., 'table.column AS SAMPLE\_X'; expressions, e.g., 'ST\_MAKEPOINT(table.x, table.y) AS SAMPLE\_WKTPOINT'; or constant values, e.g., '1, 2, 10 AS SAMPLE\_TRIPID'. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>solveMethod</td>

                <td>
                  The type of solver to use for graph matching. Supported values:

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a7ad0718b76016b8c9b0a0de88ac84c7d">match\_graph\_markov\_chain</a>: Matches <span>samplePoints</span> to the graph using the Hidden Markov Model (HMM)-based method, which conducts a range-tree closest-edge search to find the best combinations of possible road segments (<a href="/content/api/cpp/namespacegpudb#a51c5de5ff0dfc27dbf854ef34c2b0c22">num\_segments</a>) for each sample point to create the best route. The route is secured one point at a time while looking ahead <a href="/content/api/cpp/namespacegpudb#a08b6ea9775a4bb3dc42b9eb705d02426">chain\_width</a> number of points, so the prediction is corrected after each point. This solution type is the most accurate but also the most computationally intensive. Related options: <a href="/content/api/cpp/namespacegpudb#a51c5de5ff0dfc27dbf854ef34c2b0c22">num\_segments</a> and <a href="/content/api/cpp/namespacegpudb#a08b6ea9775a4bb3dc42b9eb705d02426">chain\_width</a>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a7e679642af2dff0fbc9ca0a45e2f1952">match\_graph\_match\_od\_pairs</a>: Matches <span>samplePoints</span> to find the most probable path between origin and destination pairs with cost constraints. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a8f80b8e394deafc5d34236b69d6f9b73">match\_graph\_match\_supply\_demand</a>: Matches <span>samplePoints</span> to optimize scheduling multiple supplies (trucks) with varying sizes to varying demand sites with varying capacities per depot. Related options: <a href="/content/api/cpp/namespacegpudb#a5ca9626de28542759a1b6293be8189f7">partial\_loading</a> and <a href="/content/api/cpp/namespacegpudb#a6bf775bf9a24a15eac91bccc03962882">max\_combinations</a>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a0f0ad2148c66745ae0326d8ffa1feeda">match\_graph\_match\_batch\_solves</a>: Matches <span>samplePoints</span> source and destination pairs for the shortest path solves in batch mode. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a870028a40aeeb32489b1ed2ac124ea51">match\_graph\_match\_loops</a>: Matches closed loops (Eulerian paths) originating and ending at each graph node within min and max hops (levels). </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ace6c6283dc6cd2d9e29afea68c79b942">match\_graph\_match\_charging\_stations</a>: Matches an optimal path across a number of ev-charging stations between source and target locations. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a6f36f390b7dad827b2adbc627ee8a057">match\_graph\_match\_similarity</a>: Matches the intersection set(s) by computing the Jaccard similarity score between node pairs. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a6ed1924b6d396735845214ea5312acad">match\_graph\_match\_pickup\_dropoff</a>: Matches the pickups and dropoffs by optimizing the total trip costs. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a93ed321a55a284d86e5f0a755dea35d8">match\_graph\_match\_clusters</a>: Matches the graph nodes with a cluster index using Louvain clustering algorithm. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ad5033e349cb6279334df27d2217259a1">match\_graph\_match\_pattern</a>: Matches a pattern in the graph. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aa7d68e4514106fd078269ca284fcaeb3">match\_graph\_match\_embedding</a>: Creates vector node embeddings. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ace7e2fec0b9a36ad6466bd61daabd542">match\_graph\_match\_isochrone</a>: Solves for isochrones for a set of input sources. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a99341caade4262a70954f23065993c3c">match\_graph\_match\_route\_detour</a>: Computes detour costs for nearby stations at a mark point along each source-target route. </li>
                  </ul>

                  The default value is <a href="/content/api/cpp/namespacegpudb#a7ad0718b76016b8c9b0a0de88ac84c7d">match\_graph\_markov\_chain</a>.
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>solutionTable</td>
                <td>The name of the table used to store the results, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a> and meeting <a href="/content/concepts/tables/#table-naming-criteria">table naming criteria</a>. This table contains a <a href="/content/location_intelligence/geo_objects/#geospatial-tracks">track</a> of geospatial points for the matched portion of the graph, a track ID, and a score value. Also outputs a details table containing a trip ID (that matches the track ID), the latitude/longitude pair, the timestamp the point was recorded at, and an edge ID corresponding to the matched road segment. Must not be an existing table of the same name. The default value is ''. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Additional parameters.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#ad8c2393aa951e413d74140c9243ad46c">match\_graph\_gps\_noise</a>: GPS noise value (in meters) to remove redundant sample points. Use -1 to disable noise reduction. The default value accounts for 95% of point variation (+ or -5 meters). The default value is '5.0'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a51c5de5ff0dfc27dbf854ef34c2b0c22">match\_graph\_num\_segments</a>: Maximum number of potentially matching road segments for each sample point. For the <a href="/content/api/cpp/namespacegpudb#a7ad0718b76016b8c9b0a0de88ac84c7d">markov\_chain</a> solver, the default is 3. The default value is '3'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aa4abfa1bc622e1f880aa968b3ec4df79">match\_graph\_search\_radius</a>: Maximum search radius used when snapping sample points onto potentially matching surrounding segments. The default value corresponds to approximately 100 meters. The default value is '0.001'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a08b6ea9775a4bb3dc42b9eb705d02426">match\_graph\_chain\_width</a>: For the <a href="/content/api/cpp/namespacegpudb#a7ad0718b76016b8c9b0a0de88ac84c7d">markov\_chain</a> solver only. Length of the sample points lookahead window within the Markov kernel; the larger the number, the more accurate the solution. The default value is '9'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aa13f9aae1c0b832c9506157b470b9dfd">match\_graph\_source</a>: WKT starting point from <span>samplePoints</span> for the solver. The default behavior for the endpoint is to use time to determine the starting point. The default value is 'POINT NULL'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ac287130305b0c5735894459b1e06b818">match\_graph\_destination</a>: WKT ending point from <span>samplePoints</span> for the solver. The default behavior for the endpoint is to use time to determine the destination point. The default value is 'POINT NULL'. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a5ca9626de28542759a1b6293be8189f7">match\_graph\_partial\_loading</a>: For the <a href="/content/api/cpp/namespacegpudb#a8f80b8e394deafc5d34236b69d6f9b73">match\_supply\_demand</a> solver only. When false (non-default), trucks do not off-load at the demand (store) side if the remainder is less than the store's need. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a332768f0618485847fd2dd66e18a1360">match\_graph\_true</a>: Partial off-loading at multiple store (demand) locations. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a594706f400701e02491d2a648558713b">match\_graph\_false</a>: No partial off-loading allowed if supply is less than the store's demand. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a332768f0618485847fd2dd66e18a1360">match\_graph\_true</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a6bf775bf9a24a15eac91bccc03962882">match\_graph\_max\_combinations</a>: For the <a href="/content/api/cpp/namespacegpudb#a8f80b8e394deafc5d34236b69d6f9b73">match\_supply\_demand</a> solver only. This is the cutoff for the number of generated combinations for sequencing the demand locations - can increase this up to 2M. The default value is '10000'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a971fbf1a96c6de0556c761e0fe354340">match\_graph\_max\_supply\_combinations</a>: For the <a href="/content/api/cpp/namespacegpudb#a8f80b8e394deafc5d34236b69d6f9b73">match\_supply\_demand</a> solver only. This is the cutoff for the number of generated combinations for sequencing the supply locations if/when 'permute\_supplies' is true. The default value is '10000'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#abeb53a7d9333b1208c7fde1345fe6f1b">match\_graph\_left\_turn\_penalty</a>: This will add an additional weight over the edges labeled as 'left turn' if the 'add\_turn' option parameter of the <a href="#a025f78582e1d24c590888a3d29e19f36">createGraph</a> was invoked at graph creation. The default value is '0.0'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a53c95f648987f6dfbf14963ace75acda">match\_graph\_right\_turn\_penalty</a>: This will add an additional weight over the edges labeled as' right turn' if the 'add\_turn' option parameter of the <a href="#a025f78582e1d24c590888a3d29e19f36">createGraph</a> was invoked at graph creation. The default value is '0.0'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a91d7e1185eca82260060fc03b8b9cb70">match\_graph\_intersection\_penalty</a>: This will add an additional weight over the edges labeled as 'intersection' if the 'add\_turn' option parameter of the <a href="#a025f78582e1d24c590888a3d29e19f36">createGraph</a> was invoked at graph creation. The default value is '0.0'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a989bc4180d02a248bb2ff5d3fc8e9bb5">match\_graph\_sharp\_turn\_penalty</a>: This will add an additional weight over the edges labeled as 'sharp turn' or 'u-turn' if the 'add\_turn' option parameter of the <a href="#a025f78582e1d24c590888a3d29e19f36">createGraph</a> was invoked at graph creation. The default value is '0.0'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a1b490d7e39262bd9349877fb8ad66b8e">match\_graph\_aggregated\_output</a>: For the <a href="/content/api/cpp/namespacegpudb#a8f80b8e394deafc5d34236b69d6f9b73">match\_supply\_demand</a> solver only. When it is true (default), each record in the output table shows a particular truck's scheduled cumulative round trip path (MULTILINESTRING) and the corresponding aggregated cost. Otherwise, each record shows a single scheduled truck route (LINESTRING) towards a particular demand location (store id) with its corresponding cost. The default value is 'true'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a18beb8acfc468d20f22377c5be05f029">match\_graph\_output\_tracks</a>: For the <a href="/content/api/cpp/namespacegpudb#a8f80b8e394deafc5d34236b69d6f9b73">match\_supply\_demand</a> solver only. When it is true (non-default), the output will be in tracks format for all the round trips of each truck in which the timestamps are populated directly from the edge weights starting from their originating depots. The default value is 'false'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a7621c1ba624f18e8c86333c60223b772">match\_graph\_max\_trip\_cost</a>: For the <a href="/content/api/cpp/namespacegpudb#a8f80b8e394deafc5d34236b69d6f9b73">match\_supply\_demand</a> and <a href="/content/api/cpp/namespacegpudb#a6ed1924b6d396735845214ea5312acad">match\_pickup\_dropoff</a> solvers only. If this constraint is greater than zero (default) then the trucks/rides will skip traveling from one demand/pick location to another if the cost between them is greater than this number (distance or time). Zero (default) value means no check is performed. The default value is '0.0'. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a016cdaf483664a97e8e986171d4c9e70">match\_graph\_filter\_folding\_paths</a>: For the <a href="/content/api/cpp/namespacegpudb#a7ad0718b76016b8c9b0a0de88ac84c7d">markov\_chain</a> solver only. When true (non-default), the paths per sequence combination is checked for folding over patterns and can significantly increase the execution time depending on the chain width and the number of GPS samples. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a332768f0618485847fd2dd66e18a1360">match\_graph\_true</a>: Filter out the folded paths. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a594706f400701e02491d2a648558713b">match\_graph\_false</a>: Do not filter out the folded paths. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a594706f400701e02491d2a648558713b">match\_graph\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a2fb796fe2d1559637cecf613444a2723">match\_graph\_unit\_unloading\_cost</a>: For the <a href="/content/api/cpp/namespacegpudb#a8f80b8e394deafc5d34236b69d6f9b73">match\_supply\_demand</a> solver only. The unit cost per load amount to be delivered. If this value is greater than zero (default) then the additional cost of this unit load multiplied by the total dropped load will be added over to the trip cost to the demand location. The default value is '0.0'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#af1c8e83e2626252fb4fbb7fa1de96ff7">match\_graph\_max\_num\_threads</a>: For the <a href="/content/api/cpp/namespacegpudb#a7ad0718b76016b8c9b0a0de88ac84c7d">markov\_chain</a> solver only. If specified (greater than zero), the maximum number of threads will not be greater than the specified value. It can be lower due to the memory and the number cores available. Default value of zero allows the algorithm to set the maximal number of threads within these constraints. The default value is '0'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aebec37ca89d6862bc0164a812a702502">match\_graph\_service\_limit</a>: For the <a href="/content/api/cpp/namespacegpudb#a8f80b8e394deafc5d34236b69d6f9b73">match\_supply\_demand</a> solver only. If specified (greater than zero), any supply actor's total service cost (distance or time) will be limited by the specified value including multiple rounds (if set). The default value is '0.0'. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a89beaba01481555200436e4bbeb01b17">match\_graph\_enable\_reuse</a>: For the <a href="/content/api/cpp/namespacegpudb#a8f80b8e394deafc5d34236b69d6f9b73">match\_supply\_demand</a> solver only. If specified (true), all supply actors can be scheduled for second rounds from their originating depots. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a332768f0618485847fd2dd66e18a1360">match\_graph\_true</a>: Allows reusing supply actors (trucks, e.g.) for scheduling again. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a594706f400701e02491d2a648558713b">match\_graph\_false</a>: Supply actors are scheduled only once from their depots. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a594706f400701e02491d2a648558713b">match\_graph\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a2102a4d9d59fa0e14ab4735ca4c64cd1">match\_graph\_max\_stops</a>: For the <a href="/content/api/cpp/namespacegpudb#a8f80b8e394deafc5d34236b69d6f9b73">match\_supply\_demand</a> solver only. If specified (greater than zero), a supply actor (truck) can at most have this many stops (demand locations) in one round trip. Otherwise, it is unlimited. If 'enable\_truck\_reuse' is on, this condition will be applied separately at each round trip use of the same truck. The default value is '0'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a72af04f919d7ada465cba47d6f4a8d21">match\_graph\_service\_radius</a>: For the <a href="/content/api/cpp/namespacegpudb#a8f80b8e394deafc5d34236b69d6f9b73">match\_supply\_demand</a> and <a href="/content/api/cpp/namespacegpudb#a6ed1924b6d396735845214ea5312acad">match\_pickup\_dropoff</a> solvers only. If specified (greater than zero), it filters the demands/picks outside this radius centered around the supply actor/ride's originating location (distance or time). The default value is '0.0'. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a6a4f125d6f9f714999a850a6bc3c4f42">match\_graph\_permute\_supplies</a>: For the <a href="/content/api/cpp/namespacegpudb#a8f80b8e394deafc5d34236b69d6f9b73">match\_supply\_demand</a> solver only. If specified (true), supply side actors are permuted for the demand combinations during MSDO optimization - note that this option increases optimization time significantly - use of 'max\_combinations' option is recommended to prevent prohibitively long runs. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a332768f0618485847fd2dd66e18a1360">match\_graph\_true</a>: Generates sequences over supply side permutations if total supply is less than twice the total demand. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a594706f400701e02491d2a648558713b">match\_graph\_false</a>: Permutations are not performed, rather a specific order of supplies based on capacity is computed. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a332768f0618485847fd2dd66e18a1360">match\_graph\_true</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a62d319d5df3e175b485da6e488588eff">match\_graph\_batch\_tsm\_mode</a>: For the <a href="/content/api/cpp/namespacegpudb#a8f80b8e394deafc5d34236b69d6f9b73">match\_supply\_demand</a> solver only. When enabled, it sets the number of visits on each demand location by a single salesman at each trip is considered to be (one) 1, otherwise there is no bound. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a332768f0618485847fd2dd66e18a1360">match\_graph\_true</a>: Sets only one visit per demand location by a salesman (TSM mode). </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a594706f400701e02491d2a648558713b">match\_graph\_false</a>: No preset limit (usual MSDO mode). </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a594706f400701e02491d2a648558713b">match\_graph\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ac4970d95192ea73ebecce943f5a6ebbf">match\_graph\_round\_trip</a>: For the <a href="/content/api/cpp/namespacegpudb#a8f80b8e394deafc5d34236b69d6f9b73">match\_supply\_demand</a> solver only. When enabled, the supply will have to return back to the origination location. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a332768f0618485847fd2dd66e18a1360">match\_graph\_true</a>: The optimization is done for trips in round trip manner always returning to originating locations. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a594706f400701e02491d2a648558713b">match\_graph\_false</a>: Supplies do not have to come back to their originating locations in their routes. The routes are considered finished at the final dropoff. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a332768f0618485847fd2dd66e18a1360">match\_graph\_true</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#af0b603a4b13584254318fa48df41d5bb">match\_graph\_num\_cycles</a>: For the <a href="/content/api/cpp/namespacegpudb#a93ed321a55a284d86e5f0a755dea35d8">match\_clusters</a> solver only. Terminates the cluster exchange iterations across 2-step-cycles (outer loop) when quality does not improve during iterations. The default value is '10'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a1c923bea5f46c4fe81b5d8e9fac31d80">match\_graph\_num\_loops\_per\_cycle</a>: For the <a href="/content/api/cpp/namespacegpudb#a93ed321a55a284d86e5f0a755dea35d8">match\_clusters</a> and <a href="/content/api/cpp/namespacegpudb#aa7d68e4514106fd078269ca284fcaeb3">match\_embedding</a> solvers only. Terminates the cluster exchanges within the first step iterations of a cycle (inner loop) unless convergence is reached. The default value is '10'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a6e6c37c6bd88fba0581a8b2e57e444fa">match\_graph\_num\_output\_clusters</a>: For the <a href="/content/api/cpp/namespacegpudb#a93ed321a55a284d86e5f0a755dea35d8">match\_clusters</a> solver only. Limits the output to the top 'num\_output\_clusters' clusters based on density. Default value of zero outputs all clusters. The default value is '0'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a6f6379cc5e8d66ca04dc5928197c842a">match\_graph\_max\_num\_clusters</a>: For the <a href="/content/api/cpp/namespacegpudb#a93ed321a55a284d86e5f0a755dea35d8">match\_clusters</a> and <a href="/content/api/cpp/namespacegpudb#aa7d68e4514106fd078269ca284fcaeb3">match\_embedding</a> solvers only. If set (value greater than zero), it terminates when the number of clusters goes below than this number. For embedding solver the default is 8. The default value is '0'. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#af0ff68eb99414c31f51da71c94ec1b08">match\_graph\_cluster\_quality\_metric</a>: For the <a href="/content/api/cpp/namespacegpudb#a93ed321a55a284d86e5f0a755dea35d8">match\_clusters</a> solver only. The quality metric for Louvain modularity optimization solver. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad843e2dfb092b5a005307d82b83a2c2a">match\_graph\_girvan</a>: Uses the Newman Girvan quality metric for cluster solver. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a19b4ab1cdbf377ac8dc0bda2f34a5f68">match\_graph\_spectral</a>: Applies recursive spectral bisection (RSB) partitioning solver. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ad843e2dfb092b5a005307d82b83a2c2a">match\_graph\_girvan</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ad5deb77689e7cf556eda927e2428e70a">match\_graph\_restricted\_type</a>: For the <a href="/content/api/cpp/namespacegpudb#a8f80b8e394deafc5d34236b69d6f9b73">match\_supply\_demand</a> solver only. Optimization is performed by restricting routes labeled by 'MSDO\_ODDEVEN\_RESTRICTED' only for this supply actor (truck) type. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a123b8f4a4a431562e437d715a896dc68">match\_graph\_odd</a>: Applies odd/even rule restrictions to odd tagged vehicles. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a3bfcdfd90e856815affb223f4335beec">match\_graph\_even</a>: Applies odd/even rule restrictions to even tagged vehicles. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a30b83b4be166e847127eb9be2efb553c">match\_graph\_none</a>: Does not apply odd/even rule restrictions to any vehicles. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a30b83b4be166e847127eb9be2efb553c">match\_graph\_none</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a4715ea8776985c4b99946348eae49e23">match\_graph\_server\_id</a>: Indicates which graph server(s) to send the request to. Default is to send to the server, amongst those containing the corresponding graph, that has the most computational bandwidth. The default value is ''. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a5a0230ee82aed9b0d5eb4000a14a245d">match\_graph\_inverse\_solve</a>: For the <a href="/content/api/cpp/namespacegpudb#a0f0ad2148c66745ae0326d8ffa1feeda">match\_batch\_solves</a> solver only. Solves source-destination pairs using inverse shortest path solver. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a332768f0618485847fd2dd66e18a1360">match\_graph\_true</a>: Solves using inverse shortest path solver. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a594706f400701e02491d2a648558713b">match\_graph\_false</a>: Solves using direct shortest path solver. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a594706f400701e02491d2a648558713b">match\_graph\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#ae7a3065edf17d1aefa1fb8f41821b68c">match\_graph\_min\_loop\_level</a>: For the <a href="/content/api/cpp/namespacegpudb#a870028a40aeeb32489b1ed2ac124ea51">match\_loops</a> solver only. Finds closed loops around each node deducible not less than this minimal hop (level) deep. The default value is '0'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a1b0414e388b87a93bef650c389db43cc">match\_graph\_max\_loop\_level</a>: For the <a href="/content/api/cpp/namespacegpudb#a870028a40aeeb32489b1ed2ac124ea51">match\_loops</a> solver only. Finds closed loops around each node deducible not more than this maximal hop (level) deep. The default value is '5'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a9e6acb8c9fc3b45ddfa0d0e70d30e074">match\_graph\_search\_limit</a>: For the <a href="/content/api/cpp/namespacegpudb#a870028a40aeeb32489b1ed2ac124ea51">match\_loops</a> solver only. Searches within this limit of nodes per vertex to detect loops. The value zero means there is no limit. The default value is '10000'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#af9419a4b85e0d3ba72fe5b1d4a9101b4">match\_graph\_output\_batch\_size</a>: For the <a href="/content/api/cpp/namespacegpudb#a870028a40aeeb32489b1ed2ac124ea51">match\_loops</a> solver only. Uses this value as the batch size of the number of loops in flushing(inserting) to the output table. The default value is '1000'. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a5617e18e8dc732c2bd222dad1ee4c5e9">match\_graph\_multi\_step</a>: For the <a href="/content/api/cpp/namespacegpudb#a8f80b8e394deafc5d34236b69d6f9b73">match\_supply\_demand</a> solver only. Runs multiple supply demand solver repeatedly in a multi step cycle by switching supplies to demands until it reaches the main hub supply. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a332768f0618485847fd2dd66e18a1360">match\_graph\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a594706f400701e02491d2a648558713b">match\_graph\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a594706f400701e02491d2a648558713b">match\_graph\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#ac4a701b547a8b1ba709ad1c13efc8ebc">match\_graph\_charging\_capacity</a>: For the <a href="/content/api/cpp/namespacegpudb#ace6c6283dc6cd2d9e29afea68c79b942">match\_charging\_stations</a> solver only. This is the maximum ev-charging capacity of a vehicle (distance in meters or time in seconds depending on the unit of the graph weights). The default value is '300000.0'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aabcacea13d04641f0ad1b0b693a93d9d">match\_graph\_charging\_candidates</a>: For the <a href="/content/api/cpp/namespacegpudb#ace6c6283dc6cd2d9e29afea68c79b942">match\_charging\_stations</a> solver only. Solver searches for this many number of stations closest around each base charging location found by capacity. The default value is '10'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ae8844e5dbc4c8870b01a3ec503dff5e8">match\_graph\_charging\_penalty</a>: For the <a href="/content/api/cpp/namespacegpudb#ace6c6283dc6cd2d9e29afea68c79b942">match\_charging\_stations</a> solver only. This is the penalty for full charging. The default value is '30000.0'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a9a688ea818e7b2ed01dd35257e8290fc">match\_graph\_detour\_mark\_cost</a>: For the <a href="/content/api/cpp/namespacegpudb#a99341caade4262a70954f23065993c3c">match\_route\_detour</a> solver only. Cost along the route at which to search for nearby stations If zero, it solves along the trip sliding the 3 SSSP cycle kernel by radius amount. The default value is '3600.0'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a2ef4994cf6d1e3baf767237d7b3debe6">match\_graph\_detour\_reentry\_factor</a>: For the <a href="/content/api/cpp/namespacegpudb#a99341caade4262a70954f23065993c3c">match\_route\_detour</a> solver only. Multiplier on detour\_mark\_cost to determine the reentry point on the route (default 1.2 means 20% further along). The default value is '1.2'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a3aed260768bf89964c7338f13a4e6039">match\_graph\_detour\_search\_radius</a>: For the <a href="/content/api/cpp/namespacegpudb#a99341caade4262a70954f23065993c3c">match\_route\_detour</a> solver only. Search radius around the mark point for finding nearby prospective stations (e.g. cafes, pit stops, EV charging stations). The default value is '600.0'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ac9da44dd69b388ff96ec77967a87385f">match\_graph\_detour\_search\_limit</a>: For the <a href="/content/api/cpp/namespacegpudb#a99341caade4262a70954f23065993c3c">match\_route\_detour</a> solver only. Maximum number of nearby stations to consider within the search radius around the mark point. The default value is '10'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ad33b839a557feca1020bb3a4841bb863">match\_graph\_max\_hops</a>: For the <a href="/content/api/cpp/namespacegpudb#a6f36f390b7dad827b2adbc627ee8a057">match\_similarity</a> and <a href="/content/api/cpp/namespacegpudb#aa7d68e4514106fd078269ca284fcaeb3">match\_embedding</a> solvers only. Searches within this maximum hops for source and target node pairs to compute the Jaccard scores. The default value is '3'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a8681e9fa5406b008c35620d0faee1ed9">match\_graph\_traversal\_node\_limit</a>: For the <a href="/content/api/cpp/namespacegpudb#a6f36f390b7dad827b2adbc627ee8a057">match\_similarity</a> solver only. Limits the traversal depth if it reaches this many number of nodes. The default value is '1000'. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a9642089436c6909ed1a8398d5dfa1958">match\_graph\_paired\_similarity</a>: For the <a href="/content/api/cpp/namespacegpudb#a6f36f390b7dad827b2adbc627ee8a057">match\_similarity</a> solver only. If true, it computes Jaccard score between each pair, otherwise it will compute Jaccard from the intersection set between the source and target nodes. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a332768f0618485847fd2dd66e18a1360">match\_graph\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a594706f400701e02491d2a648558713b">match\_graph\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a332768f0618485847fd2dd66e18a1360">match\_graph\_true</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a97fe0269a8e022e0a9bb12c4ae0a4856">match\_graph\_force\_undirected</a>: For the <a href="/content/api/cpp/namespacegpudb#ad5033e349cb6279334df27d2217259a1">match\_pattern</a> and <a href="/content/api/cpp/namespacegpudb#aa7d68e4514106fd078269ca284fcaeb3">match\_embedding</a> solvers only. Pattern matching will be using both pattern and graph as undirected if set to true. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a332768f0618485847fd2dd66e18a1360">match\_graph\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a594706f400701e02491d2a648558713b">match\_graph\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a594706f400701e02491d2a648558713b">match\_graph\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a30da5b563985edf135a7a3cc161e351f">match\_graph\_max\_vector\_dimension</a>: For the <a href="/content/api/cpp/namespacegpudb#aa7d68e4514106fd078269ca284fcaeb3">match\_embedding</a> solver only. Limits the number of dimensions in node vector embeddings. The default value is '1000'. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a151e4380fc84c0a9093364ef6cac1def">match\_graph\_optimize\_embedding\_weights</a>: For the <a href="/content/api/cpp/namespacegpudb#aa7d68e4514106fd078269ca284fcaeb3">match\_embedding</a> solvers only. Solves to find the optimal weights per sub feature in vector embeddings. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a332768f0618485847fd2dd66e18a1360">match\_graph\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a594706f400701e02491d2a648558713b">match\_graph\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a594706f400701e02491d2a648558713b">match\_graph\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a74df0c496679cba30fe0717d339a34bb">match\_graph\_embedding\_weights</a>: For the <a href="/content/api/cpp/namespacegpudb#aa7d68e4514106fd078269ca284fcaeb3">match\_embedding</a> solver only. User specified weights per sub feature in vector embeddings. The string contains the comma separated float values for each sub-feature in the vector space. These values will ONLY be used if 'optimize\_embedding\_weights' is false. The default value is '1.0,1.0,1.0,1.0'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a525917edc2588120657f36ddfcbf3278">match\_graph\_optimization\_sampling\_size</a>: For the <a href="/content/api/cpp/namespacegpudb#aa7d68e4514106fd078269ca284fcaeb3">match\_embedding</a> solver only. Sets the number of random nodes from the graph for solving the weights using stochastic gradient descent. The default value is '1000'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#adb12f28ff3c95dc31c6c7fdfcf881ed0">match\_graph\_optimization\_max\_iterations</a>: For the <a href="/content/api/cpp/namespacegpudb#aa7d68e4514106fd078269ca284fcaeb3">match\_embedding</a> solver only. When the iterations (epochs) for the convergence of the stochastic gradient descent algorithm reaches this number it bails out unless relative error between consecutive iterations is below the 'optimization\_error\_tolerance' option. The default value is '1000'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ad57a45a4806326703138daecd26d3c47">match\_graph\_optimization\_error\_tolerance</a>: For the <a href="/content/api/cpp/namespacegpudb#aa7d68e4514106fd078269ca284fcaeb3">match\_embedding</a> solver only. When the relative error between all of the weights' consecutive iterations falls below this threshold the optimization cycle is interrupted unless the number of iterations reaches the limit set by the option 'max\_optimization\_iterations'. The default value is '0.001'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a1a93db4bd4d845c7a7704efe837dc900">match\_graph\_optimization\_iteration\_rate</a>: For the <a href="/content/api/cpp/namespacegpudb#aa7d68e4514106fd078269ca284fcaeb3">match\_embedding</a> solver only. It is otherwise known as the learning rate, which is the proportionality constant in front of the gradient term in successive iterations. The default value is '0.3'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a373218af523994eac0135cb813e2a593">match\_graph\_max\_radius</a>: For the <a href="/content/api/cpp/namespacegpudb#ace7e2fec0b9a36ad6466bd61daabd542">match\_isochrone</a> solver only. Sets the maximal reachability limit for computing isochrones. Zero means no limit. The default value is '0.0'. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1MatchGraphResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1MatchGraphResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a912d185d316a02e1b1cb366ef352fbcf">◆ </a></span>modifyGraph() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ModifyGraphResponse">ModifyGraphResponse</a> gpudb::GPUdb::modifyGraph </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1ModifyGraphRequest">ModifyGraphRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Update an existing graph network using given nodes, edges, weights, restrictions, and options. </p>
        <p>IMPORTANT: It's highly recommended that you review the <a href="/content/graph_solver/network_graph_solver/">Graphs and Solvers</a> concepts documentation, and <a href="/content/guides/graph_rest_guide/">Graph REST Tutorial</a> before using this endpoint.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ModifyGraphRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ModifyGraphResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ae4cb6f77f809e3e948ea5dd1fc1edb3d">◆ </a></span>modifyGraph() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ModifyGraphResponse">ModifyGraphResponse</a> & gpudb::GPUdb::modifyGraph </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1ModifyGraphRequest">ModifyGraphRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1ModifyGraphResponse">ModifyGraphResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Update an existing graph network using given nodes, edges, weights, restrictions, and options. </p>
        <p>IMPORTANT: It's highly recommended that you review the <a href="/content/graph_solver/network_graph_solver/">Graphs and Solvers</a> concepts documentation, and <a href="/content/guides/graph_rest_guide/">Graph REST Tutorial</a> before using this endpoint.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ModifyGraphRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ModifyGraphResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ModifyGraphResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#afab27a20c1d067dff08ca9bd9c8bedf0">◆ </a></span>modifyGraph() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ModifyGraphResponse">ModifyGraphResponse</a> gpudb::GPUdb::modifyGraph </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>graphName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< std::string > &</td>
            <td><span><span>nodes</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< std::string > &</td>
            <td><span><span>edges</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< std::string > &</td>
            <td><span><span>weights</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< std::string > &</td>
            <td><span><span>restrictions</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Update an existing graph network using given nodes, edges, weights, restrictions, and options. </p>
        <p>IMPORTANT: It's highly recommended that you review the <a href="/content/graph_solver/network_graph_solver/">Graphs and Solvers</a> concepts documentation, and <a href="/content/guides/graph_rest_guide/">Graph REST Tutorial</a> before using this endpoint.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>graphName</td>
                <td>Name of the graph resource to modify. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>nodes</td>
                <td>Nodes with which to update existing <span>nodes</span> in graph specified by <span>graphName</span>. Review <a href="/content/graph_solver/network_graph_solver/#nodes">Nodes</a> for more information. Nodes must be specified using <a href="/content/graph_solver/network_graph_solver/#identifiers">identifiers</a>; identifiers are grouped as <a href="/content/graph_solver/network_graph_solver/#id-combos">combinations</a>. Identifiers can be used with existing column names, e.g., 'table.column AS NODE\_ID', expressions, e.g., 'ST\_MAKEPOINT(column1, column2) AS NODE\_WKTPOINT', or raw values, e.g., '9, 10, 11 AS NODE\_ID'. If using raw values in an identifier combination, the number of values specified must match across the combination. Identifier combination(s) do not have to match the method used to create the graph, e.g., if column names were specified to create the graph, expressions or raw values could also be used to modify the graph. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>edges</td>
                <td>Edges with which to update existing <span>edges</span> in graph specified by <span>graphName</span>. Review <a href="/content/graph_solver/network_graph_solver/#edges">Edges</a> for more information. Edges must be specified using <a href="/content/graph_solver/network_graph_solver/#identifiers">identifiers</a>; identifiers are grouped as <a href="/content/graph_solver/network_graph_solver/#id-combos">combinations</a>. Identifiers can be used with existing column names, e.g., 'table.column AS EDGE\_ID', expressions, e.g., 'SUBSTR(column, 1, 6) AS EDGE\_NODE1\_NAME', or raw values, e.g., "'family', 'coworker' AS EDGE\_LABEL". If using raw values in an identifier combination, the number of values specified must match across the combination. Identifier combination(s) do not have to match the method used to create the graph, e.g., if column names were specified to create the graph, expressions or raw values could also be used to modify the graph. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>weights</td>
                <td>Weights with which to update existing <span>weights</span> in graph specified by <span>graphName</span>. Review <a href="/content/graph_solver/network_graph_solver/#graph-weights">Weights</a> for more information. Weights must be specified using <a href="/content/graph_solver/network_graph_solver/#identifiers">identifiers</a>; identifiers are grouped as <a href="/content/graph_solver/network_graph_solver/#id-combos">combinations</a>. Identifiers can be used with existing column names, e.g., 'table.column AS WEIGHTS\_EDGE\_ID', expressions, e.g., 'ST\_LENGTH(wkt) AS WEIGHTS\_VALUESPECIFIED', or raw values, e.g., '4, 15 AS WEIGHTS\_VALUESPECIFIED'. If using raw values in an identifier combination, the number of values specified must match across the combination. Identifier combination(s) do not have to match the method used to create the graph, e.g., if column names were specified to create the graph, expressions or raw values could also be used to modify the graph. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>restrictions</td>
                <td>Restrictions with which to update existing <span>restrictions</span> in graph specified by <span>graphName</span>. Review <a href="/content/graph_solver/network_graph_solver/#graph-restrictions">Restrictions</a> for more information. Restrictions must be specified using <a href="/content/graph_solver/network_graph_solver/#identifiers">identifiers</a>; identifiers are grouped as <a href="/content/graph_solver/network_graph_solver/#id-combos">combinations</a>. Identifiers can be used with existing column names, e.g., 'table.column AS RESTRICTIONS\_EDGE\_ID', expressions, e.g., 'column/2 AS RESTRICTIONS\_VALUECOMPARED', or raw values, e.g., '0, 0, 0, 1 AS RESTRICTIONS\_ONOFFCOMPARED'. If using raw values in an identifier combination, the number of values specified must match across the combination. Identifier combination(s) do not have to match the method used to create the graph, e.g., if column names were specified to create the graph, expressions or raw values could also be used to modify the graph. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#ae19dc32523a8371277797f84666bb962">modify\_graph\_restriction\_threshold\_value</a>: Value-based restriction comparison. Any node or edge with a RESTRICTIONS\_VALUECOMPARED value greater than the <a href="/content/api/cpp/namespacegpudb#ae19dc32523a8371277797f84666bb962">restriction\_threshold\_value</a> will not be included in the graph. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#af50cd242d9124156fd783c163d724bf5">modify\_graph\_export\_create\_results</a>: If set to <a href="/content/api/cpp/namespacegpudb#a1f3bc632081b751d3512630697e9fb94">true</a>, returns the graph topology in the response as arrays. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a1f3bc632081b751d3512630697e9fb94">modify\_graph\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aed15081a979a75ad82dc1951457985d5">modify\_graph\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#aed15081a979a75ad82dc1951457985d5">modify\_graph\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a9322ad5a8960fecd14322fe29f3bb941">modify\_graph\_enable\_graph\_draw</a>: If set to <a href="/content/api/cpp/namespacegpudb#a1f3bc632081b751d3512630697e9fb94">true</a>, adds a 'EDGE\_WKTLINE' column identifier to the specified <a href="/content/api/cpp/namespacegpudb#aaf66d21f5695a282e405dbc923d07f66">graph\_table</a> so the graph can be viewed via WMS; for social and non-geospatial graphs, the 'EDGE\_WKTLINE' column identifier will be populated with spatial coordinates derived from a flattening layout algorithm so the graph can still be viewed. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a1f3bc632081b751d3512630697e9fb94">modify\_graph\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aed15081a979a75ad82dc1951457985d5">modify\_graph\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#aed15081a979a75ad82dc1951457985d5">modify\_graph\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a7ba706dac9f510454b9c0aa5fc204ad2">modify\_graph\_save\_persist</a>: If set to <a href="/content/api/cpp/namespacegpudb#a1f3bc632081b751d3512630697e9fb94">true</a>, the graph will be saved in the persist directory (see the <a href="/content/config/">config reference</a> for more information). If set to <a href="/content/api/cpp/namespacegpudb#aed15081a979a75ad82dc1951457985d5">false</a>, the graph will be removed when the graph server is shutdown. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a1f3bc632081b751d3512630697e9fb94">modify\_graph\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aed15081a979a75ad82dc1951457985d5">modify\_graph\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#aed15081a979a75ad82dc1951457985d5">modify\_graph\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a90ab76c0e3f009909964113b37940e3c">modify\_graph\_add\_table\_monitor</a>: Adds a table monitor to every table used in the creation of the graph; this table monitor will trigger the graph to update dynamically upon inserts to the source table(s). Note that upon database restart, if <a href="/content/api/cpp/namespacegpudb#a7ba706dac9f510454b9c0aa5fc204ad2">save\_persist</a> is also set to <a href="/content/api/cpp/namespacegpudb#a1f3bc632081b751d3512630697e9fb94">true</a>, the graph will be fully reconstructed and the table monitors will be reattached. For more details on table monitors, see <a href="#a562dc443f79f57ea572cb5ec0f2e8093">createTableMonitor</a>. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a1f3bc632081b751d3512630697e9fb94">modify\_graph\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aed15081a979a75ad82dc1951457985d5">modify\_graph\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#aed15081a979a75ad82dc1951457985d5">modify\_graph\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#aaf66d21f5695a282e405dbc923d07f66">modify\_graph\_graph\_table</a>: If specified, the created graph is also created as a table with the given name, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a> and meeting <a href="/content/concepts/tables/#table-naming-criteria">table naming criteria</a>. This table will have the following identifier columns: 'EDGE\_ID', 'EDGE\_NODE1\_ID', 'EDGE\_NODE2\_ID'. If left blank, no table is created. The default value is ''. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ae951116d1e9e96c68f03293d1309a2b0">modify\_graph\_remove\_label\_only</a>: When RESTRICTIONS on labeled entities requested, if set to true this will NOT delete the entity but only the label associated with the entity. Otherwise (default), it'll delete the label AND the entity. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a1f3bc632081b751d3512630697e9fb94">modify\_graph\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aed15081a979a75ad82dc1951457985d5">modify\_graph\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#aed15081a979a75ad82dc1951457985d5">modify\_graph\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a3563829de4ef0e818b8cf74626cd091d">modify\_graph\_add\_turns</a>: Adds dummy 'pillowed' edges around intersection nodes where there are more than three edges so that additional weight penalties can be imposed by the solve endpoints. (increases the total number of edges). Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a1f3bc632081b751d3512630697e9fb94">modify\_graph\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aed15081a979a75ad82dc1951457985d5">modify\_graph\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#aed15081a979a75ad82dc1951457985d5">modify\_graph\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a387a1f8ae338625e07cb0bf897a1743c">modify\_graph\_turn\_angle</a>: Value in degrees modifies the thresholds for attributing right, left, sharp turns, and intersections. It is the vertical deviation angle from the incoming edge to the intersection node. The larger the value, the larger the threshold for sharp turns and intersections; the smaller the value, the larger the threshold for right and left turns; 0 \< turn\_angle \< 90. The default value is '60'. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a716b56c9b0246f3f9408ae80ebd4fd1f">modify\_graph\_use\_rtree</a>: Use an range tree structure to accelerate and improve the accuracy of snapping, especially to edges. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a1f3bc632081b751d3512630697e9fb94">modify\_graph\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aed15081a979a75ad82dc1951457985d5">modify\_graph\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a1f3bc632081b751d3512630697e9fb94">modify\_graph\_true</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#afa959fbc6987a7b01b09a83c062cb7cb">modify\_graph\_label\_delimiter</a>: If provided the label string will be split according to this delimiter and each sub-string will be applied as a separate label onto the specified edge. The default value is ''. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a6c220d3edef61a065d7752f7a28d3b34">modify\_graph\_allow\_multiple\_edges</a>: Multigraph choice; allowing multiple edges with the same node pairs if set to true, otherwise, new edges with existing same node pairs will not be inserted. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a1f3bc632081b751d3512630697e9fb94">modify\_graph\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aed15081a979a75ad82dc1951457985d5">modify\_graph\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a1f3bc632081b751d3512630697e9fb94">modify\_graph\_true</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#acb1907fad7cc6aaa54c03696aac67b02">modify\_graph\_embedding\_table</a>: If table exists (should be generated by the match/graph match\_embedding solver), the vector embeddings for the newly inserted nodes will be appended into this table. The default value is ''. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ModifyGraphResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a174058fcfbf79c498610ab1d5efa3e76">◆ </a></span>modifyGraph() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ModifyGraphResponse">ModifyGraphResponse</a> & gpudb::GPUdb::modifyGraph </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>graphName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< std::string > &</td>
            <td><span><span>nodes</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< std::string > &</td>
            <td><span><span>edges</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< std::string > &</td>
            <td><span><span>weights</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< std::string > &</td>
            <td><span><span>restrictions</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1ModifyGraphResponse">ModifyGraphResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Update an existing graph network using given nodes, edges, weights, restrictions, and options. </p>
        <p>IMPORTANT: It's highly recommended that you review the <a href="/content/graph_solver/network_graph_solver/">Graphs and Solvers</a> concepts documentation, and <a href="/content/guides/graph_rest_guide/">Graph REST Tutorial</a> before using this endpoint.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>graphName</td>
                <td>Name of the graph resource to modify. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>nodes</td>
                <td>Nodes with which to update existing <span>nodes</span> in graph specified by <span>graphName</span>. Review <a href="/content/graph_solver/network_graph_solver/#nodes">Nodes</a> for more information. Nodes must be specified using <a href="/content/graph_solver/network_graph_solver/#identifiers">identifiers</a>; identifiers are grouped as <a href="/content/graph_solver/network_graph_solver/#id-combos">combinations</a>. Identifiers can be used with existing column names, e.g., 'table.column AS NODE\_ID', expressions, e.g., 'ST\_MAKEPOINT(column1, column2) AS NODE\_WKTPOINT', or raw values, e.g., '9, 10, 11 AS NODE\_ID'. If using raw values in an identifier combination, the number of values specified must match across the combination. Identifier combination(s) do not have to match the method used to create the graph, e.g., if column names were specified to create the graph, expressions or raw values could also be used to modify the graph. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>edges</td>
                <td>Edges with which to update existing <span>edges</span> in graph specified by <span>graphName</span>. Review <a href="/content/graph_solver/network_graph_solver/#edges">Edges</a> for more information. Edges must be specified using <a href="/content/graph_solver/network_graph_solver/#identifiers">identifiers</a>; identifiers are grouped as <a href="/content/graph_solver/network_graph_solver/#id-combos">combinations</a>. Identifiers can be used with existing column names, e.g., 'table.column AS EDGE\_ID', expressions, e.g., 'SUBSTR(column, 1, 6) AS EDGE\_NODE1\_NAME', or raw values, e.g., "'family', 'coworker' AS EDGE\_LABEL". If using raw values in an identifier combination, the number of values specified must match across the combination. Identifier combination(s) do not have to match the method used to create the graph, e.g., if column names were specified to create the graph, expressions or raw values could also be used to modify the graph. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>weights</td>
                <td>Weights with which to update existing <span>weights</span> in graph specified by <span>graphName</span>. Review <a href="/content/graph_solver/network_graph_solver/#graph-weights">Weights</a> for more information. Weights must be specified using <a href="/content/graph_solver/network_graph_solver/#identifiers">identifiers</a>; identifiers are grouped as <a href="/content/graph_solver/network_graph_solver/#id-combos">combinations</a>. Identifiers can be used with existing column names, e.g., 'table.column AS WEIGHTS\_EDGE\_ID', expressions, e.g., 'ST\_LENGTH(wkt) AS WEIGHTS\_VALUESPECIFIED', or raw values, e.g., '4, 15 AS WEIGHTS\_VALUESPECIFIED'. If using raw values in an identifier combination, the number of values specified must match across the combination. Identifier combination(s) do not have to match the method used to create the graph, e.g., if column names were specified to create the graph, expressions or raw values could also be used to modify the graph. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>restrictions</td>
                <td>Restrictions with which to update existing <span>restrictions</span> in graph specified by <span>graphName</span>. Review <a href="/content/graph_solver/network_graph_solver/#graph-restrictions">Restrictions</a> for more information. Restrictions must be specified using <a href="/content/graph_solver/network_graph_solver/#identifiers">identifiers</a>; identifiers are grouped as <a href="/content/graph_solver/network_graph_solver/#id-combos">combinations</a>. Identifiers can be used with existing column names, e.g., 'table.column AS RESTRICTIONS\_EDGE\_ID', expressions, e.g., 'column/2 AS RESTRICTIONS\_VALUECOMPARED', or raw values, e.g., '0, 0, 0, 1 AS RESTRICTIONS\_ONOFFCOMPARED'. If using raw values in an identifier combination, the number of values specified must match across the combination. Identifier combination(s) do not have to match the method used to create the graph, e.g., if column names were specified to create the graph, expressions or raw values could also be used to modify the graph. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#ae19dc32523a8371277797f84666bb962">modify\_graph\_restriction\_threshold\_value</a>: Value-based restriction comparison. Any node or edge with a RESTRICTIONS\_VALUECOMPARED value greater than the <a href="/content/api/cpp/namespacegpudb#ae19dc32523a8371277797f84666bb962">restriction\_threshold\_value</a> will not be included in the graph. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#af50cd242d9124156fd783c163d724bf5">modify\_graph\_export\_create\_results</a>: If set to <a href="/content/api/cpp/namespacegpudb#a1f3bc632081b751d3512630697e9fb94">true</a>, returns the graph topology in the response as arrays. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a1f3bc632081b751d3512630697e9fb94">modify\_graph\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aed15081a979a75ad82dc1951457985d5">modify\_graph\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#aed15081a979a75ad82dc1951457985d5">modify\_graph\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a9322ad5a8960fecd14322fe29f3bb941">modify\_graph\_enable\_graph\_draw</a>: If set to <a href="/content/api/cpp/namespacegpudb#a1f3bc632081b751d3512630697e9fb94">true</a>, adds a 'EDGE\_WKTLINE' column identifier to the specified <a href="/content/api/cpp/namespacegpudb#aaf66d21f5695a282e405dbc923d07f66">graph\_table</a> so the graph can be viewed via WMS; for social and non-geospatial graphs, the 'EDGE\_WKTLINE' column identifier will be populated with spatial coordinates derived from a flattening layout algorithm so the graph can still be viewed. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a1f3bc632081b751d3512630697e9fb94">modify\_graph\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aed15081a979a75ad82dc1951457985d5">modify\_graph\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#aed15081a979a75ad82dc1951457985d5">modify\_graph\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a7ba706dac9f510454b9c0aa5fc204ad2">modify\_graph\_save\_persist</a>: If set to <a href="/content/api/cpp/namespacegpudb#a1f3bc632081b751d3512630697e9fb94">true</a>, the graph will be saved in the persist directory (see the <a href="/content/config/">config reference</a> for more information). If set to <a href="/content/api/cpp/namespacegpudb#aed15081a979a75ad82dc1951457985d5">false</a>, the graph will be removed when the graph server is shutdown. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a1f3bc632081b751d3512630697e9fb94">modify\_graph\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aed15081a979a75ad82dc1951457985d5">modify\_graph\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#aed15081a979a75ad82dc1951457985d5">modify\_graph\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a90ab76c0e3f009909964113b37940e3c">modify\_graph\_add\_table\_monitor</a>: Adds a table monitor to every table used in the creation of the graph; this table monitor will trigger the graph to update dynamically upon inserts to the source table(s). Note that upon database restart, if <a href="/content/api/cpp/namespacegpudb#a7ba706dac9f510454b9c0aa5fc204ad2">save\_persist</a> is also set to <a href="/content/api/cpp/namespacegpudb#a1f3bc632081b751d3512630697e9fb94">true</a>, the graph will be fully reconstructed and the table monitors will be reattached. For more details on table monitors, see <a href="#a562dc443f79f57ea572cb5ec0f2e8093">createTableMonitor</a>. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a1f3bc632081b751d3512630697e9fb94">modify\_graph\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aed15081a979a75ad82dc1951457985d5">modify\_graph\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#aed15081a979a75ad82dc1951457985d5">modify\_graph\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#aaf66d21f5695a282e405dbc923d07f66">modify\_graph\_graph\_table</a>: If specified, the created graph is also created as a table with the given name, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a> and meeting <a href="/content/concepts/tables/#table-naming-criteria">table naming criteria</a>. This table will have the following identifier columns: 'EDGE\_ID', 'EDGE\_NODE1\_ID', 'EDGE\_NODE2\_ID'. If left blank, no table is created. The default value is ''. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ae951116d1e9e96c68f03293d1309a2b0">modify\_graph\_remove\_label\_only</a>: When RESTRICTIONS on labeled entities requested, if set to true this will NOT delete the entity but only the label associated with the entity. Otherwise (default), it'll delete the label AND the entity. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a1f3bc632081b751d3512630697e9fb94">modify\_graph\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aed15081a979a75ad82dc1951457985d5">modify\_graph\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#aed15081a979a75ad82dc1951457985d5">modify\_graph\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a3563829de4ef0e818b8cf74626cd091d">modify\_graph\_add\_turns</a>: Adds dummy 'pillowed' edges around intersection nodes where there are more than three edges so that additional weight penalties can be imposed by the solve endpoints. (increases the total number of edges). Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a1f3bc632081b751d3512630697e9fb94">modify\_graph\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aed15081a979a75ad82dc1951457985d5">modify\_graph\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#aed15081a979a75ad82dc1951457985d5">modify\_graph\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a387a1f8ae338625e07cb0bf897a1743c">modify\_graph\_turn\_angle</a>: Value in degrees modifies the thresholds for attributing right, left, sharp turns, and intersections. It is the vertical deviation angle from the incoming edge to the intersection node. The larger the value, the larger the threshold for sharp turns and intersections; the smaller the value, the larger the threshold for right and left turns; 0 \< turn\_angle \< 90. The default value is '60'. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a716b56c9b0246f3f9408ae80ebd4fd1f">modify\_graph\_use\_rtree</a>: Use an range tree structure to accelerate and improve the accuracy of snapping, especially to edges. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a1f3bc632081b751d3512630697e9fb94">modify\_graph\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aed15081a979a75ad82dc1951457985d5">modify\_graph\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a1f3bc632081b751d3512630697e9fb94">modify\_graph\_true</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#afa959fbc6987a7b01b09a83c062cb7cb">modify\_graph\_label\_delimiter</a>: If provided the label string will be split according to this delimiter and each sub-string will be applied as a separate label onto the specified edge. The default value is ''. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a6c220d3edef61a065d7752f7a28d3b34">modify\_graph\_allow\_multiple\_edges</a>: Multigraph choice; allowing multiple edges with the same node pairs if set to true, otherwise, new edges with existing same node pairs will not be inserted. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a1f3bc632081b751d3512630697e9fb94">modify\_graph\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aed15081a979a75ad82dc1951457985d5">modify\_graph\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a1f3bc632081b751d3512630697e9fb94">modify\_graph\_true</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#acb1907fad7cc6aaa54c03696aac67b02">modify\_graph\_embedding\_table</a>: If table exists (should be generated by the match/graph match\_embedding solver), the vector embeddings for the newly inserted nodes will be appended into this table. The default value is ''. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ModifyGraphResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ModifyGraphResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#aa19b2032dbef0fd308b55202fcb738fa">◆ </a></span>queryGraph() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1QueryGraphResponse">QueryGraphResponse</a> gpudb::GPUdb::queryGraph </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1QueryGraphRequest">QueryGraphRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Employs a topological query on a graph generated a-priori by <a href="#a4055b3b0cd047d5c78f8ab61350e1c4e">createGraph</a> and returns a list of adjacent edge(s) or node(s), also known as an adjacency list, depending on what's been provided to the endpoint; providing edges will return nodes and providing nodes will return edges. </p>
        <p>To determine the node(s) or edge(s) adjacent to a value from a given column, provide a list of values to <a href="/content/api/cpp/structgpudb_1_1QueryGraphRequest#a8b2317188945fb7342e569296c876a4a">queries</a>. This field can be populated with column values from any table as long as the type is supported by the given identifier. See <a href="/content/graph_solver/network_graph_solver/#query-identifiers">Query Identifiers</a> for more information.</p>
        <p>To return the adjacency list in the response, leave <a href="/content/api/cpp/structgpudb_1_1QueryGraphRequest#a3be4a716bb21623b98e4dfa4392d9b0e">adjacencyTable</a> empty.</p>
        <p>IMPORTANT: It's highly recommended that you review the <a href="/content/graph_solver/network_graph_solver/">Graphs and Solvers</a> concepts documentation, the <a href="/content/guides/graph_rest_guide/">Graph REST Tutorial</a>, and/or some <a href="/content/guides/tags/graph-query">/match/graph examples</a> before using this endpoint.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1QueryGraphRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1QueryGraphResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a08bbe4ff8674e31412e17280c1bc783e">◆ </a></span>queryGraph() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1QueryGraphResponse">QueryGraphResponse</a> & gpudb::GPUdb::queryGraph </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1QueryGraphRequest">QueryGraphRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1QueryGraphResponse">QueryGraphResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Employs a topological query on a graph generated a-priori by <a href="#a4055b3b0cd047d5c78f8ab61350e1c4e">createGraph</a> and returns a list of adjacent edge(s) or node(s), also known as an adjacency list, depending on what's been provided to the endpoint; providing edges will return nodes and providing nodes will return edges. </p>
        <p>To determine the node(s) or edge(s) adjacent to a value from a given column, provide a list of values to <a href="/content/api/cpp/structgpudb_1_1QueryGraphRequest#a8b2317188945fb7342e569296c876a4a">queries</a>. This field can be populated with column values from any table as long as the type is supported by the given identifier. See <a href="/content/graph_solver/network_graph_solver/#query-identifiers">Query Identifiers</a> for more information.</p>
        <p>To return the adjacency list in the response, leave <a href="/content/api/cpp/structgpudb_1_1QueryGraphRequest#a3be4a716bb21623b98e4dfa4392d9b0e">adjacencyTable</a> empty.</p>
        <p>IMPORTANT: It's highly recommended that you review the <a href="/content/graph_solver/network_graph_solver/">Graphs and Solvers</a> concepts documentation, the <a href="/content/guides/graph_rest_guide/">Graph REST Tutorial</a>, and/or some <a href="/content/guides/tags/graph-query">/match/graph examples</a> before using this endpoint.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1QueryGraphRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1QueryGraphResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1QueryGraphResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#adc39e9e087081da5e5da059ccf682b34">◆ </a></span>queryGraph() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1QueryGraphResponse">QueryGraphResponse</a> gpudb::GPUdb::queryGraph </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>graphName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< std::string > &</td>
            <td><span><span>queries</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< std::string > &</td>
            <td><span><span>restrictions</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>adjacencyTable</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const int32\_t</td>
            <td><span><span>rings</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Employs a topological query on a graph generated a-priori by <a href="#a025f78582e1d24c590888a3d29e19f36">createGraph</a> and returns a list of adjacent edge(s) or node(s), also known as an adjacency list, depending on what's been provided to the endpoint; providing edges will return nodes and providing nodes will return edges. </p>
        <p>To determine the node(s) or edge(s) adjacent to a value from a given column, provide a list of values to <span>queries</span>. This field can be populated with column values from any table as long as the type is supported by the given identifier. See <a href="/content/graph_solver/network_graph_solver/#query-identifiers">Query Identifiers</a> for more information.</p>
        <p>To return the adjacency list in the response, leave <span>adjacencyTable</span> empty.</p>
        <p>IMPORTANT: It's highly recommended that you review the <a href="/content/graph_solver/network_graph_solver/">Graphs and Solvers</a> concepts documentation, the <a href="/content/guides/graph_rest_guide/">Graph REST Tutorial</a>, and/or some <a href="/content/guides/tags/graph-query">/match/graph examples</a> before using this endpoint.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>graphName</td>
                <td>Name of the graph resource to query. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>queries</td>
                <td>Nodes or edges to be queried specified using <a href="/content/graph_solver/network_graph_solver/#query-identifiers">query identifiers</a>. Identifiers can be used with existing column names, e.g., 'table.column AS QUERY\_NODE\_ID', raw values, e.g., '0, 2 AS QUERY\_NODE\_ID', or expressions, e.g., 'ST\_MAKEPOINT(table.x, table.y) AS QUERY\_NODE\_WKTPOINT'. Multiple values can be provided as long as the same identifier is used for all values. If using raw values in an identifier combination, the number of values specified must match across the combination. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>restrictions</td>
                <td>Additional restrictions to apply to the nodes/edges of an existing graph. Restrictions must be specified using <a href="/content/graph_solver/network_graph_solver/#identifiers">identifiers</a>; identifiers are grouped as <a href="/content/graph_solver/network_graph_solver/#id-combos">combinations</a>. Identifiers can be used with existing column names, e.g., 'table.column AS RESTRICTIONS\_EDGE\_ID', expressions, e.g., 'column/2 AS RESTRICTIONS\_VALUECOMPARED', or raw values, e.g., '0, 0, 0, 1 AS RESTRICTIONS\_ONOFFCOMPARED'. If using raw values in an identifier combination, the number of values specified must match across the combination. The default value is an empty vector. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>adjacencyTable</td>
                <td>Name of the table to store the resulting adjacencies, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a> and meeting <a href="/content/concepts/tables/#table-naming-criteria">table naming criteria</a>. If left blank, the query results are instead returned in the response. If the 'QUERY\_TARGET\_NODE\_LABEL' <a href="/content/graph_solver/network_graph_solver/#query-identifiers">query identifier</a> is used in <span>queries</span>, then two additional columns will be available: 'PATH\_ID' and 'RING\_ID'. See <a href="/content/graph_solver/network_graph_solver/#using-labels">Using Labels</a> for more information. The default value is ''. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>rings</td>
                <td>Sets the number of rings around the node to query for adjacency, with '1' being the edges directly attached to the queried node. Also known as number of hops. For example, if it is set to '2', the edge(s) directly attached to the queried node(s) will be returned; in addition, the edge(s) attached to the node(s) attached to the initial ring of edge(s) surrounding the queried node(s) will be returned. If the value is set to '0', any nodes that meet the criteria in <span>queries</span> and <span>restrictions</span> will be returned. This parameter is only applicable when querying nodes. The default value is 1. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Additional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a1dcd1e4aa5331b29f656ec75cfddc0b1">query\_graph\_force\_undirected</a>: If set to <a href="/content/api/cpp/namespacegpudb#aa1cd1170a7b667692ad0549777c7e1f2">true</a>, all inbound edges and outbound edges relative to the node will be returned. If set to <a href="/content/api/cpp/namespacegpudb#a77fd961bc121320757340b18ae256129">false</a>, only outbound edges relative to the node will be returned. This parameter is only applicable if the queried graph <span>graphName</span> is directed and when querying nodes. Consult <a href="/content/graph_solver/network_graph_solver/#directed-graphs">Directed Graphs</a> for more details. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#aa1cd1170a7b667692ad0549777c7e1f2">query\_graph\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a77fd961bc121320757340b18ae256129">query\_graph\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a77fd961bc121320757340b18ae256129">query\_graph\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#af9f4cf4858229ecd6fbb88d2e807a696">query\_graph\_limit</a>: When specified (>0), limits the number of query results. The size of the nodes table will be limited by the <a href="/content/api/cpp/namespacegpudb#af9f4cf4858229ecd6fbb88d2e807a696">limit</a> value. The default value is '0'. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a56c6520637ee893244d5c5d7a9d053e3">query\_graph\_output\_wkt\_path</a>: If true then concatenated wkt line segments will be added as the WKT column of the adjacency table. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#aa1cd1170a7b667692ad0549777c7e1f2">query\_graph\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a77fd961bc121320757340b18ae256129">query\_graph\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a77fd961bc121320757340b18ae256129">query\_graph\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a152343177fe41887b1f2c8f7ea51a686">query\_graph\_and\_labels</a>: If set to <a href="/content/api/cpp/namespacegpudb#aa1cd1170a7b667692ad0549777c7e1f2">true</a>, the result of the query has entities that satisfy all of the target labels, instead of any. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#aa1cd1170a7b667692ad0549777c7e1f2">query\_graph\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a77fd961bc121320757340b18ae256129">query\_graph\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a77fd961bc121320757340b18ae256129">query\_graph\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#ac82b78326aa02649f70af36c7f378b6a">query\_graph\_server\_id</a>: Indicates which graph server(s) to send the request to. Default is to send to the server, amongst those containing the corresponding graph, that has the most computational bandwidth. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a0eb7ba53622df90830d072d4ada6b84b">query\_graph\_output\_charn\_length</a>: When specified (>0 and \<=256), limits the number of char length on the output tables for string based nodes. The default length is 64. The default value is '64'. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a57bf4d6470e8662acd69f93096a48dc1">query\_graph\_find\_common\_labels</a>: If set to true, for many-to-many queries or multi-level traversals, it lists the common labels between the source and target nodes and edge labels in each path. Otherwise (zero rings), it'll list all labels of the node(s) queried. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#aa1cd1170a7b667692ad0549777c7e1f2">query\_graph\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a77fd961bc121320757340b18ae256129">query\_graph\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a77fd961bc121320757340b18ae256129">query\_graph\_false</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1QueryGraphResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a32d2c3902b783544cd574005eb34d075">◆ </a></span>queryGraph() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1QueryGraphResponse">QueryGraphResponse</a> & gpudb::GPUdb::queryGraph </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>graphName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< std::string > &</td>
            <td><span><span>queries</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< std::string > &</td>
            <td><span><span>restrictions</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>adjacencyTable</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const int32\_t</td>
            <td><span><span>rings</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1QueryGraphResponse">QueryGraphResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Employs a topological query on a graph generated a-priori by <a href="#a025f78582e1d24c590888a3d29e19f36">createGraph</a> and returns a list of adjacent edge(s) or node(s), also known as an adjacency list, depending on what's been provided to the endpoint; providing edges will return nodes and providing nodes will return edges. </p>
        <p>To determine the node(s) or edge(s) adjacent to a value from a given column, provide a list of values to <span>queries</span>. This field can be populated with column values from any table as long as the type is supported by the given identifier. See <a href="/content/graph_solver/network_graph_solver/#query-identifiers">Query Identifiers</a> for more information.</p>
        <p>To return the adjacency list in the response, leave <span>adjacencyTable</span> empty.</p>
        <p>IMPORTANT: It's highly recommended that you review the <a href="/content/graph_solver/network_graph_solver/">Graphs and Solvers</a> concepts documentation, the <a href="/content/guides/graph_rest_guide/">Graph REST Tutorial</a>, and/or some <a href="/content/guides/tags/graph-query">/match/graph examples</a> before using this endpoint.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>graphName</td>
                <td>Name of the graph resource to query. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>queries</td>
                <td>Nodes or edges to be queried specified using <a href="/content/graph_solver/network_graph_solver/#query-identifiers">query identifiers</a>. Identifiers can be used with existing column names, e.g., 'table.column AS QUERY\_NODE\_ID', raw values, e.g., '0, 2 AS QUERY\_NODE\_ID', or expressions, e.g., 'ST\_MAKEPOINT(table.x, table.y) AS QUERY\_NODE\_WKTPOINT'. Multiple values can be provided as long as the same identifier is used for all values. If using raw values in an identifier combination, the number of values specified must match across the combination. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>restrictions</td>
                <td>Additional restrictions to apply to the nodes/edges of an existing graph. Restrictions must be specified using <a href="/content/graph_solver/network_graph_solver/#identifiers">identifiers</a>; identifiers are grouped as <a href="/content/graph_solver/network_graph_solver/#id-combos">combinations</a>. Identifiers can be used with existing column names, e.g., 'table.column AS RESTRICTIONS\_EDGE\_ID', expressions, e.g., 'column/2 AS RESTRICTIONS\_VALUECOMPARED', or raw values, e.g., '0, 0, 0, 1 AS RESTRICTIONS\_ONOFFCOMPARED'. If using raw values in an identifier combination, the number of values specified must match across the combination. The default value is an empty vector. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>adjacencyTable</td>
                <td>Name of the table to store the resulting adjacencies, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a> and meeting <a href="/content/concepts/tables/#table-naming-criteria">table naming criteria</a>. If left blank, the query results are instead returned in the response. If the 'QUERY\_TARGET\_NODE\_LABEL' <a href="/content/graph_solver/network_graph_solver/#query-identifiers">query identifier</a> is used in <span>queries</span>, then two additional columns will be available: 'PATH\_ID' and 'RING\_ID'. See <a href="/content/graph_solver/network_graph_solver/#using-labels">Using Labels</a> for more information. The default value is ''. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>rings</td>
                <td>Sets the number of rings around the node to query for adjacency, with '1' being the edges directly attached to the queried node. Also known as number of hops. For example, if it is set to '2', the edge(s) directly attached to the queried node(s) will be returned; in addition, the edge(s) attached to the node(s) attached to the initial ring of edge(s) surrounding the queried node(s) will be returned. If the value is set to '0', any nodes that meet the criteria in <span>queries</span> and <span>restrictions</span> will be returned. This parameter is only applicable when querying nodes. The default value is 1. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Additional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a1dcd1e4aa5331b29f656ec75cfddc0b1">query\_graph\_force\_undirected</a>: If set to <a href="/content/api/cpp/namespacegpudb#aa1cd1170a7b667692ad0549777c7e1f2">true</a>, all inbound edges and outbound edges relative to the node will be returned. If set to <a href="/content/api/cpp/namespacegpudb#a77fd961bc121320757340b18ae256129">false</a>, only outbound edges relative to the node will be returned. This parameter is only applicable if the queried graph <span>graphName</span> is directed and when querying nodes. Consult <a href="/content/graph_solver/network_graph_solver/#directed-graphs">Directed Graphs</a> for more details. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#aa1cd1170a7b667692ad0549777c7e1f2">query\_graph\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a77fd961bc121320757340b18ae256129">query\_graph\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a77fd961bc121320757340b18ae256129">query\_graph\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#af9f4cf4858229ecd6fbb88d2e807a696">query\_graph\_limit</a>: When specified (>0), limits the number of query results. The size of the nodes table will be limited by the <a href="/content/api/cpp/namespacegpudb#af9f4cf4858229ecd6fbb88d2e807a696">limit</a> value. The default value is '0'. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a56c6520637ee893244d5c5d7a9d053e3">query\_graph\_output\_wkt\_path</a>: If true then concatenated wkt line segments will be added as the WKT column of the adjacency table. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#aa1cd1170a7b667692ad0549777c7e1f2">query\_graph\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a77fd961bc121320757340b18ae256129">query\_graph\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a77fd961bc121320757340b18ae256129">query\_graph\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a152343177fe41887b1f2c8f7ea51a686">query\_graph\_and\_labels</a>: If set to <a href="/content/api/cpp/namespacegpudb#aa1cd1170a7b667692ad0549777c7e1f2">true</a>, the result of the query has entities that satisfy all of the target labels, instead of any. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#aa1cd1170a7b667692ad0549777c7e1f2">query\_graph\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a77fd961bc121320757340b18ae256129">query\_graph\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a77fd961bc121320757340b18ae256129">query\_graph\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#ac82b78326aa02649f70af36c7f378b6a">query\_graph\_server\_id</a>: Indicates which graph server(s) to send the request to. Default is to send to the server, amongst those containing the corresponding graph, that has the most computational bandwidth. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a0eb7ba53622df90830d072d4ada6b84b">query\_graph\_output\_charn\_length</a>: When specified (>0 and \<=256), limits the number of char length on the output tables for string based nodes. The default length is 64. The default value is '64'. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a57bf4d6470e8662acd69f93096a48dc1">query\_graph\_find\_common\_labels</a>: If set to true, for many-to-many queries or multi-level traversals, it lists the common labels between the source and target nodes and edge labels in each path. Otherwise (zero rings), it'll list all labels of the node(s) queried. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#aa1cd1170a7b667692ad0549777c7e1f2">query\_graph\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a77fd961bc121320757340b18ae256129">query\_graph\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a77fd961bc121320757340b18ae256129">query\_graph\_false</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1QueryGraphResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1QueryGraphResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a04da24e61fee753e76aea8519c2ddb0c">◆ </a></span>removeHttpHeader()</h2>

    <div>
      <div>
        <table>
          <tr>
            <td>void gpudb::GPUdb::removeHttpHeader </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>header</span></span></td>
            <td>)</td>

            <td />
          </tr>
        </table>
      </div>

      <div>
        <p>Removes the given HTTP header from the map of additional HTTP headers to send to <a href="/content/api/cpp/classgpudb_1_1GPUdb">GPUdb</a> with each request. </p>
        <p>The user is not allowed to remove the following headers: </p>

        <ul>
          <li> Authorization </li>
          <li> Content-type </li>
          <li> Content-length </li>
          <li> ha\_sync\_mode </li>
        </ul>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>header</td>
                <td>the HTTP header</td>
              </tr>
            </table>
          </div>
        </div>

        <p>See <code><a href="#a9a05888d893e2ca984609b1a836ae5ba">getHttpHeaders()</a></code> See <code><a href="#a949cbb204510e4011233952fb00dc7f3">addHttpHeader(const std::string&, const std::string&)</a></code> </p>
      </div>
    </div>

    <h2><span><a href="#ae8df406ae2ed789bb8763e5a94201b23">◆ </a></span>repartitionGraph() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1RepartitionGraphResponse">RepartitionGraphResponse</a> gpudb::GPUdb::repartitionGraph </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1RepartitionGraphRequest">RepartitionGraphRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Rebalances an existing partitioned graph. </p>
        <p>IMPORTANT: It's highly recommended that you review the <a href="/content/graph_solver/network_graph_solver/">Graphs and Solvers</a> concepts documentation, the <a href="/content/guides/graph_rest_guide/">Graph REST Tutorial</a>, and/or some <a href="/content/guides/tags/graph">graph examples</a> before using this endpoint.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1RepartitionGraphRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1RepartitionGraphResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a61ad24358df749999a45542d99b11187">◆ </a></span>repartitionGraph() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1RepartitionGraphResponse">RepartitionGraphResponse</a> & gpudb::GPUdb::repartitionGraph </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1RepartitionGraphRequest">RepartitionGraphRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1RepartitionGraphResponse">RepartitionGraphResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Rebalances an existing partitioned graph. </p>
        <p>IMPORTANT: It's highly recommended that you review the <a href="/content/graph_solver/network_graph_solver/">Graphs and Solvers</a> concepts documentation, the <a href="/content/guides/graph_rest_guide/">Graph REST Tutorial</a>, and/or some <a href="/content/guides/tags/graph">graph examples</a> before using this endpoint.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1RepartitionGraphRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1RepartitionGraphResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1RepartitionGraphResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a441d50b3d621b8fa90607390992ee41b">◆ </a></span>repartitionGraph() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1RepartitionGraphResponse">RepartitionGraphResponse</a> gpudb::GPUdb::repartitionGraph </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>graphName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Rebalances an existing partitioned graph. </p>
        <p>IMPORTANT: It's highly recommended that you review the <a href="/content/graph_solver/network_graph_solver/">Graphs and Solvers</a> concepts documentation, the <a href="/content/guides/graph_rest_guide/">Graph REST Tutorial</a>, and/or some <a href="/content/guides/tags/graph">graph examples</a> before using this endpoint.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>graphName</td>
                <td>Name of the graph resource to rebalance. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#aeb144e2a37f2993c87c302a1459bd45b">repartition\_graph\_new\_graph\_name</a>: If a non-empty value is specified, the original graph will be kept (non-default behavior) and a new balanced graph will be created under this given name. When the value is empty (default), the generated 'balanced' graph will replace the original 'unbalanced' graph under the same graph name. The default value is ''. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a532030c53b8f7f20faa299e07ee5ea14">repartition\_graph\_source\_node</a>: The distributed shortest path solve is run from this source node to all the nodes in the graph to create balanced partitions using the iso-distance levels of the solution. The source node is selected by the rebalance algorithm automatically (default case when the value is an empty string). Otherwise, the user specified node is used as the source. The default value is ''. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1RepartitionGraphResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a042f7cdf1d63a33582b06e74b03fbb89">◆ </a></span>repartitionGraph() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1RepartitionGraphResponse">RepartitionGraphResponse</a> & gpudb::GPUdb::repartitionGraph </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>graphName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1RepartitionGraphResponse">RepartitionGraphResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Rebalances an existing partitioned graph. </p>
        <p>IMPORTANT: It's highly recommended that you review the <a href="/content/graph_solver/network_graph_solver/">Graphs and Solvers</a> concepts documentation, the <a href="/content/guides/graph_rest_guide/">Graph REST Tutorial</a>, and/or some <a href="/content/guides/tags/graph">graph examples</a> before using this endpoint.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>graphName</td>
                <td>Name of the graph resource to rebalance. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#aeb144e2a37f2993c87c302a1459bd45b">repartition\_graph\_new\_graph\_name</a>: If a non-empty value is specified, the original graph will be kept (non-default behavior) and a new balanced graph will be created under this given name. When the value is empty (default), the generated 'balanced' graph will replace the original 'unbalanced' graph under the same graph name. The default value is ''. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a532030c53b8f7f20faa299e07ee5ea14">repartition\_graph\_source\_node</a>: The distributed shortest path solve is run from this source node to all the nodes in the graph to create balanced partitions using the iso-distance levels of the solution. The source node is selected by the rebalance algorithm automatically (default case when the value is an empty string). Otherwise, the user specified node is used as the source. The default value is ''. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1RepartitionGraphResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1RepartitionGraphResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ab84fbe6421108eedd42326a8fa9b3555">◆ </a></span>restoreBackup() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1RestoreBackupResponse">RestoreBackupResponse</a> gpudb::GPUdb::restoreBackup </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1RestoreBackupRequest">RestoreBackupRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Restores database objects from a <a href="/content/admin/backup_restore/#database-backup">backup</a> accessible via the <a href="/content/concepts/data_sources/">data source</a> specified by <a href="/content/api/cpp/structgpudb_1_1RestoreBackupRequest#a0be8cf0e9ceb5b55867028aea9500254">datasourceName</a>. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1RestoreBackupRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1RestoreBackupResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a8beb2661d0dbc7ac6f449c13531673ab">◆ </a></span>restoreBackup() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1RestoreBackupResponse">RestoreBackupResponse</a> & gpudb::GPUdb::restoreBackup </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1RestoreBackupRequest">RestoreBackupRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1RestoreBackupResponse">RestoreBackupResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Restores database objects from a <a href="/content/admin/backup_restore/#database-backup">backup</a> accessible via the <a href="/content/concepts/data_sources/">data source</a> specified by <a href="/content/api/cpp/structgpudb_1_1RestoreBackupRequest#a0be8cf0e9ceb5b55867028aea9500254">datasourceName</a>. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1RestoreBackupRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1RestoreBackupResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1RestoreBackupResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#af9ffdf8b1766b6d85e3c436e616efc39">◆ </a></span>restoreBackup() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1RestoreBackupResponse">RestoreBackupResponse</a> gpudb::GPUdb::restoreBackup </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>backupName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>restoreObjectsMap</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>datasourceName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Restores database objects from a <a href="/content/admin/backup_restore/#database-backup">backup</a> accessible via the <a href="/content/concepts/data_sources/">data source</a> specified by <span>datasourceName</span>. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>backupName</td>
                <td>Name of the backup to restore from, which must refer to an existing backup. The default value is ''. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>restoreObjectsMap</td>

                <td>
                  Map of database objects to be restored from the backup.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a761f0694dd53485350641870e7503978">restore\_backup\_all</a>: All object types and data contained in the given <a href="/content/concepts/schemas/">schema(s)</a>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a3e4922e1cde5e814ab38d2ce3c05c56c">restore\_backup\_catalog</a>: Data Lake catalog that is external to the database. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aeb94f10c081503f1a11efc235c1c09fe">restore\_backup\_context</a>: <a href="/content/sql-gpt/concepts/#sql-gpt-context">Context(s)</a>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a440dc021250541eabeaa434b07ac5f39">restore\_backup\_credential</a>: <a href="/content/concepts/credentials/">Credential(s)</a>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a2ab2fe375fad40885ece68113fe05f95">restore\_backup\_datasink</a>: <a href="/content/concepts/data_sinks/">Data sink(s)</a>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a1e551df5a9ea62c41617dced89cf77f3">restore\_backup\_datasource</a>: <a href="/content/concepts/data_sources/">Data source(s)</a>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aab964cd2cc2cc3233691d145004ba68f">restore\_backup\_directory</a>: KiFS <a href="/content/tools/kifs/">File directory(ies)</a>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aa082f3a571fa3d18412185fccec05f4c">restore\_backup\_function\_environment</a>: <a href="/content/udf/python/writing/#udf-python-func-env">Python UDF function environment(s)</a>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a5e8133694bab8ce04524e3bac3d9d31f">restore\_backup\_graph</a>: <a href="/content/graph_solver/network_graph_solver/">Graph</a> definition(s). Source table(s), if applicable, are required in order to restore graph objects. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#af95bcae7e864c27e87f0171045dcd1af">restore\_backup\_monitor</a>: <a href="/content/concepts/table_monitors/">Table monitor(s)</a> / <a href="/content/sql/ddl/#create-stream">SQL stream(s)</a>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ad06fd060701b87dcc84353298a9a5252">restore\_backup\_resource\_group</a>: <a href="/content/rm/concepts/#resource-groups">Resource group(s)</a>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#af52b0f8e4634925705a7c01660bddcb9">restore\_backup\_role</a>: <a href="/content/security/sec_concepts/#roles">Role(s)</a>, role members (roles or users, recursively), and associated permissions. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#af7a14671d5a092a7409aeb4941b702d8">restore\_backup\_stored\_procedure</a>: <a href="/content/sql/procedure/">SQL procedure(s)</a>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a856f4364db2f935158ffa05c0c65ecd9">restore\_backup\_table</a>: <a href="/content/concepts/tables/">Table(s)</a> and <a href="/content/sql/ddl/#create-view">SQL view(s)</a>. Tables with subscriptions will by default be restored in the state they were in at the time of the snapshot. See <a href="/content/api/cpp/namespacegpudb#aba16dee35440b6cf5ea142ff4b34b5fa">restore\_subscriptions</a> for options to override the default behavior. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ab1ac25ebb11e7f13ee4cc43a645e4df8">restore\_backup\_user</a>: <a href="/content/security/sec_concepts/#security-concepts-users">User(s)</a> (internal and external) and associated permissions. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aeb85a55c026b70e6edc509205394393d">restore\_backup\_user\_defined\_function</a>: <a href="/content/udf_overview">UDF(s)</a>. </li>
                  </ul>
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>datasourceName</td>
                <td>Data source through which the backup will be restored. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a9cd9d752c0fe2f4ad0335a6702ad1804">restore\_backup\_backup\_id</a>: ID of the snapshot to restore. Leave empty to restore the most recent snapshot in the backup. The default value is ''. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ad5a4723458018b9c754044482562ea81">restore\_backup\_checksum</a>: Whether or not to verify checksums for backup files when restoring. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a850b8e689559a5b5a94a4f3cd66c511f">restore\_backup\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a73d3b04d3a3fd88ddaaa7f951c8df47a">restore\_backup\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a73d3b04d3a3fd88ddaaa7f951c8df47a">restore\_backup\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ab918c03618f79e5ddb0708615157eae0">restore\_backup\_create\_schema\_if\_not\_exist</a>: Behavior to apply when the schema containing any database object to restore does not already exist. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a850b8e689559a5b5a94a4f3cd66c511f">restore\_backup\_true</a>: If the schema containing any restored object does not exist, create it automatically. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a73d3b04d3a3fd88ddaaa7f951c8df47a">restore\_backup\_false</a>: If the schema containing any restored object does not exist, return an error. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a850b8e689559a5b5a94a4f3cd66c511f">restore\_backup\_true</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a4e590e0c73ea4f5a96854fdfeafc0f83">restore\_backup\_ddl\_only</a>: Behavior to apply when restoring tables. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a850b8e689559a5b5a94a4f3cd66c511f">restore\_backup\_true</a>: Restore table DDL, but do not restore data. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a73d3b04d3a3fd88ddaaa7f951c8df47a">restore\_backup\_false</a>: Restore tables and their data. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a73d3b04d3a3fd88ddaaa7f951c8df47a">restore\_backup\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#aefb3eb8f28a1573ed52d8a20c8c14ae7">restore\_backup\_dry\_run</a>: Whether or not to perform a dry run of the restoration operation. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a850b8e689559a5b5a94a4f3cd66c511f">restore\_backup\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a73d3b04d3a3fd88ddaaa7f951c8df47a">restore\_backup\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a73d3b04d3a3fd88ddaaa7f951c8df47a">restore\_backup\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#aba16dee35440b6cf5ea142ff4b34b5fa">restore\_backup\_restore\_subscriptions</a>: Behavior to apply when restoring datasource subscriptions on tables. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a0b5aaed3f6031df7cdee3bdc1549283d">restore\_backup\_resume</a>: Resume subscriptions that were active when the backup was made. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a88eb1bdd219967f23ee15b7cf923a15a">restore\_backup\_pause</a>: Pause subscriptions that were active when the backup was made. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a7f4f3d6b0850a28620b31ebfdf82f354">restore\_backup\_cancel</a>: Cancel active subscriptions. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a0b5aaed3f6031df7cdee3bdc1549283d">restore\_backup\_resume</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a927c43060046d9d01d72f42d35f2448b">restore\_backup\_reingest</a>: Behavior to apply when restoring table data. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a850b8e689559a5b5a94a4f3cd66c511f">restore\_backup\_true</a>: Restore table data by re-ingesting it. This is the default behavior if the cluster topology differs from that of the contained backup. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a73d3b04d3a3fd88ddaaa7f951c8df47a">restore\_backup\_false</a>: Restore the persisted data files directly. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a73d3b04d3a3fd88ddaaa7f951c8df47a">restore\_backup\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a9bc0c34e8902369ebc9833c7bc8abaa9">restore\_backup\_renamed\_objects\_schema</a>: If the <a href="/content/api/cpp/namespacegpudb#a49117f7f997cda7471884205dfe804c3">restore\_policy</a> is <a href="/content/api/cpp/namespacegpudb#a933b478d719f63dab82a9c70d18d62fa">rename</a>, use this schema for relocated existing objects instead of the default generated one. The default value is ''. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a6f77ce067b10e7a1a813a94d62a9cec6">restore\_backup\_restore\_all\_permissions</a>: Whether or not all permissions of restored principals should be restored or scoped to the restored objects. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a850b8e689559a5b5a94a4f3cd66c511f">restore\_backup\_true</a>: Restore all permissions. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a73d3b04d3a3fd88ddaaa7f951c8df47a">restore\_backup\_false</a>: Restore only permissions on restored objects. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a73d3b04d3a3fd88ddaaa7f951c8df47a">restore\_backup\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a49117f7f997cda7471884205dfe804c3">restore\_backup\_restore\_policy</a>: Behavior to apply when any database object to restore already exists. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a36a66147f2c0be703afc00e394895063">restore\_backup\_none</a>: If an object to be restored already exists with the same name, abort and return error. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a085b2e580493109501e601724c7435cb">restore\_backup\_replace</a>: If an object to be restored already exists with the same name, replace it with the backup version. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a933b478d719f63dab82a9c70d18d62fa">restore\_backup\_rename</a>: If an object to be restored already exists with the same name, move that existing one to the schema specified by <a href="/content/api/cpp/namespacegpudb#a9bc0c34e8902369ebc9833c7bc8abaa9">renamed\_objects\_schema</a>. This policy does not apply to non-schema objects. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a36a66147f2c0be703afc00e394895063">restore\_backup\_none</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#afbd644d9d1e344060b7c1bba31c9ca3f">restore\_backup\_target\_schema\_map</a>: Restore schema-based objects to alternate schema. Value is a comma delimitted list of key:value pairs mapping the original (source) schema name as it exists in the backup to a target (destination) schema namespace: "src: dst \[, src: dst \[, ...]]". Note that schema names are case sensitive and must adhere to the database schema <a href="/content/concepts/schemas/">naming criteria</a>. The default value is ''. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1RestoreBackupResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a621e2c752c1a5a1efdd550ac44bb159d">◆ </a></span>restoreBackup() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1RestoreBackupResponse">RestoreBackupResponse</a> & gpudb::GPUdb::restoreBackup </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>backupName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>restoreObjectsMap</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>datasourceName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1RestoreBackupResponse">RestoreBackupResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Restores database objects from a <a href="/content/admin/backup_restore/#database-backup">backup</a> accessible via the <a href="/content/concepts/data_sources/">data source</a> specified by <span>datasourceName</span>. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>backupName</td>
                <td>Name of the backup to restore from, which must refer to an existing backup. The default value is ''. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>restoreObjectsMap</td>

                <td>
                  Map of database objects to be restored from the backup.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a761f0694dd53485350641870e7503978">restore\_backup\_all</a>: All object types and data contained in the given <a href="/content/concepts/schemas/">schema(s)</a>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a3e4922e1cde5e814ab38d2ce3c05c56c">restore\_backup\_catalog</a>: Data Lake catalog that is external to the database. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aeb94f10c081503f1a11efc235c1c09fe">restore\_backup\_context</a>: <a href="/content/sql-gpt/concepts/#sql-gpt-context">Context(s)</a>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a440dc021250541eabeaa434b07ac5f39">restore\_backup\_credential</a>: <a href="/content/concepts/credentials/">Credential(s)</a>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a2ab2fe375fad40885ece68113fe05f95">restore\_backup\_datasink</a>: <a href="/content/concepts/data_sinks/">Data sink(s)</a>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a1e551df5a9ea62c41617dced89cf77f3">restore\_backup\_datasource</a>: <a href="/content/concepts/data_sources/">Data source(s)</a>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aab964cd2cc2cc3233691d145004ba68f">restore\_backup\_directory</a>: KiFS <a href="/content/tools/kifs/">File directory(ies)</a>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aa082f3a571fa3d18412185fccec05f4c">restore\_backup\_function\_environment</a>: <a href="/content/udf/python/writing/#udf-python-func-env">Python UDF function environment(s)</a>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a5e8133694bab8ce04524e3bac3d9d31f">restore\_backup\_graph</a>: <a href="/content/graph_solver/network_graph_solver/">Graph</a> definition(s). Source table(s), if applicable, are required in order to restore graph objects. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#af95bcae7e864c27e87f0171045dcd1af">restore\_backup\_monitor</a>: <a href="/content/concepts/table_monitors/">Table monitor(s)</a> / <a href="/content/sql/ddl/#create-stream">SQL stream(s)</a>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ad06fd060701b87dcc84353298a9a5252">restore\_backup\_resource\_group</a>: <a href="/content/rm/concepts/#resource-groups">Resource group(s)</a>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#af52b0f8e4634925705a7c01660bddcb9">restore\_backup\_role</a>: <a href="/content/security/sec_concepts/#roles">Role(s)</a>, role members (roles or users, recursively), and associated permissions. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#af7a14671d5a092a7409aeb4941b702d8">restore\_backup\_stored\_procedure</a>: <a href="/content/sql/procedure/">SQL procedure(s)</a>. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a856f4364db2f935158ffa05c0c65ecd9">restore\_backup\_table</a>: <a href="/content/concepts/tables/">Table(s)</a> and <a href="/content/sql/ddl/#create-view">SQL view(s)</a>. Tables with subscriptions will by default be restored in the state they were in at the time of the snapshot. See <a href="/content/api/cpp/namespacegpudb#aba16dee35440b6cf5ea142ff4b34b5fa">restore\_subscriptions</a> for options to override the default behavior. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ab1ac25ebb11e7f13ee4cc43a645e4df8">restore\_backup\_user</a>: <a href="/content/security/sec_concepts/#security-concepts-users">User(s)</a> (internal and external) and associated permissions. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aeb85a55c026b70e6edc509205394393d">restore\_backup\_user\_defined\_function</a>: <a href="/content/udf_overview">UDF(s)</a>. </li>
                  </ul>
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>datasourceName</td>
                <td>Data source through which the backup will be restored. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a9cd9d752c0fe2f4ad0335a6702ad1804">restore\_backup\_backup\_id</a>: ID of the snapshot to restore. Leave empty to restore the most recent snapshot in the backup. The default value is ''. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ad5a4723458018b9c754044482562ea81">restore\_backup\_checksum</a>: Whether or not to verify checksums for backup files when restoring. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a850b8e689559a5b5a94a4f3cd66c511f">restore\_backup\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a73d3b04d3a3fd88ddaaa7f951c8df47a">restore\_backup\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a73d3b04d3a3fd88ddaaa7f951c8df47a">restore\_backup\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ab918c03618f79e5ddb0708615157eae0">restore\_backup\_create\_schema\_if\_not\_exist</a>: Behavior to apply when the schema containing any database object to restore does not already exist. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a850b8e689559a5b5a94a4f3cd66c511f">restore\_backup\_true</a>: If the schema containing any restored object does not exist, create it automatically. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a73d3b04d3a3fd88ddaaa7f951c8df47a">restore\_backup\_false</a>: If the schema containing any restored object does not exist, return an error. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a850b8e689559a5b5a94a4f3cd66c511f">restore\_backup\_true</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a4e590e0c73ea4f5a96854fdfeafc0f83">restore\_backup\_ddl\_only</a>: Behavior to apply when restoring tables. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a850b8e689559a5b5a94a4f3cd66c511f">restore\_backup\_true</a>: Restore table DDL, but do not restore data. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a73d3b04d3a3fd88ddaaa7f951c8df47a">restore\_backup\_false</a>: Restore tables and their data. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a73d3b04d3a3fd88ddaaa7f951c8df47a">restore\_backup\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#aefb3eb8f28a1573ed52d8a20c8c14ae7">restore\_backup\_dry\_run</a>: Whether or not to perform a dry run of the restoration operation. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a850b8e689559a5b5a94a4f3cd66c511f">restore\_backup\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a73d3b04d3a3fd88ddaaa7f951c8df47a">restore\_backup\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a73d3b04d3a3fd88ddaaa7f951c8df47a">restore\_backup\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#aba16dee35440b6cf5ea142ff4b34b5fa">restore\_backup\_restore\_subscriptions</a>: Behavior to apply when restoring datasource subscriptions on tables. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a0b5aaed3f6031df7cdee3bdc1549283d">restore\_backup\_resume</a>: Resume subscriptions that were active when the backup was made. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a88eb1bdd219967f23ee15b7cf923a15a">restore\_backup\_pause</a>: Pause subscriptions that were active when the backup was made. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a7f4f3d6b0850a28620b31ebfdf82f354">restore\_backup\_cancel</a>: Cancel active subscriptions. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a0b5aaed3f6031df7cdee3bdc1549283d">restore\_backup\_resume</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a927c43060046d9d01d72f42d35f2448b">restore\_backup\_reingest</a>: Behavior to apply when restoring table data. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a850b8e689559a5b5a94a4f3cd66c511f">restore\_backup\_true</a>: Restore table data by re-ingesting it. This is the default behavior if the cluster topology differs from that of the contained backup. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a73d3b04d3a3fd88ddaaa7f951c8df47a">restore\_backup\_false</a>: Restore the persisted data files directly. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a73d3b04d3a3fd88ddaaa7f951c8df47a">restore\_backup\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a9bc0c34e8902369ebc9833c7bc8abaa9">restore\_backup\_renamed\_objects\_schema</a>: If the <a href="/content/api/cpp/namespacegpudb#a49117f7f997cda7471884205dfe804c3">restore\_policy</a> is <a href="/content/api/cpp/namespacegpudb#a933b478d719f63dab82a9c70d18d62fa">rename</a>, use this schema for relocated existing objects instead of the default generated one. The default value is ''. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a6f77ce067b10e7a1a813a94d62a9cec6">restore\_backup\_restore\_all\_permissions</a>: Whether or not all permissions of restored principals should be restored or scoped to the restored objects. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a850b8e689559a5b5a94a4f3cd66c511f">restore\_backup\_true</a>: Restore all permissions. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a73d3b04d3a3fd88ddaaa7f951c8df47a">restore\_backup\_false</a>: Restore only permissions on restored objects. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a73d3b04d3a3fd88ddaaa7f951c8df47a">restore\_backup\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a49117f7f997cda7471884205dfe804c3">restore\_backup\_restore\_policy</a>: Behavior to apply when any database object to restore already exists. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a36a66147f2c0be703afc00e394895063">restore\_backup\_none</a>: If an object to be restored already exists with the same name, abort and return error. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a085b2e580493109501e601724c7435cb">restore\_backup\_replace</a>: If an object to be restored already exists with the same name, replace it with the backup version. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a933b478d719f63dab82a9c70d18d62fa">restore\_backup\_rename</a>: If an object to be restored already exists with the same name, move that existing one to the schema specified by <a href="/content/api/cpp/namespacegpudb#a9bc0c34e8902369ebc9833c7bc8abaa9">renamed\_objects\_schema</a>. This policy does not apply to non-schema objects. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a36a66147f2c0be703afc00e394895063">restore\_backup\_none</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#afbd644d9d1e344060b7c1bba31c9ca3f">restore\_backup\_target\_schema\_map</a>: Restore schema-based objects to alternate schema. Value is a comma delimitted list of key:value pairs mapping the original (source) schema name as it exists in the backup to a target (destination) schema namespace: "src: dst \[, src: dst \[, ...]]". Note that schema names are case sensitive and must adhere to the database schema <a href="/content/concepts/schemas/">naming criteria</a>. The default value is ''. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1RestoreBackupResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1RestoreBackupResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a23100aed98b997cef0abdae25f01a1d3">◆ </a></span>revokePermission() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1RevokePermissionResponse">RevokePermissionResponse</a> gpudb::GPUdb::revokePermission </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1RevokePermissionRequest">RevokePermissionRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Revoke user or role the specified permission on the specified object. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1RevokePermissionRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1RevokePermissionResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a65316a4b8982cbe6423eb35ac39afb0e">◆ </a></span>revokePermission() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1RevokePermissionResponse">RevokePermissionResponse</a> & gpudb::GPUdb::revokePermission </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1RevokePermissionRequest">RevokePermissionRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1RevokePermissionResponse">RevokePermissionResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Revoke user or role the specified permission on the specified object. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1RevokePermissionRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1RevokePermissionResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1RevokePermissionResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a55a1f3f0e5c95eb77a49e34b51ac9f09">◆ </a></span>revokePermission() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1RevokePermissionResponse">RevokePermissionResponse</a> gpudb::GPUdb::revokePermission </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>principal</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>object</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>objectType</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>permission</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Revoke user or role the specified permission on the specified object. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>principal</td>
                <td>Name of the user or role for which the permission is being revoked. Must be an existing user or role. The default value is ''. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>object</td>
                <td>Name of object permission is being revoked from. It is recommended to use a fully-qualified name when possible. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>objectType</td>

                <td>
                  The type of object being revoked. Supported values:

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#ad4e45ca079adf15abdcf627dceaa1482">revoke\_permission\_catalog</a>: Catalog </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ab80a7f4b293b9f50f759ba0814ffc3da">revoke\_permission\_context</a>: Context </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ada1af5d73e7a1817d738d79cedceff25">revoke\_permission\_credential</a>: Credential </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a494635f51aef0d5bd013d9ccd0af2fcf">revoke\_permission\_datasink</a>: Data Sink </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a1a27d3af496c077023ec0df7829b1649">revoke\_permission\_datasource</a>: Data Source </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a086c5d7ace98c0fbf591b8683c2276f6">revoke\_permission\_directory</a>: KIFS File Directory </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a2eb7ff900598349e986a006701671ed7">revoke\_permission\_graph</a>: A Graph object </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a1fd729475c3feeccce4cd124cb24d470">revoke\_permission\_proc</a>: UDF Procedure </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a71dd279f9ba5e74985525bedb5abe5ab">revoke\_permission\_schema</a>: Schema </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#af979263103df1c770223bc691dc32edc">revoke\_permission\_sql\_proc</a>: SQL Procedure </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#af8805c73c3ecc243745d559f1324721e">revoke\_permission\_system</a>: System-level access </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ac70e48a0f11c6c04eecffd8bd9f60ca6">revoke\_permission\_table</a>: Database Table </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a9b388b775acc1ecad0e3a535ac33627f">revoke\_permission\_table\_monitor</a>: Table monitor </li>
                  </ul>
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>permission</td>

                <td>
                  Permission being revoked. Supported values:

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a82ef2e083ee019762f7c051720702a26">revoke\_permission\_admin</a>: Full read/write and administrative access on the object. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aab19fcb4b6760af544d14b69b5ddd253">revoke\_permission\_connect</a>: Connect access on the given data source or data sink. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a1bbbf6acaab18aea438223f9186fd69d">revoke\_permission\_create</a>: Ability to create new objects of this type. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ac4fd64f4c6d7457e46482684f47e8b01">revoke\_permission\_delete</a>: Delete rows from tables. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aead27275cfd384ac4d4f7aaa37cb59f9">revoke\_permission\_execute</a>: Ability to Execute the Procedure object. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ab5afb76d55be05289302b2fdd07ddee5">revoke\_permission\_insert</a>: Insert access to tables. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a0ebf72f7a60ca5d613f01899d427a71c">revoke\_permission\_monitor</a>: Monitor logs and statistics. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a096f6d8d429cfd1164326fb5006e5f11">revoke\_permission\_read</a>: Ability to read, list and use the object. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a63931c6219107635d83d103dcef04eaf">revoke\_permission\_send\_alert</a>: Ability to send system alerts. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#af96bb726a1bfcc045320a766b4f5868c">revoke\_permission\_update</a>: Update access to the table. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a3fdbec59ac637f87dd0412b87b92c95a">revoke\_permission\_user\_admin</a>: Access to administer users and roles that do not have system\_admin permission. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a51bb9a1f9011bf96d6eb3fb098268c31">revoke\_permission\_write</a>: Access to write, change and delete objects. </li>
                  </ul>
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#abc94821c94421595437443aec30d0d38">revoke\_permission\_columns</a>: Revoke table security from these columns, comma-separated. The default value is ''. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1RevokePermissionResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a058430d085cdaf8a5f29451bd31a0daf">◆ </a></span>revokePermission() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1RevokePermissionResponse">RevokePermissionResponse</a> & gpudb::GPUdb::revokePermission </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>principal</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>object</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>objectType</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>permission</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1RevokePermissionResponse">RevokePermissionResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Revoke user or role the specified permission on the specified object. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>principal</td>
                <td>Name of the user or role for which the permission is being revoked. Must be an existing user or role. The default value is ''. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>object</td>
                <td>Name of object permission is being revoked from. It is recommended to use a fully-qualified name when possible. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>objectType</td>

                <td>
                  The type of object being revoked. Supported values:

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#ad4e45ca079adf15abdcf627dceaa1482">revoke\_permission\_catalog</a>: Catalog </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ab80a7f4b293b9f50f759ba0814ffc3da">revoke\_permission\_context</a>: Context </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ada1af5d73e7a1817d738d79cedceff25">revoke\_permission\_credential</a>: Credential </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a494635f51aef0d5bd013d9ccd0af2fcf">revoke\_permission\_datasink</a>: Data Sink </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a1a27d3af496c077023ec0df7829b1649">revoke\_permission\_datasource</a>: Data Source </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a086c5d7ace98c0fbf591b8683c2276f6">revoke\_permission\_directory</a>: KIFS File Directory </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a2eb7ff900598349e986a006701671ed7">revoke\_permission\_graph</a>: A Graph object </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a1fd729475c3feeccce4cd124cb24d470">revoke\_permission\_proc</a>: UDF Procedure </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a71dd279f9ba5e74985525bedb5abe5ab">revoke\_permission\_schema</a>: Schema </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#af979263103df1c770223bc691dc32edc">revoke\_permission\_sql\_proc</a>: SQL Procedure </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#af8805c73c3ecc243745d559f1324721e">revoke\_permission\_system</a>: System-level access </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ac70e48a0f11c6c04eecffd8bd9f60ca6">revoke\_permission\_table</a>: Database Table </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a9b388b775acc1ecad0e3a535ac33627f">revoke\_permission\_table\_monitor</a>: Table monitor </li>
                  </ul>
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>permission</td>

                <td>
                  Permission being revoked. Supported values:

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a82ef2e083ee019762f7c051720702a26">revoke\_permission\_admin</a>: Full read/write and administrative access on the object. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aab19fcb4b6760af544d14b69b5ddd253">revoke\_permission\_connect</a>: Connect access on the given data source or data sink. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a1bbbf6acaab18aea438223f9186fd69d">revoke\_permission\_create</a>: Ability to create new objects of this type. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ac4fd64f4c6d7457e46482684f47e8b01">revoke\_permission\_delete</a>: Delete rows from tables. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aead27275cfd384ac4d4f7aaa37cb59f9">revoke\_permission\_execute</a>: Ability to Execute the Procedure object. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ab5afb76d55be05289302b2fdd07ddee5">revoke\_permission\_insert</a>: Insert access to tables. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a0ebf72f7a60ca5d613f01899d427a71c">revoke\_permission\_monitor</a>: Monitor logs and statistics. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a096f6d8d429cfd1164326fb5006e5f11">revoke\_permission\_read</a>: Ability to read, list and use the object. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a63931c6219107635d83d103dcef04eaf">revoke\_permission\_send\_alert</a>: Ability to send system alerts. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#af96bb726a1bfcc045320a766b4f5868c">revoke\_permission\_update</a>: Update access to the table. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a3fdbec59ac637f87dd0412b87b92c95a">revoke\_permission\_user\_admin</a>: Access to administer users and roles that do not have system\_admin permission. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a51bb9a1f9011bf96d6eb3fb098268c31">revoke\_permission\_write</a>: Access to write, change and delete objects. </li>
                  </ul>
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#abc94821c94421595437443aec30d0d38">revoke\_permission\_columns</a>: Revoke table security from these columns, comma-separated. The default value is ''. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1RevokePermissionResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1RevokePermissionResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#aa30344583dbc85d2c410b4b0051afad8">◆ </a></span>revokePermissionCredential() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1RevokePermissionCredentialResponse">RevokePermissionCredentialResponse</a> gpudb::GPUdb::revokePermissionCredential </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1RevokePermissionCredentialRequest">RevokePermissionCredentialRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Revokes a <a href="/content/security/sec_concepts/#security-concepts-permissions-credential">credential-level permission</a> from a user or role. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1RevokePermissionCredentialRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1RevokePermissionCredentialResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#af8a7c2d2e9fc43a3e5c340dab974c808">◆ </a></span>revokePermissionCredential() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1RevokePermissionCredentialResponse">RevokePermissionCredentialResponse</a> & gpudb::GPUdb::revokePermissionCredential </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1RevokePermissionCredentialRequest">RevokePermissionCredentialRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1RevokePermissionCredentialResponse">RevokePermissionCredentialResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Revokes a <a href="/content/security/sec_concepts/#security-concepts-permissions-credential">credential-level permission</a> from a user or role. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1RevokePermissionCredentialRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1RevokePermissionCredentialResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1RevokePermissionCredentialResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#afd28eb5a078e910ab075f8883527cd4d">◆ </a></span>revokePermissionCredential() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1RevokePermissionCredentialResponse">RevokePermissionCredentialResponse</a> gpudb::GPUdb::revokePermissionCredential </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>permission</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>credentialName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Revokes a <a href="/content/security/sec_concepts/#security-concepts-permissions-credential">credential-level permission</a> from a user or role. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>name</td>
                <td>Name of the user or role from which the permission will be revoked. Must be an existing user or role. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>permission</td>

                <td>
                  Permission to revoke from the user or role. Supported values:

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#aa1b748437ba3a3ee793e3c4922f7f779">revoke\_permission\_credential\_credential\_admin</a>: Full read/write and administrative access on the credential. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aaaf88325b7aaa2955a7c6d633ee7bd32">revoke\_permission\_credential\_credential\_read</a>: Ability to read and use the credential. </li>
                  </ul>
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>credentialName</td>
                <td>Name of the credential on which the permission will be revoked. Must be an existing credential, or an empty string to revoke access on all credentials. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1RevokePermissionCredentialResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a06a757e504e5c3b3c454d92e794555ab">◆ </a></span>revokePermissionCredential() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1RevokePermissionCredentialResponse">RevokePermissionCredentialResponse</a> & gpudb::GPUdb::revokePermissionCredential </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>permission</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>credentialName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1RevokePermissionCredentialResponse">RevokePermissionCredentialResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Revokes a <a href="/content/security/sec_concepts/#security-concepts-permissions-credential">credential-level permission</a> from a user or role. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>name</td>
                <td>Name of the user or role from which the permission will be revoked. Must be an existing user or role. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>permission</td>

                <td>
                  Permission to revoke from the user or role. Supported values:

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#aa1b748437ba3a3ee793e3c4922f7f779">revoke\_permission\_credential\_credential\_admin</a>: Full read/write and administrative access on the credential. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aaaf88325b7aaa2955a7c6d633ee7bd32">revoke\_permission\_credential\_credential\_read</a>: Ability to read and use the credential. </li>
                  </ul>
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>credentialName</td>
                <td>Name of the credential on which the permission will be revoked. Must be an existing credential, or an empty string to revoke access on all credentials. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1RevokePermissionCredentialResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1RevokePermissionCredentialResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a3d3fa1335f761ab3e7474e419aa3b6ee">◆ </a></span>revokePermissionDatasource() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1RevokePermissionDatasourceResponse">RevokePermissionDatasourceResponse</a> gpudb::GPUdb::revokePermissionDatasource </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1RevokePermissionDatasourceRequest">RevokePermissionDatasourceRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Revokes a <a href="/content/concepts/data_sources/">data source</a> permission from a user or role. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1RevokePermissionDatasourceRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1RevokePermissionDatasourceResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#aca4dc8e22f74db9c59583d273bf95767">◆ </a></span>revokePermissionDatasource() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1RevokePermissionDatasourceResponse">RevokePermissionDatasourceResponse</a> & gpudb::GPUdb::revokePermissionDatasource </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1RevokePermissionDatasourceRequest">RevokePermissionDatasourceRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1RevokePermissionDatasourceResponse">RevokePermissionDatasourceResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Revokes a <a href="/content/concepts/data_sources/">data source</a> permission from a user or role. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1RevokePermissionDatasourceRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1RevokePermissionDatasourceResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1RevokePermissionDatasourceResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#abeb672e878e60f305a3ad973ea088914">◆ </a></span>revokePermissionDatasource() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1RevokePermissionDatasourceResponse">RevokePermissionDatasourceResponse</a> gpudb::GPUdb::revokePermissionDatasource </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>permission</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>datasourceName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Revokes a <a href="/content/concepts/data_sources/">data source</a> permission from a user or role. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>name</td>
                <td>Name of the user or role from which the permission will be revoked. Must be an existing user or role. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>permission</td>

                <td>
                  Permission to revoke from the user or role. Supported values:

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#af848bb407bd6b721f641a8422de01397">revoke\_permission\_datasource\_admin</a>: Admin access on the given data source. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a041176abe7689ef0f15de0e945ec05ab">revoke\_permission\_datasource\_connect</a>: Connect access on the given data source. </li>
                  </ul>
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>datasourceName</td>
                <td>Name of the data source on which the permission will be revoked. Must be an existing data source, or an empty string to revoke permission from all data sources. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1RevokePermissionDatasourceResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a03c35a898ab1a5b1a89f26c9e6422d16">◆ </a></span>revokePermissionDatasource() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1RevokePermissionDatasourceResponse">RevokePermissionDatasourceResponse</a> & gpudb::GPUdb::revokePermissionDatasource </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>permission</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>datasourceName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1RevokePermissionDatasourceResponse">RevokePermissionDatasourceResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Revokes a <a href="/content/concepts/data_sources/">data source</a> permission from a user or role. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>name</td>
                <td>Name of the user or role from which the permission will be revoked. Must be an existing user or role. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>permission</td>

                <td>
                  Permission to revoke from the user or role. Supported values:

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#af848bb407bd6b721f641a8422de01397">revoke\_permission\_datasource\_admin</a>: Admin access on the given data source. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a041176abe7689ef0f15de0e945ec05ab">revoke\_permission\_datasource\_connect</a>: Connect access on the given data source. </li>
                  </ul>
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>datasourceName</td>
                <td>Name of the data source on which the permission will be revoked. Must be an existing data source, or an empty string to revoke permission from all data sources. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1RevokePermissionDatasourceResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1RevokePermissionDatasourceResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a5f793acdd5d6c5214db0c5e0aef29465">◆ </a></span>revokePermissionDirectory() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1RevokePermissionDirectoryResponse">RevokePermissionDirectoryResponse</a> gpudb::GPUdb::revokePermissionDirectory </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1RevokePermissionDirectoryRequest">RevokePermissionDirectoryRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Revokes a <a href="/content/tools/kifs/">KiFS</a> directory-level permission from a user or role. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1RevokePermissionDirectoryRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1RevokePermissionDirectoryResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a0bee5fd68f799452bac2a6b33e90d9af">◆ </a></span>revokePermissionDirectory() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1RevokePermissionDirectoryResponse">RevokePermissionDirectoryResponse</a> & gpudb::GPUdb::revokePermissionDirectory </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1RevokePermissionDirectoryRequest">RevokePermissionDirectoryRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1RevokePermissionDirectoryResponse">RevokePermissionDirectoryResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Revokes a <a href="/content/tools/kifs/">KiFS</a> directory-level permission from a user or role. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1RevokePermissionDirectoryRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1RevokePermissionDirectoryResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1RevokePermissionDirectoryResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a19033c11cbb4b0e8e54d058b12c31dd3">◆ </a></span>revokePermissionDirectory() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1RevokePermissionDirectoryResponse">RevokePermissionDirectoryResponse</a> gpudb::GPUdb::revokePermissionDirectory </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>permission</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>directoryName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Revokes a <a href="/content/tools/kifs/">KiFS</a> directory-level permission from a user or role. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>name</td>
                <td>Name of the user or role from which the permission will be revoked. Must be an existing user or role. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>permission</td>

                <td>
                  Permission to revoke from the user or role. Supported values:

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a38b6d7ae52943783786f521e530c4353">revoke\_permission\_directory\_directory\_read</a>: For files in the directory, access to list files, download files, or use files in server side functions. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a4d279d88a4084ac3e31e904afe861b4f">revoke\_permission\_directory\_directory\_write</a>: Access to upload files to, or delete files from, the directory. A user or role with write access automatically has read access. </li>
                  </ul>
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>directoryName</td>
                <td>Name of the KiFS directory to which the permission revokes access. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1RevokePermissionDirectoryResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a06ecd2c905e1c4bab33ae360b6f070e1">◆ </a></span>revokePermissionDirectory() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1RevokePermissionDirectoryResponse">RevokePermissionDirectoryResponse</a> & gpudb::GPUdb::revokePermissionDirectory </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>permission</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>directoryName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1RevokePermissionDirectoryResponse">RevokePermissionDirectoryResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Revokes a <a href="/content/tools/kifs/">KiFS</a> directory-level permission from a user or role. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>name</td>
                <td>Name of the user or role from which the permission will be revoked. Must be an existing user or role. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>permission</td>

                <td>
                  Permission to revoke from the user or role. Supported values:

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a38b6d7ae52943783786f521e530c4353">revoke\_permission\_directory\_directory\_read</a>: For files in the directory, access to list files, download files, or use files in server side functions. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a4d279d88a4084ac3e31e904afe861b4f">revoke\_permission\_directory\_directory\_write</a>: Access to upload files to, or delete files from, the directory. A user or role with write access automatically has read access. </li>
                  </ul>
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>directoryName</td>
                <td>Name of the KiFS directory to which the permission revokes access. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1RevokePermissionDirectoryResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1RevokePermissionDirectoryResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ac9da5fcbd5d8573eeb08c5638e62f73e">◆ </a></span>revokePermissionProc() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1RevokePermissionProcResponse">RevokePermissionProcResponse</a> gpudb::GPUdb::revokePermissionProc </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1RevokePermissionProcRequest">RevokePermissionProcRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Revokes a proc-level permission from a user or role. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1RevokePermissionProcRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1RevokePermissionProcResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a668adb81005a2404b184ccd7dcafae74">◆ </a></span>revokePermissionProc() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1RevokePermissionProcResponse">RevokePermissionProcResponse</a> & gpudb::GPUdb::revokePermissionProc </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1RevokePermissionProcRequest">RevokePermissionProcRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1RevokePermissionProcResponse">RevokePermissionProcResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Revokes a proc-level permission from a user or role. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1RevokePermissionProcRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1RevokePermissionProcResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1RevokePermissionProcResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a5cc3a06a6c54954a679dc234d20da3a2">◆ </a></span>revokePermissionProc() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1RevokePermissionProcResponse">RevokePermissionProcResponse</a> gpudb::GPUdb::revokePermissionProc </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>permission</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>procName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Revokes a proc-level permission from a user or role. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>name</td>
                <td>Name of the user or role from which the permission will be revoked. Must be an existing user or role. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>permission</td>

                <td>
                  Permission to revoke from the user or role. Supported values:

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a201e705a6e20f6ca495dbb30c4ef7a4a">revoke\_permission\_proc\_proc\_admin</a>: Admin access to the proc. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a3f9bd6160fd4f71f139113674ed72e0e">revoke\_permission\_proc\_proc\_execute</a>: Execute access to the proc. </li>
                  </ul>
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>procName</td>
                <td>Name of the proc to which the permission grants access. Must be an existing proc, or an empty string if the permission grants access to all procs. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1RevokePermissionProcResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a21a9fb07c479f6bae03c991d16bd0253">◆ </a></span>revokePermissionProc() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1RevokePermissionProcResponse">RevokePermissionProcResponse</a> & gpudb::GPUdb::revokePermissionProc </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>permission</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>procName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1RevokePermissionProcResponse">RevokePermissionProcResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Revokes a proc-level permission from a user or role. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>name</td>
                <td>Name of the user or role from which the permission will be revoked. Must be an existing user or role. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>permission</td>

                <td>
                  Permission to revoke from the user or role. Supported values:

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a201e705a6e20f6ca495dbb30c4ef7a4a">revoke\_permission\_proc\_proc\_admin</a>: Admin access to the proc. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a3f9bd6160fd4f71f139113674ed72e0e">revoke\_permission\_proc\_proc\_execute</a>: Execute access to the proc. </li>
                  </ul>
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>procName</td>
                <td>Name of the proc to which the permission grants access. Must be an existing proc, or an empty string if the permission grants access to all procs. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1RevokePermissionProcResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1RevokePermissionProcResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ad20db437d84c13c2ba812cb71b95d13f">◆ </a></span>revokePermissionSystem() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1RevokePermissionSystemResponse">RevokePermissionSystemResponse</a> gpudb::GPUdb::revokePermissionSystem </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1RevokePermissionSystemRequest">RevokePermissionSystemRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Revokes a system-level permission from a user or role. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1RevokePermissionSystemRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1RevokePermissionSystemResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a3dae6f3c45ae998d48272c02fca55c05">◆ </a></span>revokePermissionSystem() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1RevokePermissionSystemResponse">RevokePermissionSystemResponse</a> & gpudb::GPUdb::revokePermissionSystem </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1RevokePermissionSystemRequest">RevokePermissionSystemRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1RevokePermissionSystemResponse">RevokePermissionSystemResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Revokes a system-level permission from a user or role. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1RevokePermissionSystemRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1RevokePermissionSystemResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1RevokePermissionSystemResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#aeb38f6305ef46f6bb65ef2cc3d190d3c">◆ </a></span>revokePermissionSystem() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1RevokePermissionSystemResponse">RevokePermissionSystemResponse</a> gpudb::GPUdb::revokePermissionSystem </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>permission</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Revokes a system-level permission from a user or role. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>name</td>
                <td>Name of the user or role from which the permission will be revoked. Must be an existing user or role. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>permission</td>

                <td>
                  Permission to revoke from the user or role. Supported values:

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a6c26c57bc9d1d3177ac35ad214367e40">revoke\_permission\_system\_system\_admin</a>: Full access to all data and system functions. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a4060deb8663e456adf9a92f7108b543c">revoke\_permission\_system\_system\_user\_admin</a>: Access to administer users and roles that do not have system\_admin permission. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ac87bb2600dcd647257d39cd0c79a5ffa">revoke\_permission\_system\_system\_write</a>: Read and write access to all tables. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a4be45d14256e45be090a03b8698d1d4b">revoke\_permission\_system\_system\_read</a>: Read-only access to all tables. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a5c7375b52d15ab38e540379dc7eb296c">revoke\_permission\_system\_system\_send\_alert</a>: Send system alerts. </li>
                  </ul>
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1RevokePermissionSystemResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a3c8f1d2213e21c184f7bfc88792cf89e">◆ </a></span>revokePermissionSystem() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1RevokePermissionSystemResponse">RevokePermissionSystemResponse</a> & gpudb::GPUdb::revokePermissionSystem </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>permission</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1RevokePermissionSystemResponse">RevokePermissionSystemResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Revokes a system-level permission from a user or role. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>name</td>
                <td>Name of the user or role from which the permission will be revoked. Must be an existing user or role. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>permission</td>

                <td>
                  Permission to revoke from the user or role. Supported values:

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a6c26c57bc9d1d3177ac35ad214367e40">revoke\_permission\_system\_system\_admin</a>: Full access to all data and system functions. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a4060deb8663e456adf9a92f7108b543c">revoke\_permission\_system\_system\_user\_admin</a>: Access to administer users and roles that do not have system\_admin permission. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ac87bb2600dcd647257d39cd0c79a5ffa">revoke\_permission\_system\_system\_write</a>: Read and write access to all tables. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a4be45d14256e45be090a03b8698d1d4b">revoke\_permission\_system\_system\_read</a>: Read-only access to all tables. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a5c7375b52d15ab38e540379dc7eb296c">revoke\_permission\_system\_system\_send\_alert</a>: Send system alerts. </li>
                  </ul>
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1RevokePermissionSystemResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1RevokePermissionSystemResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#abaf044cc15bfdb39af48c3c7d838d4e6">◆ </a></span>revokePermissionTable() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1RevokePermissionTableResponse">RevokePermissionTableResponse</a> gpudb::GPUdb::revokePermissionTable </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1RevokePermissionTableRequest">RevokePermissionTableRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Revokes a table-level permission from a user or role. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1RevokePermissionTableRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1RevokePermissionTableResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a8d3b2f5c7e28677e5ea3c4be996dcabd">◆ </a></span>revokePermissionTable() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1RevokePermissionTableResponse">RevokePermissionTableResponse</a> & gpudb::GPUdb::revokePermissionTable </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1RevokePermissionTableRequest">RevokePermissionTableRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1RevokePermissionTableResponse">RevokePermissionTableResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Revokes a table-level permission from a user or role. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1RevokePermissionTableRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1RevokePermissionTableResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1RevokePermissionTableResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ac4183c48e168e0ce4d78c82f96d6adc3">◆ </a></span>revokePermissionTable() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1RevokePermissionTableResponse">RevokePermissionTableResponse</a> gpudb::GPUdb::revokePermissionTable </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>permission</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Revokes a table-level permission from a user or role. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>name</td>
                <td>Name of the user or role from which the permission will be revoked. Must be an existing user or role. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>permission</td>

                <td>
                  Permission to revoke from the user or role. Supported values:

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#ada71c4c0435153ec10bff5873e2e9468">revoke\_permission\_table\_table\_admin</a>: Full read/write and administrative access to the table. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#afa14e9af75c3a742ac09c0e362f22468">revoke\_permission\_table\_table\_insert</a>: Insert access to the table. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#adb409c8abd923492b460aaa66a2229c7">revoke\_permission\_table\_table\_update</a>: Update access to the table. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a32e91402beeb87d7db3f248da596ddc7">revoke\_permission\_table\_table\_delete</a>: Delete access to the table. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a465f0e61f1207798cd5a697bbdf366c0">revoke\_permission\_table\_table\_read</a>: Read access to the table. </li>
                  </ul>
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of the table to which the permission grants access, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. Must be an existing table, view or schema. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a0f0c69fd6e2c448a915e260f0f70d649">revoke\_permission\_table\_columns</a>: Apply security to these columns, comma-separated. The default value is ''. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1RevokePermissionTableResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#abf33298e271827ae006a41f25658968c">◆ </a></span>revokePermissionTable() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1RevokePermissionTableResponse">RevokePermissionTableResponse</a> & gpudb::GPUdb::revokePermissionTable </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>permission</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1RevokePermissionTableResponse">RevokePermissionTableResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Revokes a table-level permission from a user or role. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>name</td>
                <td>Name of the user or role from which the permission will be revoked. Must be an existing user or role. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>permission</td>

                <td>
                  Permission to revoke from the user or role. Supported values:

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#ada71c4c0435153ec10bff5873e2e9468">revoke\_permission\_table\_table\_admin</a>: Full read/write and administrative access to the table. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#afa14e9af75c3a742ac09c0e362f22468">revoke\_permission\_table\_table\_insert</a>: Insert access to the table. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#adb409c8abd923492b460aaa66a2229c7">revoke\_permission\_table\_table\_update</a>: Update access to the table. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a32e91402beeb87d7db3f248da596ddc7">revoke\_permission\_table\_table\_delete</a>: Delete access to the table. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a465f0e61f1207798cd5a697bbdf366c0">revoke\_permission\_table\_table\_read</a>: Read access to the table. </li>
                  </ul>
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of the table to which the permission grants access, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. Must be an existing table, view or schema. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a0f0c69fd6e2c448a915e260f0f70d649">revoke\_permission\_table\_columns</a>: Apply security to these columns, comma-separated. The default value is ''. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1RevokePermissionTableResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1RevokePermissionTableResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#af2ab5ebfb9d96023490305c680d6f923">◆ </a></span>revokeRole() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1RevokeRoleResponse">RevokeRoleResponse</a> gpudb::GPUdb::revokeRole </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1RevokeRoleRequest">RevokeRoleRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Revokes membership in a role from a user or role. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1RevokeRoleRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1RevokeRoleResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a42fccf8d04bdd1dd09321e097d3ad67c">◆ </a></span>revokeRole() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1RevokeRoleResponse">RevokeRoleResponse</a> & gpudb::GPUdb::revokeRole </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1RevokeRoleRequest">RevokeRoleRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1RevokeRoleResponse">RevokeRoleResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Revokes membership in a role from a user or role. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1RevokeRoleRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1RevokeRoleResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1RevokeRoleResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a82f2ac33256a97486b580e8a7b4d2d12">◆ </a></span>revokeRole() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1RevokeRoleResponse">RevokeRoleResponse</a> gpudb::GPUdb::revokeRole </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>role</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>member</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Revokes membership in a role from a user or role. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>role</td>
                <td>Name of the role in which membership will be revoked. Must be an existing role. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>member</td>
                <td>Name of the user or role that will be revoked membership in <span>role</span>. Must be an existing user or role. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1RevokeRoleResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a965b7a7a9e82170d7b4859799d372ce8">◆ </a></span>revokeRole() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1RevokeRoleResponse">RevokeRoleResponse</a> & gpudb::GPUdb::revokeRole </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>role</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>member</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1RevokeRoleResponse">RevokeRoleResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Revokes membership in a role from a user or role. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>role</td>
                <td>Name of the role in which membership will be revoked. Must be an existing role. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>member</td>
                <td>Name of the user or role that will be revoked membership in <span>role</span>. Must be an existing user or role. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1RevokeRoleResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1RevokeRoleResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a3d9092f061ebd3e72c0f6f1db3709f6e">◆ </a></span>sanitizeUserAgentToken()</h2>

    <div>
      <div>
        <table>
          <tr>
            <td>
              <table>
                <tr>
                  <td>static std::string gpudb::GPUdb::sanitizeUserAgentToken </td>
                  <td>(</td>
                  <td>const std::string &</td>
                  <td><span><span>value</span></span></td>
                  <td>)</td>

                  <td />
                </tr>
              </table>
            </td>

            <td> <span><span>static</span></span> </td>
          </tr>
        </table>
      </div>

      <div>
        <p>Sanitizes a token for use in the User-Agent header by replacing disallowed characters with underscores. </p>
      </div>
    </div>

    <h2><span><a href="#a71ebc6d06dede4f22358d47abf91d66f">◆ </a></span>setHASyncMode()</h2>

    <div>
      <div>
        <table>
          <tr>
            <td>void gpudb::GPUdb::setHASyncMode </td>
            <td>(</td>
            <td><a href="#a37626bfbd9c5e1decfcd08d7851e6719">HASynchronicityMode</a></td>
            <td><span><span>mode</span></span></td>
            <td>)</td>

            <td />
          </tr>
        </table>
      </div>

      <div>
        <p>Sets the high-availability synchronization mode which will override the default mode. </p>
      </div>
    </div>

    <h2><span><a href="#a34282710c81f1a106ac96da1e1ce4211">◆ </a></span>showBackup() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowBackupResponse">ShowBackupResponse</a> gpudb::GPUdb::showBackup </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1ShowBackupRequest">ShowBackupRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Shows information about one or more <a href="/content/admin/backup_restore/#database-backup">backups</a> accessible via the <a href="/content/concepts/data_sources/">data source</a> specified by <a href="/content/api/cpp/structgpudb_1_1ShowBackupRequest#a4c53beb3d991fb36d95db8360588a455">datasourceName</a>. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowBackupRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowBackupResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a7164fd1c1db5357815a5465aadd5f8aa">◆ </a></span>showBackup() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowBackupResponse">ShowBackupResponse</a> & gpudb::GPUdb::showBackup </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1ShowBackupRequest">ShowBackupRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1ShowBackupResponse">ShowBackupResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Shows information about one or more <a href="/content/admin/backup_restore/#database-backup">backups</a> accessible via the <a href="/content/concepts/data_sources/">data source</a> specified by <a href="/content/api/cpp/structgpudb_1_1ShowBackupRequest#a4c53beb3d991fb36d95db8360588a455">datasourceName</a>. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowBackupRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowBackupResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowBackupResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ac5bb47e7d77debb047c7069ece8a6bba">◆ </a></span>showBackup() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowBackupResponse">ShowBackupResponse</a> gpudb::GPUdb::showBackup </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>backupName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>datasourceName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Shows information about one or more <a href="/content/admin/backup_restore/#database-backup">backups</a> accessible via the <a href="/content/concepts/data_sources/">data source</a> specified by <span>datasourceName</span>. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>backupName</td>
                <td>Name of the backup. An empty string or '<span>' will show all existing backups. Any text followed by a '</span>' will show backups whose name starts with that text. The default value is ''. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>datasourceName</td>
                <td>Data source through which the backup is accessible. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a3269c6d9ff10c33f4213d76590effaed">show\_backup\_backup\_id</a>: ID of the snapshot to show. Leave empty to show information from the most recent snapshot in the backup. The default value is ''. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a819635b9225fc4b6afcd8768715c1d11">show\_backup\_backup\_type</a>: Show backups by type. This option is ignored if <a href="/content/api/cpp/namespacegpudb#a3269c6d9ff10c33f4213d76590effaed">backup\_id</a> is non-empty. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a33a1a3611401c6936cd9cc70688e14da">show\_backup\_all</a>: Show all backup types. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a4a6b21c880132a275efce98c09c36131">show\_backup\_full</a>: Show full backups only. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a2f7f019b2916c4c3645eb294b8d65afa">show\_backup\_incremental</a>: Show incremental backups only. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ac6137ca9b245b82e7da42fb59871634c">show\_backup\_differential</a>: Show differential backups only. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a33a1a3611401c6936cd9cc70688e14da">show\_backup\_all</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a9293fe14d819e7e1a5fc94456f18b8b8">show\_backup\_show\_contents</a>: Show the contents of the backed-up snapshots. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a39bff1c8e36e73d2e34467c0ab71dd89">show\_backup\_none</a>: Don't show snapshot contents. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ae3d1c5999b22c1766977f14a9bd0e8bc">show\_backup\_object\_names</a>: Show backed-up object names, and for tables, sizing detail. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a05d969c804a68086f2f082eb00c9e41d">show\_backup\_object\_files</a>: Show backed-up object names, and for tables, sizing detail and associated files. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a39bff1c8e36e73d2e34467c0ab71dd89">show\_backup\_none</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a43c6648255e4c1eae0430f0a25a2e12c">show\_backup\_no\_error\_if\_not\_exists</a>: Whether or not to suppress the error if the specified backup does not exist. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a661dcd43a3b8131b46ca569f68e80399">show\_backup\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a67f9b488a9898861f9782b2b2aa648ab">show\_backup\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a67f9b488a9898861f9782b2b2aa648ab">show\_backup\_false</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowBackupResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#afac647eceb0bf839b94ba9e4099a6ee0">◆ </a></span>showBackup() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowBackupResponse">ShowBackupResponse</a> & gpudb::GPUdb::showBackup </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>backupName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>datasourceName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1ShowBackupResponse">ShowBackupResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Shows information about one or more <a href="/content/admin/backup_restore/#database-backup">backups</a> accessible via the <a href="/content/concepts/data_sources/">data source</a> specified by <span>datasourceName</span>. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>backupName</td>
                <td>Name of the backup. An empty string or '<span>' will show all existing backups. Any text followed by a '</span>' will show backups whose name starts with that text. The default value is ''. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>datasourceName</td>
                <td>Data source through which the backup is accessible. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a3269c6d9ff10c33f4213d76590effaed">show\_backup\_backup\_id</a>: ID of the snapshot to show. Leave empty to show information from the most recent snapshot in the backup. The default value is ''. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a819635b9225fc4b6afcd8768715c1d11">show\_backup\_backup\_type</a>: Show backups by type. This option is ignored if <a href="/content/api/cpp/namespacegpudb#a3269c6d9ff10c33f4213d76590effaed">backup\_id</a> is non-empty. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a33a1a3611401c6936cd9cc70688e14da">show\_backup\_all</a>: Show all backup types. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a4a6b21c880132a275efce98c09c36131">show\_backup\_full</a>: Show full backups only. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a2f7f019b2916c4c3645eb294b8d65afa">show\_backup\_incremental</a>: Show incremental backups only. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ac6137ca9b245b82e7da42fb59871634c">show\_backup\_differential</a>: Show differential backups only. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a33a1a3611401c6936cd9cc70688e14da">show\_backup\_all</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a9293fe14d819e7e1a5fc94456f18b8b8">show\_backup\_show\_contents</a>: Show the contents of the backed-up snapshots. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a39bff1c8e36e73d2e34467c0ab71dd89">show\_backup\_none</a>: Don't show snapshot contents. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ae3d1c5999b22c1766977f14a9bd0e8bc">show\_backup\_object\_names</a>: Show backed-up object names, and for tables, sizing detail. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a05d969c804a68086f2f082eb00c9e41d">show\_backup\_object\_files</a>: Show backed-up object names, and for tables, sizing detail and associated files. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a39bff1c8e36e73d2e34467c0ab71dd89">show\_backup\_none</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a43c6648255e4c1eae0430f0a25a2e12c">show\_backup\_no\_error\_if\_not\_exists</a>: Whether or not to suppress the error if the specified backup does not exist. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a661dcd43a3b8131b46ca569f68e80399">show\_backup\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a67f9b488a9898861f9782b2b2aa648ab">show\_backup\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a67f9b488a9898861f9782b2b2aa648ab">show\_backup\_false</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowBackupResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowBackupResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a8a6cc5b109352abc15c712cf43afcfd5">◆ </a></span>showCredential() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowCredentialResponse">ShowCredentialResponse</a> gpudb::GPUdb::showCredential </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1ShowCredentialRequest">ShowCredentialRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Shows information about a specified <a href="/content/concepts/credentials/">credential</a> or all credentials. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowCredentialRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowCredentialResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a8bebd7da393fc8b7171956ec6426962e">◆ </a></span>showCredential() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowCredentialResponse">ShowCredentialResponse</a> & gpudb::GPUdb::showCredential </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1ShowCredentialRequest">ShowCredentialRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1ShowCredentialResponse">ShowCredentialResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Shows information about a specified <a href="/content/concepts/credentials/">credential</a> or all credentials. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowCredentialRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowCredentialResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowCredentialResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ae50bb1bf426256e47af58232466f6f44">◆ </a></span>showCredential() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowCredentialResponse">ShowCredentialResponse</a> gpudb::GPUdb::showCredential </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>credentialName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Shows information about a specified <a href="/content/concepts/credentials/">credential</a> or all credentials. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>credentialName</td>
                <td>Name of the credential on which to retrieve information. The name must refer to a currently existing credential. If '\*' is specified, information about all credentials will be returned. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowCredentialResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#aaa932d90ebb6dc3d6510ae7932901dac">◆ </a></span>showCredential() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowCredentialResponse">ShowCredentialResponse</a> & gpudb::GPUdb::showCredential </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>credentialName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1ShowCredentialResponse">ShowCredentialResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Shows information about a specified <a href="/content/concepts/credentials/">credential</a> or all credentials. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>credentialName</td>
                <td>Name of the credential on which to retrieve information. The name must refer to a currently existing credential. If '\*' is specified, information about all credentials will be returned. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowCredentialResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowCredentialResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a13af4020cdbe38c12188d1c8488c99aa">◆ </a></span>showDatasink() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowDatasinkResponse">ShowDatasinkResponse</a> gpudb::GPUdb::showDatasink </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1ShowDatasinkRequest">ShowDatasinkRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Shows information about a specified <a href="/content/concepts/data_sinks/">data sink</a> or all data sinks. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowDatasinkRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowDatasinkResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a9832668f41ca574bbd5026124f5024d3">◆ </a></span>showDatasink() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowDatasinkResponse">ShowDatasinkResponse</a> & gpudb::GPUdb::showDatasink </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1ShowDatasinkRequest">ShowDatasinkRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1ShowDatasinkResponse">ShowDatasinkResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Shows information about a specified <a href="/content/concepts/data_sinks/">data sink</a> or all data sinks. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowDatasinkRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowDatasinkResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowDatasinkResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a905e27980f40316043b75a662f2e9c84">◆ </a></span>showDatasink() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowDatasinkResponse">ShowDatasinkResponse</a> gpudb::GPUdb::showDatasink </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Shows information about a specified <a href="/content/concepts/data_sinks/">data sink</a> or all data sinks. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>name</td>
                <td>Name of the data sink for which to retrieve information. The name must refer to a currently existing data sink. If '\*' is specified, information about all data sinks will be returned. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowDatasinkResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a270d824dd50f10b254489586d181e7dc">◆ </a></span>showDatasink() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowDatasinkResponse">ShowDatasinkResponse</a> & gpudb::GPUdb::showDatasink </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1ShowDatasinkResponse">ShowDatasinkResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Shows information about a specified <a href="/content/concepts/data_sinks/">data sink</a> or all data sinks. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>name</td>
                <td>Name of the data sink for which to retrieve information. The name must refer to a currently existing data sink. If '\*' is specified, information about all data sinks will be returned. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowDatasinkResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowDatasinkResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a68037bb39be04e21f46e233a32e2bd5b">◆ </a></span>showDatasource() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowDatasourceResponse">ShowDatasourceResponse</a> gpudb::GPUdb::showDatasource </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1ShowDatasourceRequest">ShowDatasourceRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Shows information about a specified <a href="/content/concepts/data_sources/">data source</a> or all data sources. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowDatasourceRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowDatasourceResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a15f7b88b3d480e2e189ccdfae7ee2fd5">◆ </a></span>showDatasource() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowDatasourceResponse">ShowDatasourceResponse</a> & gpudb::GPUdb::showDatasource </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1ShowDatasourceRequest">ShowDatasourceRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1ShowDatasourceResponse">ShowDatasourceResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Shows information about a specified <a href="/content/concepts/data_sources/">data source</a> or all data sources. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowDatasourceRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowDatasourceResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowDatasourceResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a596fab35b766d506ddb9ad94c1330f1c">◆ </a></span>showDatasource() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowDatasourceResponse">ShowDatasourceResponse</a> gpudb::GPUdb::showDatasource </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Shows information about a specified <a href="/content/concepts/data_sources/">data source</a> or all data sources. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>name</td>
                <td>Name of the data source for which to retrieve information. The name must refer to a currently existing data source. If '\*' is specified, information about all data sources will be returned. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowDatasourceResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a835cc3144ea0d08f815948b9cba92528">◆ </a></span>showDatasource() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowDatasourceResponse">ShowDatasourceResponse</a> & gpudb::GPUdb::showDatasource </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1ShowDatasourceResponse">ShowDatasourceResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Shows information about a specified <a href="/content/concepts/data_sources/">data source</a> or all data sources. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>name</td>
                <td>Name of the data source for which to retrieve information. The name must refer to a currently existing data source. If '\*' is specified, information about all data sources will be returned. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowDatasourceResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowDatasourceResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a4938a2b931ab7710d13c4eb46caeb79b">◆ </a></span>showDirectories() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowDirectoriesResponse">ShowDirectoriesResponse</a> gpudb::GPUdb::showDirectories </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1ShowDirectoriesRequest">ShowDirectoriesRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Shows information about directories in <a href="/content/tools/kifs/">KiFS</a>. </p>
        <p>Can be used to show a single directory, or all directories.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowDirectoriesRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowDirectoriesResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a5d6437a5dac0f332d11129a27526c424">◆ </a></span>showDirectories() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowDirectoriesResponse">ShowDirectoriesResponse</a> & gpudb::GPUdb::showDirectories </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1ShowDirectoriesRequest">ShowDirectoriesRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1ShowDirectoriesResponse">ShowDirectoriesResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Shows information about directories in <a href="/content/tools/kifs/">KiFS</a>. </p>
        <p>Can be used to show a single directory, or all directories.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowDirectoriesRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowDirectoriesResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowDirectoriesResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a9c29f706c737f08808675066fe0cb14a">◆ </a></span>showDirectories() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowDirectoriesResponse">ShowDirectoriesResponse</a> gpudb::GPUdb::showDirectories </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>directoryName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Shows information about directories in <a href="/content/tools/kifs/">KiFS</a>. </p>
        <p>Can be used to show a single directory, or all directories.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>directoryName</td>
                <td>The KiFS directory name to show. If empty, shows all directories. The default value is ''. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowDirectoriesResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a72f8a16fa689331e831c4779b6ef3844">◆ </a></span>showDirectories() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowDirectoriesResponse">ShowDirectoriesResponse</a> & gpudb::GPUdb::showDirectories </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>directoryName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1ShowDirectoriesResponse">ShowDirectoriesResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Shows information about directories in <a href="/content/tools/kifs/">KiFS</a>. </p>
        <p>Can be used to show a single directory, or all directories.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>directoryName</td>
                <td>The KiFS directory name to show. If empty, shows all directories. The default value is ''. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowDirectoriesResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowDirectoriesResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ad2c3289e4d36b6d0278357e362354c35">◆ </a></span>showEnvironment() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowEnvironmentResponse">ShowEnvironmentResponse</a> gpudb::GPUdb::showEnvironment </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1ShowEnvironmentRequest">ShowEnvironmentRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Shows information about a specified <a href="/content/concepts/udf/">user-defined function</a> (UDF) environment or all environments. </p>
        <p>Returns detailed information about existing environments.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowEnvironmentRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowEnvironmentResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a642110b2dfca287ef3f899ae69471648">◆ </a></span>showEnvironment() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowEnvironmentResponse">ShowEnvironmentResponse</a> & gpudb::GPUdb::showEnvironment </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1ShowEnvironmentRequest">ShowEnvironmentRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1ShowEnvironmentResponse">ShowEnvironmentResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Shows information about a specified <a href="/content/concepts/udf/">user-defined function</a> (UDF) environment or all environments. </p>
        <p>Returns detailed information about existing environments.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowEnvironmentRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowEnvironmentResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowEnvironmentResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a02c334c7050c5c8541543bffbb2c3dab">◆ </a></span>showEnvironment() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowEnvironmentResponse">ShowEnvironmentResponse</a> gpudb::GPUdb::showEnvironment </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>environmentName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Shows information about a specified <a href="/content/concepts/udf/">user-defined function</a> (UDF) environment or all environments. </p>
        <p>Returns detailed information about existing environments.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>environmentName</td>
                <td>Name of the environment on which to retrieve information. The name must refer to a currently existing environment. If '\*' or an empty value is specified, information about all environments will be returned. The default value is ''. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#af575f109d992b4aef0f341f00e7b5d94">show\_environment\_no\_error\_if\_not\_exists</a>: If <a href="/content/api/cpp/namespacegpudb#a4d1a16db5d9451ac3fcfaeddb78814b9">true</a> and if the environment specified in <span>environmentName</span> does not exist, no error is returned. If <a href="/content/api/cpp/namespacegpudb#aa866ab06d053878b37890174c72e0c8b">false</a> and if the environment specified in <span>environmentName</span> does not exist, then an error is returned. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a4d1a16db5d9451ac3fcfaeddb78814b9">show\_environment\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aa866ab06d053878b37890174c72e0c8b">show\_environment\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#aa866ab06d053878b37890174c72e0c8b">show\_environment\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a8155c4dd32a05da2c9b16699f39779d0">show\_environment\_show\_names\_only</a>: If <a href="/content/api/cpp/namespacegpudb#a4d1a16db5d9451ac3fcfaeddb78814b9">true</a> only return the names of the installed environments and omit package listing. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a4d1a16db5d9451ac3fcfaeddb78814b9">show\_environment\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aa866ab06d053878b37890174c72e0c8b">show\_environment\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#aa866ab06d053878b37890174c72e0c8b">show\_environment\_false</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowEnvironmentResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#aa373b15e4a0e973a55356bc2b6a2c0b8">◆ </a></span>showEnvironment() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowEnvironmentResponse">ShowEnvironmentResponse</a> & gpudb::GPUdb::showEnvironment </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>environmentName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1ShowEnvironmentResponse">ShowEnvironmentResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Shows information about a specified <a href="/content/concepts/udf/">user-defined function</a> (UDF) environment or all environments. </p>
        <p>Returns detailed information about existing environments.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>environmentName</td>
                <td>Name of the environment on which to retrieve information. The name must refer to a currently existing environment. If '\*' or an empty value is specified, information about all environments will be returned. The default value is ''. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#af575f109d992b4aef0f341f00e7b5d94">show\_environment\_no\_error\_if\_not\_exists</a>: If <a href="/content/api/cpp/namespacegpudb#a4d1a16db5d9451ac3fcfaeddb78814b9">true</a> and if the environment specified in <span>environmentName</span> does not exist, no error is returned. If <a href="/content/api/cpp/namespacegpudb#aa866ab06d053878b37890174c72e0c8b">false</a> and if the environment specified in <span>environmentName</span> does not exist, then an error is returned. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a4d1a16db5d9451ac3fcfaeddb78814b9">show\_environment\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aa866ab06d053878b37890174c72e0c8b">show\_environment\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#aa866ab06d053878b37890174c72e0c8b">show\_environment\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a8155c4dd32a05da2c9b16699f39779d0">show\_environment\_show\_names\_only</a>: If <a href="/content/api/cpp/namespacegpudb#a4d1a16db5d9451ac3fcfaeddb78814b9">true</a> only return the names of the installed environments and omit package listing. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a4d1a16db5d9451ac3fcfaeddb78814b9">show\_environment\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aa866ab06d053878b37890174c72e0c8b">show\_environment\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#aa866ab06d053878b37890174c72e0c8b">show\_environment\_false</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowEnvironmentResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowEnvironmentResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a25eed62c5697242506cc5e336925b45d">◆ </a></span>showFiles() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowFilesResponse">ShowFilesResponse</a> gpudb::GPUdb::showFiles </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1ShowFilesRequest">ShowFilesRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Shows information about files in <a href="/content/tools/kifs/">KiFS</a>. </p>
        <p>Can be used for individual files, or to show all files in a given directory.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowFilesRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowFilesResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a16e25d4e91734847b87f3f1a44862f13">◆ </a></span>showFiles() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowFilesResponse">ShowFilesResponse</a> & gpudb::GPUdb::showFiles </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1ShowFilesRequest">ShowFilesRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1ShowFilesResponse">ShowFilesResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Shows information about files in <a href="/content/tools/kifs/">KiFS</a>. </p>
        <p>Can be used for individual files, or to show all files in a given directory.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowFilesRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowFilesResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowFilesResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a96bb343ffbdcbfdfa09e2cb3d850b12f">◆ </a></span>showFiles() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowFilesResponse">ShowFilesResponse</a> gpudb::GPUdb::showFiles </td>
            <td>(</td>
            <td>const std::vector\< std::string > &</td>
            <td><span><span>paths</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Shows information about files in <a href="/content/tools/kifs/">KiFS</a>. </p>
        <p>Can be used for individual files, or to show all files in a given directory.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>paths</td>
                <td>File paths to show. Each path can be a KiFS directory name, or a full path to a KiFS file. File paths may contain wildcard characters after the KiFS directory delimiter. Accepted wildcard characters are asterisk (\*) to represent any string of zero or more characters, and question mark (?) to indicate a single character. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowFilesResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a9f53bbe801f06691fd686533da8ec2d8">◆ </a></span>showFiles() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowFilesResponse">ShowFilesResponse</a> & gpudb::GPUdb::showFiles </td>
            <td>(</td>
            <td>const std::vector\< std::string > &</td>
            <td><span><span>paths</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1ShowFilesResponse">ShowFilesResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Shows information about files in <a href="/content/tools/kifs/">KiFS</a>. </p>
        <p>Can be used for individual files, or to show all files in a given directory.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>paths</td>
                <td>File paths to show. Each path can be a KiFS directory name, or a full path to a KiFS file. File paths may contain wildcard characters after the KiFS directory delimiter. Accepted wildcard characters are asterisk (\*) to represent any string of zero or more characters, and question mark (?) to indicate a single character. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowFilesResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowFilesResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#aa26104ece9a4825f8fd309470e2477ec">◆ </a></span>showGraph() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowGraphResponse">ShowGraphResponse</a> gpudb::GPUdb::showGraph </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1ShowGraphRequest">ShowGraphRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Shows information and characteristics of graphs that exist on the graph server. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowGraphRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowGraphResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#afde5e9ee7e8f46468385d65999027797">◆ </a></span>showGraph() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowGraphResponse">ShowGraphResponse</a> & gpudb::GPUdb::showGraph </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1ShowGraphRequest">ShowGraphRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1ShowGraphResponse">ShowGraphResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Shows information and characteristics of graphs that exist on the graph server. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowGraphRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowGraphResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowGraphResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a9debdae46b9cb8ce19f782d73a958c51">◆ </a></span>showGraph() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowGraphResponse">ShowGraphResponse</a> gpudb::GPUdb::showGraph </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>graphName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Shows information and characteristics of graphs that exist on the graph server. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>graphName</td>
                <td>Name of the graph on which to retrieve information. If left as the default value, information about all graphs is returned. The default value is ''. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a3bb68b1028a864565f1ce5919de172f4">show\_graph\_show\_original\_request</a>: If set to <a href="/content/api/cpp/namespacegpudb#a26a3b0bf712e67e2e00990e225e367f2">true</a>, the request that was originally used to create the graph is also returned as JSON. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a26a3b0bf712e67e2e00990e225e367f2">show\_graph\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a592bbf5af85bb488e6cad6647134bcdb">show\_graph\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a26a3b0bf712e67e2e00990e225e367f2">show\_graph\_true</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a3814a4ae4f1f583d62e4f013824e7e07">show\_graph\_server\_id</a>: Indicates which graph server(s) to send the request to. Default is to send to get information about all the servers. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#aab789724b8c8e65eecbf3c6bab42d8a6">show\_graph\_export\_graph\_schema</a>: If true, generates the graph ontology (schema) as a DOT format string in the response info field under the key 'dot'. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a26a3b0bf712e67e2e00990e225e367f2">show\_graph\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a592bbf5af85bb488e6cad6647134bcdb">show\_graph\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a592bbf5af85bb488e6cad6647134bcdb">show\_graph\_false</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowGraphResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a88e042d9704eae6dae407957f0cf43b2">◆ </a></span>showGraph() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowGraphResponse">ShowGraphResponse</a> & gpudb::GPUdb::showGraph </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>graphName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1ShowGraphResponse">ShowGraphResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Shows information and characteristics of graphs that exist on the graph server. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>graphName</td>
                <td>Name of the graph on which to retrieve information. If left as the default value, information about all graphs is returned. The default value is ''. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a3bb68b1028a864565f1ce5919de172f4">show\_graph\_show\_original\_request</a>: If set to <a href="/content/api/cpp/namespacegpudb#a26a3b0bf712e67e2e00990e225e367f2">true</a>, the request that was originally used to create the graph is also returned as JSON. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a26a3b0bf712e67e2e00990e225e367f2">show\_graph\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a592bbf5af85bb488e6cad6647134bcdb">show\_graph\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a26a3b0bf712e67e2e00990e225e367f2">show\_graph\_true</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a3814a4ae4f1f583d62e4f013824e7e07">show\_graph\_server\_id</a>: Indicates which graph server(s) to send the request to. Default is to send to get information about all the servers. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#aab789724b8c8e65eecbf3c6bab42d8a6">show\_graph\_export\_graph\_schema</a>: If true, generates the graph ontology (schema) as a DOT format string in the response info field under the key 'dot'. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a26a3b0bf712e67e2e00990e225e367f2">show\_graph\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a592bbf5af85bb488e6cad6647134bcdb">show\_graph\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a592bbf5af85bb488e6cad6647134bcdb">show\_graph\_false</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowGraphResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowGraphResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ae7427428b2214adb5622e723382cb304">◆ </a></span>showProc() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowProcResponse">ShowProcResponse</a> gpudb::GPUdb::showProc </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1ShowProcRequest">ShowProcRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Shows information about a proc. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowProcRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowProcResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a5061ef951ef0a4b8d987d3d2b7c83d57">◆ </a></span>showProc() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowProcResponse">ShowProcResponse</a> & gpudb::GPUdb::showProc </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1ShowProcRequest">ShowProcRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1ShowProcResponse">ShowProcResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Shows information about a proc. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowProcRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowProcResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowProcResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a4ff6de0d6b70a356a1995b973c9811dc">◆ </a></span>showProc() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowProcResponse">ShowProcResponse</a> gpudb::GPUdb::showProc </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>procName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Shows information about a proc. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>procName</td>
                <td>Name of the proc to show information about. If specified, must be the name of a currently existing proc. If not specified, information about all procs will be returned. The default value is ''. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#aa10b05418a4d2243037e0b717419c8b0">show\_proc\_include\_files</a>: If set to <a href="/content/api/cpp/namespacegpudb#a65b2142b10ccfd6389f690e9da9d16bc">true</a>, the files that make up the proc will be returned. If set to <a href="/content/api/cpp/namespacegpudb#a0fb62f1764d96da8371fd11c9771a2cb">false</a>, the files will not be returned. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a65b2142b10ccfd6389f690e9da9d16bc">show\_proc\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a0fb62f1764d96da8371fd11c9771a2cb">show\_proc\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a0fb62f1764d96da8371fd11c9771a2cb">show\_proc\_false</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowProcResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ae6068858a2038ed362689d6d360a058f">◆ </a></span>showProc() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowProcResponse">ShowProcResponse</a> & gpudb::GPUdb::showProc </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>procName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1ShowProcResponse">ShowProcResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Shows information about a proc. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>procName</td>
                <td>Name of the proc to show information about. If specified, must be the name of a currently existing proc. If not specified, information about all procs will be returned. The default value is ''. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#aa10b05418a4d2243037e0b717419c8b0">show\_proc\_include\_files</a>: If set to <a href="/content/api/cpp/namespacegpudb#a65b2142b10ccfd6389f690e9da9d16bc">true</a>, the files that make up the proc will be returned. If set to <a href="/content/api/cpp/namespacegpudb#a0fb62f1764d96da8371fd11c9771a2cb">false</a>, the files will not be returned. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a65b2142b10ccfd6389f690e9da9d16bc">show\_proc\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a0fb62f1764d96da8371fd11c9771a2cb">show\_proc\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a0fb62f1764d96da8371fd11c9771a2cb">show\_proc\_false</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowProcResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowProcResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a1d460da9ead16a63d91e8a104805d0a6">◆ </a></span>showProcStatus() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowProcStatusResponse">ShowProcStatusResponse</a> gpudb::GPUdb::showProcStatus </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1ShowProcStatusRequest">ShowProcStatusRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Shows the statuses of running or completed proc instances. </p>
        <p>Results are grouped by run ID (as returned from <a href="#aec2cf18c6185bf22d4fa351019b9924e">executeProc</a>) and data segment ID (each invocation of the proc command on a data segment is assigned a data segment ID).</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowProcStatusRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowProcStatusResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a24b7a91e64544a630bba237a13278ced">◆ </a></span>showProcStatus() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowProcStatusResponse">ShowProcStatusResponse</a> & gpudb::GPUdb::showProcStatus </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1ShowProcStatusRequest">ShowProcStatusRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1ShowProcStatusResponse">ShowProcStatusResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Shows the statuses of running or completed proc instances. </p>
        <p>Results are grouped by run ID (as returned from <a href="#aec2cf18c6185bf22d4fa351019b9924e">executeProc</a>) and data segment ID (each invocation of the proc command on a data segment is assigned a data segment ID).</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowProcStatusRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowProcStatusResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowProcStatusResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a13497a80667b878cad9e5e6db04092d9">◆ </a></span>showProcStatus() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowProcStatusResponse">ShowProcStatusResponse</a> gpudb::GPUdb::showProcStatus </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>runId</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Shows the statuses of running or completed proc instances. </p>
        <p>Results are grouped by run ID (as returned from <a href="#a19f569cb61a53022021bbfd9e031468d">executeProc</a>) and data segment ID (each invocation of the proc command on a data segment is assigned a data segment ID).</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>runId</td>
                <td>The run ID of a specific proc instance for which the status will be returned. If a proc with a matching run ID is not found, the response will be empty. If not specified, the statuses of all executed proc instances will be returned. The default value is ''. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ac66483badacbfc643b331dc9a4fa49e4">show\_proc\_status\_clear\_complete</a>: If set to <a href="/content/api/cpp/namespacegpudb#a52fcd6cd1d56e6a8dab49e68f0749ba5">true</a>, if a proc instance has completed (either successfully or unsuccessfully) then its status will be cleared and no longer returned in subsequent calls. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a52fcd6cd1d56e6a8dab49e68f0749ba5">show\_proc\_status\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a14ba0ef4c12caf314a87db74604ffa80">show\_proc\_status\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a14ba0ef4c12caf314a87db74604ffa80">show\_proc\_status\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a346fcb78bba835a71c440750418aae75">show\_proc\_status\_run\_tag</a>: If <span>runId</span> is specified, return the status for a proc instance that has a matching run ID and a matching run tag that was provided to <a href="#a19f569cb61a53022021bbfd9e031468d">executeProc</a>. If <span>runId</span> is not specified, return statuses for all proc instances where a matching run tag was provided to <a href="#a19f569cb61a53022021bbfd9e031468d">executeProc</a>. The default value is ''. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowProcStatusResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ac60a93b49b3d2f94f229a9d0df2aa79b">◆ </a></span>showProcStatus() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowProcStatusResponse">ShowProcStatusResponse</a> & gpudb::GPUdb::showProcStatus </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>runId</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1ShowProcStatusResponse">ShowProcStatusResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Shows the statuses of running or completed proc instances. </p>
        <p>Results are grouped by run ID (as returned from <a href="#a19f569cb61a53022021bbfd9e031468d">executeProc</a>) and data segment ID (each invocation of the proc command on a data segment is assigned a data segment ID).</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>runId</td>
                <td>The run ID of a specific proc instance for which the status will be returned. If a proc with a matching run ID is not found, the response will be empty. If not specified, the statuses of all executed proc instances will be returned. The default value is ''. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ac66483badacbfc643b331dc9a4fa49e4">show\_proc\_status\_clear\_complete</a>: If set to <a href="/content/api/cpp/namespacegpudb#a52fcd6cd1d56e6a8dab49e68f0749ba5">true</a>, if a proc instance has completed (either successfully or unsuccessfully) then its status will be cleared and no longer returned in subsequent calls. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a52fcd6cd1d56e6a8dab49e68f0749ba5">show\_proc\_status\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a14ba0ef4c12caf314a87db74604ffa80">show\_proc\_status\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a14ba0ef4c12caf314a87db74604ffa80">show\_proc\_status\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a346fcb78bba835a71c440750418aae75">show\_proc\_status\_run\_tag</a>: If <span>runId</span> is specified, return the status for a proc instance that has a matching run ID and a matching run tag that was provided to <a href="#a19f569cb61a53022021bbfd9e031468d">executeProc</a>. If <span>runId</span> is not specified, return statuses for all proc instances where a matching run tag was provided to <a href="#a19f569cb61a53022021bbfd9e031468d">executeProc</a>. The default value is ''. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowProcStatusResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowProcStatusResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a378c6b54b2b4795e17ba59fe12110633">◆ </a></span>showResourceGroups() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowResourceGroupsResponse">ShowResourceGroupsResponse</a> gpudb::GPUdb::showResourceGroups </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1ShowResourceGroupsRequest">ShowResourceGroupsRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Requests resource group properties. </p>
        <p>Returns detailed information about the requested resource groups.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowResourceGroupsRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowResourceGroupsResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#add609fa998cd62bb51ad9795c4e9f897">◆ </a></span>showResourceGroups() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowResourceGroupsResponse">ShowResourceGroupsResponse</a> & gpudb::GPUdb::showResourceGroups </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1ShowResourceGroupsRequest">ShowResourceGroupsRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1ShowResourceGroupsResponse">ShowResourceGroupsResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Requests resource group properties. </p>
        <p>Returns detailed information about the requested resource groups.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowResourceGroupsRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowResourceGroupsResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowResourceGroupsResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a726aae68f00a46595368ee7f5a3f4ec9">◆ </a></span>showResourceGroups() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowResourceGroupsResponse">ShowResourceGroupsResponse</a> gpudb::GPUdb::showResourceGroups </td>
            <td>(</td>
            <td>const std::vector\< std::string > &</td>
            <td><span><span>names</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Requests resource group properties. </p>
        <p>Returns detailed information about the requested resource groups.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>names</td>
                <td>List of names of groups to be shown. A single entry with an empty string returns all groups. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a833517c8c044c706f5f41c953c15ccd7">show\_resource\_groups\_show\_default\_values</a>: If <a href="/content/api/cpp/namespacegpudb#ad4b3a02d3ee642e2843160475c7b0303">true</a> include values of fields that are based on the default resource group. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad4b3a02d3ee642e2843160475c7b0303">show\_resource\_groups\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#acea27e6ab09c00ff04331e9ffac27447">show\_resource\_groups\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ad4b3a02d3ee642e2843160475c7b0303">show\_resource\_groups\_true</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a43527f4db3b1b92867362d128cbd5297">show\_resource\_groups\_show\_default\_group</a>: If <a href="/content/api/cpp/namespacegpudb#ad4b3a02d3ee642e2843160475c7b0303">true</a> include the default and system resource groups in the response. This value defaults to false if an explicit list of group names is provided, and true otherwise. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad4b3a02d3ee642e2843160475c7b0303">show\_resource\_groups\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#acea27e6ab09c00ff04331e9ffac27447">show\_resource\_groups\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ad4b3a02d3ee642e2843160475c7b0303">show\_resource\_groups\_true</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a3ec409936a7718d4c378f9e2d6050e2e">show\_resource\_groups\_show\_tier\_usage</a>: If <a href="/content/api/cpp/namespacegpudb#ad4b3a02d3ee642e2843160475c7b0303">true</a> include the resource group usage on the worker ranks in the response. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad4b3a02d3ee642e2843160475c7b0303">show\_resource\_groups\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#acea27e6ab09c00ff04331e9ffac27447">show\_resource\_groups\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#acea27e6ab09c00ff04331e9ffac27447">show\_resource\_groups\_false</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowResourceGroupsResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a1181eebb9d511dd63c8c978476c8e89b">◆ </a></span>showResourceGroups() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowResourceGroupsResponse">ShowResourceGroupsResponse</a> & gpudb::GPUdb::showResourceGroups </td>
            <td>(</td>
            <td>const std::vector\< std::string > &</td>
            <td><span><span>names</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1ShowResourceGroupsResponse">ShowResourceGroupsResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Requests resource group properties. </p>
        <p>Returns detailed information about the requested resource groups.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>names</td>
                <td>List of names of groups to be shown. A single entry with an empty string returns all groups. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a833517c8c044c706f5f41c953c15ccd7">show\_resource\_groups\_show\_default\_values</a>: If <a href="/content/api/cpp/namespacegpudb#ad4b3a02d3ee642e2843160475c7b0303">true</a> include values of fields that are based on the default resource group. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad4b3a02d3ee642e2843160475c7b0303">show\_resource\_groups\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#acea27e6ab09c00ff04331e9ffac27447">show\_resource\_groups\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ad4b3a02d3ee642e2843160475c7b0303">show\_resource\_groups\_true</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a43527f4db3b1b92867362d128cbd5297">show\_resource\_groups\_show\_default\_group</a>: If <a href="/content/api/cpp/namespacegpudb#ad4b3a02d3ee642e2843160475c7b0303">true</a> include the default and system resource groups in the response. This value defaults to false if an explicit list of group names is provided, and true otherwise. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad4b3a02d3ee642e2843160475c7b0303">show\_resource\_groups\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#acea27e6ab09c00ff04331e9ffac27447">show\_resource\_groups\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ad4b3a02d3ee642e2843160475c7b0303">show\_resource\_groups\_true</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a3ec409936a7718d4c378f9e2d6050e2e">show\_resource\_groups\_show\_tier\_usage</a>: If <a href="/content/api/cpp/namespacegpudb#ad4b3a02d3ee642e2843160475c7b0303">true</a> include the resource group usage on the worker ranks in the response. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad4b3a02d3ee642e2843160475c7b0303">show\_resource\_groups\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#acea27e6ab09c00ff04331e9ffac27447">show\_resource\_groups\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#acea27e6ab09c00ff04331e9ffac27447">show\_resource\_groups\_false</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowResourceGroupsResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowResourceGroupsResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a88a53f3f53aea0fe34c7952f8ed1706b">◆ </a></span>showResourceObjects() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowResourceObjectsResponse">ShowResourceObjectsResponse</a> gpudb::GPUdb::showResourceObjects </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1ShowResourceObjectsRequest">ShowResourceObjectsRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Returns information about the internal sub-components (tiered objects) which use resources of the system. </p>
        <p>The request can either return results from actively used objects (default) or it can be used to query the status of the objects of a given list of tables. Returns detailed information about the requested resource objects.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowResourceObjectsRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowResourceObjectsResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#af5c1be74988aa37d3ad684559e7adcc5">◆ </a></span>showResourceObjects() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowResourceObjectsResponse">ShowResourceObjectsResponse</a> & gpudb::GPUdb::showResourceObjects </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1ShowResourceObjectsRequest">ShowResourceObjectsRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1ShowResourceObjectsResponse">ShowResourceObjectsResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Returns information about the internal sub-components (tiered objects) which use resources of the system. </p>
        <p>The request can either return results from actively used objects (default) or it can be used to query the status of the objects of a given list of tables. Returns detailed information about the requested resource objects.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowResourceObjectsRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowResourceObjectsResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowResourceObjectsResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a7e822927bba455a02b789e548f61f683">◆ </a></span>showResourceObjects() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowResourceObjectsResponse">ShowResourceObjectsResponse</a> gpudb::GPUdb::showResourceObjects </td>
            <td>(</td>
            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Returns information about the internal sub-components (tiered objects) which use resources of the system. </p>
        <p>The request can either return results from actively used objects (default) or it can be used to query the status of the objects of a given list of tables. Returns detailed information about the requested resource objects.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a0b31f7927a9cdef08acde42fac2dc7c1">show\_resource\_objects\_tiers</a>: Comma-separated list of tiers to query, leave blank for all tiers. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#abe8884a0f27b77a621f21f69efb31a61">show\_resource\_objects\_expression</a>: An expression to filter the returned objects. Expression is limited to the following operators: =,!=,\<,\<=,>,>=,+,-,\*,AND,OR,LIKE. For details see <a href="/content/concepts/expressions/">Expressions</a>. To use a more complex expression, query the ki\_catalog.ki\_tiered\_objects table directly. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a152200d6a93427bfc232f77884df44e5">show\_resource\_objects\_order\_by</a>: Single column to be sorted by as well as the sort direction, e.g., 'size asc'. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a31ae0a48d4c457c0a8cf801caf34aa71">show\_resource\_objects\_size</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a8d7422ed6c4189882ccec4170f3cc034">show\_resource\_objects\_id</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ae086d1a79371642793bf32d742661a0f">show\_resource\_objects\_priority</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#adbfbaea531c8282d5c7da78ebd8883de">show\_resource\_objects\_tier</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aaa47cf3e378428e1118ae1bfdb29781a">show\_resource\_objects\_evictable</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aba35326e39fb3b1e3ad223367fdce581">show\_resource\_objects\_locked</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a4051d562714f5a17066db0a6136e2ce5">show\_resource\_objects\_pin\_count</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aacfe747e0197153a6c2990495ae0af8c">show\_resource\_objects\_ram\_evictions</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a48edb205f372f4c9543db5d056d6e205">show\_resource\_objects\_persist\_evictions</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a4bdb2a4b223ae81acb82bc8358396523">show\_resource\_objects\_owner\_resource\_group</a> </li>
                      </ul>
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a45ce4ae09004d8893864404b4da9e211">show\_resource\_objects\_limit</a>: An integer indicating the maximum number of results to be returned, per rank, or (-1) to indicate that the maximum number of results allowed by the server should be returned. The number of records returned will never exceed the server's own limit, defined by the <a href="/content/config/#config-main-general">max\_get\_records\_size</a> parameter in the server configuration. The default value is '100'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a5386e5737131544d28ca31856d222a1c">show\_resource\_objects\_table\_names</a>: Comma-separated list of tables to restrict the results to. Use '\*' to show all tables. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowResourceObjectsResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#aed2c3b3e3205862b58eca63e0af50856">◆ </a></span>showResourceObjects() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowResourceObjectsResponse">ShowResourceObjectsResponse</a> & gpudb::GPUdb::showResourceObjects </td>
            <td>(</td>
            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1ShowResourceObjectsResponse">ShowResourceObjectsResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Returns information about the internal sub-components (tiered objects) which use resources of the system. </p>
        <p>The request can either return results from actively used objects (default) or it can be used to query the status of the objects of a given list of tables. Returns detailed information about the requested resource objects.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a0b31f7927a9cdef08acde42fac2dc7c1">show\_resource\_objects\_tiers</a>: Comma-separated list of tiers to query, leave blank for all tiers. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#abe8884a0f27b77a621f21f69efb31a61">show\_resource\_objects\_expression</a>: An expression to filter the returned objects. Expression is limited to the following operators: =,!=,\<,\<=,>,>=,+,-,\*,AND,OR,LIKE. For details see <a href="/content/concepts/expressions/">Expressions</a>. To use a more complex expression, query the ki\_catalog.ki\_tiered\_objects table directly. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a152200d6a93427bfc232f77884df44e5">show\_resource\_objects\_order\_by</a>: Single column to be sorted by as well as the sort direction, e.g., 'size asc'. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a31ae0a48d4c457c0a8cf801caf34aa71">show\_resource\_objects\_size</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a8d7422ed6c4189882ccec4170f3cc034">show\_resource\_objects\_id</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ae086d1a79371642793bf32d742661a0f">show\_resource\_objects\_priority</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#adbfbaea531c8282d5c7da78ebd8883de">show\_resource\_objects\_tier</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aaa47cf3e378428e1118ae1bfdb29781a">show\_resource\_objects\_evictable</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aba35326e39fb3b1e3ad223367fdce581">show\_resource\_objects\_locked</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a4051d562714f5a17066db0a6136e2ce5">show\_resource\_objects\_pin\_count</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aacfe747e0197153a6c2990495ae0af8c">show\_resource\_objects\_ram\_evictions</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a48edb205f372f4c9543db5d056d6e205">show\_resource\_objects\_persist\_evictions</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a4bdb2a4b223ae81acb82bc8358396523">show\_resource\_objects\_owner\_resource\_group</a> </li>
                      </ul>
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a45ce4ae09004d8893864404b4da9e211">show\_resource\_objects\_limit</a>: An integer indicating the maximum number of results to be returned, per rank, or (-1) to indicate that the maximum number of results allowed by the server should be returned. The number of records returned will never exceed the server's own limit, defined by the <a href="/content/config/#config-main-general">max\_get\_records\_size</a> parameter in the server configuration. The default value is '100'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a5386e5737131544d28ca31856d222a1c">show\_resource\_objects\_table\_names</a>: Comma-separated list of tables to restrict the results to. Use '\*' to show all tables. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowResourceObjectsResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowResourceObjectsResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a3fc3bd8bd184e925912ade256e84f9f7">◆ </a></span>showResourceStatistics() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowResourceStatisticsResponse">ShowResourceStatisticsResponse</a> gpudb::GPUdb::showResourceStatistics </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1ShowResourceStatisticsRequest">ShowResourceStatisticsRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Requests various statistics for storage/memory tiers and resource groups. </p>
        <p>Returns statistics on a per-rank basis.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowResourceStatisticsRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowResourceStatisticsResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a8a63706033443ae53638d95e9e136d48">◆ </a></span>showResourceStatistics() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowResourceStatisticsResponse">ShowResourceStatisticsResponse</a> & gpudb::GPUdb::showResourceStatistics </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1ShowResourceStatisticsRequest">ShowResourceStatisticsRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1ShowResourceStatisticsResponse">ShowResourceStatisticsResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Requests various statistics for storage/memory tiers and resource groups. </p>
        <p>Returns statistics on a per-rank basis.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowResourceStatisticsRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowResourceStatisticsResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowResourceStatisticsResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a85c91091e33a01bb10426de8d53a34c5">◆ </a></span>showResourceStatistics() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowResourceStatisticsResponse">ShowResourceStatisticsResponse</a> gpudb::GPUdb::showResourceStatistics </td>
            <td>(</td>
            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Requests various statistics for storage/memory tiers and resource groups. </p>
        <p>Returns statistics on a per-rank basis.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowResourceStatisticsResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ae3347291e4420eedba0bbd771b959e2b">◆ </a></span>showResourceStatistics() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowResourceStatisticsResponse">ShowResourceStatisticsResponse</a> & gpudb::GPUdb::showResourceStatistics </td>
            <td>(</td>
            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1ShowResourceStatisticsResponse">ShowResourceStatisticsResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Requests various statistics for storage/memory tiers and resource groups. </p>
        <p>Returns statistics on a per-rank basis.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowResourceStatisticsResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowResourceStatisticsResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a1cc194756eebfcbf911f60598b55daed">◆ </a></span>showSchema() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowSchemaResponse">ShowSchemaResponse</a> gpudb::GPUdb::showSchema </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1ShowSchemaRequest">ShowSchemaRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Retrieves information about a <a href="/content/concepts/schemas/">schema</a> (or all schemas), as specified in <a href="/content/api/cpp/structgpudb_1_1ShowSchemaRequest#ab426d3779701046c6ea78613c2593a35">schemaName</a>. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowSchemaRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowSchemaResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ad7de0c685fbf21daeea86231e8754ddc">◆ </a></span>showSchema() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowSchemaResponse">ShowSchemaResponse</a> & gpudb::GPUdb::showSchema </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1ShowSchemaRequest">ShowSchemaRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1ShowSchemaResponse">ShowSchemaResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Retrieves information about a <a href="/content/concepts/schemas/">schema</a> (or all schemas), as specified in <a href="/content/api/cpp/structgpudb_1_1ShowSchemaRequest#ab426d3779701046c6ea78613c2593a35">schemaName</a>. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowSchemaRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowSchemaResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowSchemaResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ab206730d8e790a566f5276653d609572">◆ </a></span>showSchema() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowSchemaResponse">ShowSchemaResponse</a> gpudb::GPUdb::showSchema </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>schemaName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Retrieves information about a <a href="/content/concepts/schemas/">schema</a> (or all schemas), as specified in <span>schemaName</span>. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>schemaName</td>
                <td>Name of the schema for which to retrieve the information. If blank, then info for all schemas is returned. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#af41f688d2e571fea39e93bcb1aae4f3e">show\_schema\_no\_error\_if\_not\_exists</a>: If <a href="/content/api/cpp/namespacegpudb#abc687a170852e53bc07b6563ba3b07f0">false</a> will return an error if the provided <span>schemaName</span> does not exist. If <a href="/content/api/cpp/namespacegpudb#a616d5dccf626e7832b98f554008408ac">true</a> then it will return an empty result if the provided <span>schemaName</span> does not exist. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a616d5dccf626e7832b98f554008408ac">show\_schema\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#abc687a170852e53bc07b6563ba3b07f0">show\_schema\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#abc687a170852e53bc07b6563ba3b07f0">show\_schema\_false</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowSchemaResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a77a202a439aa2b3af6f82368abf2fa34">◆ </a></span>showSchema() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowSchemaResponse">ShowSchemaResponse</a> & gpudb::GPUdb::showSchema </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>schemaName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1ShowSchemaResponse">ShowSchemaResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Retrieves information about a <a href="/content/concepts/schemas/">schema</a> (or all schemas), as specified in <span>schemaName</span>. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>schemaName</td>
                <td>Name of the schema for which to retrieve the information. If blank, then info for all schemas is returned. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#af41f688d2e571fea39e93bcb1aae4f3e">show\_schema\_no\_error\_if\_not\_exists</a>: If <a href="/content/api/cpp/namespacegpudb#abc687a170852e53bc07b6563ba3b07f0">false</a> will return an error if the provided <span>schemaName</span> does not exist. If <a href="/content/api/cpp/namespacegpudb#a616d5dccf626e7832b98f554008408ac">true</a> then it will return an empty result if the provided <span>schemaName</span> does not exist. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a616d5dccf626e7832b98f554008408ac">show\_schema\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#abc687a170852e53bc07b6563ba3b07f0">show\_schema\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#abc687a170852e53bc07b6563ba3b07f0">show\_schema\_false</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowSchemaResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowSchemaResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a40c433cf19b0cc02dea2b197924e5a22">◆ </a></span>showSecurity() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowSecurityResponse">ShowSecurityResponse</a> gpudb::GPUdb::showSecurity </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1ShowSecurityRequest">ShowSecurityRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Shows security information relating to users and/or roles. </p>
        <p>If the caller is not a system administrator, only information relating to the caller and their roles is returned.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowSecurityRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowSecurityResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ac04015d3b7c2003b2a428b29c5cdf47a">◆ </a></span>showSecurity() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowSecurityResponse">ShowSecurityResponse</a> & gpudb::GPUdb::showSecurity </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1ShowSecurityRequest">ShowSecurityRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1ShowSecurityResponse">ShowSecurityResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Shows security information relating to users and/or roles. </p>
        <p>If the caller is not a system administrator, only information relating to the caller and their roles is returned.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowSecurityRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowSecurityResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowSecurityResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#acca9c93b40c72ff151c7d8abb60c59af">◆ </a></span>showSecurity() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowSecurityResponse">ShowSecurityResponse</a> gpudb::GPUdb::showSecurity </td>
            <td>(</td>
            <td>const std::vector\< std::string > &</td>
            <td><span><span>names</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Shows security information relating to users and/or roles. </p>
        <p>If the caller is not a system administrator, only information relating to the caller and their roles is returned.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>names</td>
                <td>A list of names of users and/or roles about which security information is requested. If none are provided, information about all users and roles will be returned. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a3c94f8f210d7fb5a32bf4facb02b0ca8">show\_security\_show\_current\_user</a>: If <a href="/content/api/cpp/namespacegpudb#ae3ada38970a156ce4d085be047d436b0">true</a>, returns only security information for the current user. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ae3ada38970a156ce4d085be047d436b0">show\_security\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aaa39aa054ac5b23243b497332c1a0dbf">show\_security\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#aaa39aa054ac5b23243b497332c1a0dbf">show\_security\_false</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowSecurityResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ab8545998de2f9115da768db51cabf7f7">◆ </a></span>showSecurity() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowSecurityResponse">ShowSecurityResponse</a> & gpudb::GPUdb::showSecurity </td>
            <td>(</td>
            <td>const std::vector\< std::string > &</td>
            <td><span><span>names</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1ShowSecurityResponse">ShowSecurityResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Shows security information relating to users and/or roles. </p>
        <p>If the caller is not a system administrator, only information relating to the caller and their roles is returned.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>names</td>
                <td>A list of names of users and/or roles about which security information is requested. If none are provided, information about all users and roles will be returned. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a3c94f8f210d7fb5a32bf4facb02b0ca8">show\_security\_show\_current\_user</a>: If <a href="/content/api/cpp/namespacegpudb#ae3ada38970a156ce4d085be047d436b0">true</a>, returns only security information for the current user. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ae3ada38970a156ce4d085be047d436b0">show\_security\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aaa39aa054ac5b23243b497332c1a0dbf">show\_security\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#aaa39aa054ac5b23243b497332c1a0dbf">show\_security\_false</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowSecurityResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowSecurityResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#af1e1e90f76a43c60220ad2ffa008f4af">◆ </a></span>showSqlProc() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowSqlProcResponse">ShowSqlProcResponse</a> gpudb::GPUdb::showSqlProc </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1ShowSqlProcRequest">ShowSqlProcRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Shows information about SQL procedures, including the full definition of each requested procedure. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowSqlProcRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowSqlProcResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a9dffef865f8df9bac7ed947e80d58c66">◆ </a></span>showSqlProc() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowSqlProcResponse">ShowSqlProcResponse</a> & gpudb::GPUdb::showSqlProc </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1ShowSqlProcRequest">ShowSqlProcRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1ShowSqlProcResponse">ShowSqlProcResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Shows information about SQL procedures, including the full definition of each requested procedure. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowSqlProcRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowSqlProcResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowSqlProcResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a13c04a3cae289ef769af2244f913e27c">◆ </a></span>showSqlProc() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowSqlProcResponse">ShowSqlProcResponse</a> gpudb::GPUdb::showSqlProc </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>procedureName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Shows information about SQL procedures, including the full definition of each requested procedure. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>procedureName</td>
                <td>Name of the procedure for which to retrieve the information. If blank, then information about all procedures is returned. The default value is ''. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ac6840c1d5c408c26e9808e761d5d2c85">show\_sql\_proc\_no\_error\_if\_not\_exists</a>: If <a href="/content/api/cpp/namespacegpudb#a3e2a2936461449f8d5b83cd62be74f72">true</a>, no error will be returned if the requested procedure does not exist. If <a href="/content/api/cpp/namespacegpudb#a12d6012a5d73862589b8cb18ec7a6366">false</a>, an error will be returned if the requested procedure does not exist. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a3e2a2936461449f8d5b83cd62be74f72">show\_sql\_proc\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a12d6012a5d73862589b8cb18ec7a6366">show\_sql\_proc\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a12d6012a5d73862589b8cb18ec7a6366">show\_sql\_proc\_false</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowSqlProcResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#aff1be35f1f720165261c4128beaa9cae">◆ </a></span>showSqlProc() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowSqlProcResponse">ShowSqlProcResponse</a> & gpudb::GPUdb::showSqlProc </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>procedureName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1ShowSqlProcResponse">ShowSqlProcResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Shows information about SQL procedures, including the full definition of each requested procedure. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>procedureName</td>
                <td>Name of the procedure for which to retrieve the information. If blank, then information about all procedures is returned. The default value is ''. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ac6840c1d5c408c26e9808e761d5d2c85">show\_sql\_proc\_no\_error\_if\_not\_exists</a>: If <a href="/content/api/cpp/namespacegpudb#a3e2a2936461449f8d5b83cd62be74f72">true</a>, no error will be returned if the requested procedure does not exist. If <a href="/content/api/cpp/namespacegpudb#a12d6012a5d73862589b8cb18ec7a6366">false</a>, an error will be returned if the requested procedure does not exist. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a3e2a2936461449f8d5b83cd62be74f72">show\_sql\_proc\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a12d6012a5d73862589b8cb18ec7a6366">show\_sql\_proc\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a12d6012a5d73862589b8cb18ec7a6366">show\_sql\_proc\_false</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowSqlProcResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowSqlProcResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a9f383f90577358cd07abe30ddf79295f">◆ </a></span>showStatistics() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowStatisticsResponse">ShowStatisticsResponse</a> gpudb::GPUdb::showStatistics </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1ShowStatisticsRequest">ShowStatisticsRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Retrieves the collected column statistics for the specified table(s). </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowStatisticsRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowStatisticsResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#abc0302b8710c3ee9fe443f7ab5c57d22">◆ </a></span>showStatistics() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowStatisticsResponse">ShowStatisticsResponse</a> & gpudb::GPUdb::showStatistics </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1ShowStatisticsRequest">ShowStatisticsRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1ShowStatisticsResponse">ShowStatisticsResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Retrieves the collected column statistics for the specified table(s). </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowStatisticsRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowStatisticsResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowStatisticsResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a718f8538f41b0877f1d3c998ec263bf9">◆ </a></span>showStatistics() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowStatisticsResponse">ShowStatisticsResponse</a> gpudb::GPUdb::showStatistics </td>
            <td>(</td>
            <td>const std::vector\< std::string > &</td>
            <td><span><span>tableNames</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Retrieves the collected column statistics for the specified table(s). </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableNames</td>
                <td>Names of tables whose metadata will be fetched, each in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. All provided tables must exist, or an error is returned. A single entry of '\*' expands to every user table the caller may read (excluding system schemas, views, and temporary tables); when used it must be the only entry. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a7d76a95c1fb5ee220e049f6334be9696">show\_statistics\_no\_error\_if\_not\_exists</a>: If <a href="/content/api/cpp/namespacegpudb#a83d9cb34ce94fe40114b20cb32748eb7">true</a> and if the table names specified in <span>tableNames</span> does not exist, no error is returned. If <a href="/content/api/cpp/namespacegpudb#a42cedb45be89e7b0b659b4f55e70fccc">false</a> and if the table names specified in <span>tableNames</span> does not exist, then an error is returned. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a83d9cb34ce94fe40114b20cb32748eb7">show\_statistics\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a42cedb45be89e7b0b659b4f55e70fccc">show\_statistics\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a42cedb45be89e7b0b659b4f55e70fccc">show\_statistics\_false</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowStatisticsResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a7b33126532757e9abfabcd9fbdc8982d">◆ </a></span>showStatistics() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowStatisticsResponse">ShowStatisticsResponse</a> & gpudb::GPUdb::showStatistics </td>
            <td>(</td>
            <td>const std::vector\< std::string > &</td>
            <td><span><span>tableNames</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1ShowStatisticsResponse">ShowStatisticsResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Retrieves the collected column statistics for the specified table(s). </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableNames</td>
                <td>Names of tables whose metadata will be fetched, each in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. All provided tables must exist, or an error is returned. A single entry of '\*' expands to every user table the caller may read (excluding system schemas, views, and temporary tables); when used it must be the only entry. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a7d76a95c1fb5ee220e049f6334be9696">show\_statistics\_no\_error\_if\_not\_exists</a>: If <a href="/content/api/cpp/namespacegpudb#a83d9cb34ce94fe40114b20cb32748eb7">true</a> and if the table names specified in <span>tableNames</span> does not exist, no error is returned. If <a href="/content/api/cpp/namespacegpudb#a42cedb45be89e7b0b659b4f55e70fccc">false</a> and if the table names specified in <span>tableNames</span> does not exist, then an error is returned. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a83d9cb34ce94fe40114b20cb32748eb7">show\_statistics\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a42cedb45be89e7b0b659b4f55e70fccc">show\_statistics\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a42cedb45be89e7b0b659b4f55e70fccc">show\_statistics\_false</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowStatisticsResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowStatisticsResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a84ab8280203e0c3868f29de4991685ac">◆ </a></span>showSystemProperties() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowSystemPropertiesResponse">ShowSystemPropertiesResponse</a> gpudb::GPUdb::showSystemProperties </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1ShowSystemPropertiesRequest">ShowSystemPropertiesRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Returns server configuration and version related information to the caller. </p>
        <p>The admin tool uses it to present server related information to the user.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowSystemPropertiesRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowSystemPropertiesResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#aa352ba53bf874da1241d2ad175c7b7fd">◆ </a></span>showSystemProperties() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowSystemPropertiesResponse">ShowSystemPropertiesResponse</a> & gpudb::GPUdb::showSystemProperties </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1ShowSystemPropertiesRequest">ShowSystemPropertiesRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1ShowSystemPropertiesResponse">ShowSystemPropertiesResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Returns server configuration and version related information to the caller. </p>
        <p>The admin tool uses it to present server related information to the user.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowSystemPropertiesRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowSystemPropertiesResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowSystemPropertiesResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a784bbdd03c35b32dbf2568f7bf46b27f">◆ </a></span>showSystemProperties() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowSystemPropertiesResponse">ShowSystemPropertiesResponse</a> gpudb::GPUdb::showSystemProperties </td>
            <td>(</td>
            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Returns server configuration and version related information to the caller. </p>
        <p>The admin tool uses it to present server related information to the user.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a3a5b23fcf4ad5693d2fba93bcb092a92">show\_system\_properties\_properties</a>: A list of comma separated names of properties requested. If not specified, all properties will be returned. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowSystemPropertiesResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#aab5ac92b58d7dbe03522426356852b24">◆ </a></span>showSystemProperties() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowSystemPropertiesResponse">ShowSystemPropertiesResponse</a> & gpudb::GPUdb::showSystemProperties </td>
            <td>(</td>
            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1ShowSystemPropertiesResponse">ShowSystemPropertiesResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Returns server configuration and version related information to the caller. </p>
        <p>The admin tool uses it to present server related information to the user.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a3a5b23fcf4ad5693d2fba93bcb092a92">show\_system\_properties\_properties</a>: A list of comma separated names of properties requested. If not specified, all properties will be returned. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowSystemPropertiesResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowSystemPropertiesResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#abe9a7d6ea3fe0b154d73b86955db53cb">◆ </a></span>showSystemStatus() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowSystemStatusResponse">ShowSystemStatusResponse</a> gpudb::GPUdb::showSystemStatus </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1ShowSystemStatusRequest">ShowSystemStatusRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Provides server configuration and health related status to the caller. </p>
        <p>The admin tool uses it to present server related information to the user.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowSystemStatusRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowSystemStatusResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ad8ee4fa96d9c29267f56698dc165c2a3">◆ </a></span>showSystemStatus() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowSystemStatusResponse">ShowSystemStatusResponse</a> & gpudb::GPUdb::showSystemStatus </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1ShowSystemStatusRequest">ShowSystemStatusRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1ShowSystemStatusResponse">ShowSystemStatusResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Provides server configuration and health related status to the caller. </p>
        <p>The admin tool uses it to present server related information to the user.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowSystemStatusRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowSystemStatusResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowSystemStatusResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a2cc190f96524c44227af5731319ad4e1">◆ </a></span>showSystemStatus() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowSystemStatusResponse">ShowSystemStatusResponse</a> gpudb::GPUdb::showSystemStatus </td>
            <td>(</td>
            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Provides server configuration and health related status to the caller. </p>
        <p>The admin tool uses it to present server related information to the user.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters, currently unused. The default value is an empty map.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowSystemStatusResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#acd8fa09150dd778c2890357d220c451f">◆ </a></span>showSystemStatus() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowSystemStatusResponse">ShowSystemStatusResponse</a> & gpudb::GPUdb::showSystemStatus </td>
            <td>(</td>
            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1ShowSystemStatusResponse">ShowSystemStatusResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Provides server configuration and health related status to the caller. </p>
        <p>The admin tool uses it to present server related information to the user.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters, currently unused. The default value is an empty map. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowSystemStatusResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowSystemStatusResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a98058f80289f0cb4fcc381db5f43a54f">◆ </a></span>showSystemTiming() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowSystemTimingResponse">ShowSystemTimingResponse</a> gpudb::GPUdb::showSystemTiming </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1ShowSystemTimingRequest">ShowSystemTimingRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Returns the last 100 database requests along with the request timing and internal job ID. </p>
        <p>The admin tool uses it to present request timing information to the user.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowSystemTimingRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowSystemTimingResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#abed19734233489426cb907a2ff00e40c">◆ </a></span>showSystemTiming() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowSystemTimingResponse">ShowSystemTimingResponse</a> & gpudb::GPUdb::showSystemTiming </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1ShowSystemTimingRequest">ShowSystemTimingRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1ShowSystemTimingResponse">ShowSystemTimingResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Returns the last 100 database requests along with the request timing and internal job ID. </p>
        <p>The admin tool uses it to present request timing information to the user.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowSystemTimingRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowSystemTimingResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowSystemTimingResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ae4f171b4c997ea2b72b898f436395e64">◆ </a></span>showSystemTiming() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowSystemTimingResponse">ShowSystemTimingResponse</a> gpudb::GPUdb::showSystemTiming </td>
            <td>(</td>
            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Returns the last 100 database requests along with the request timing and internal job ID. </p>
        <p>The admin tool uses it to present request timing information to the user.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters, currently unused. The default value is an empty map.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowSystemTimingResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#abfc55faedf2820f296f12dab7b62cb55">◆ </a></span>showSystemTiming() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowSystemTimingResponse">ShowSystemTimingResponse</a> & gpudb::GPUdb::showSystemTiming </td>
            <td>(</td>
            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1ShowSystemTimingResponse">ShowSystemTimingResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Returns the last 100 database requests along with the request timing and internal job ID. </p>
        <p>The admin tool uses it to present request timing information to the user.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters, currently unused. The default value is an empty map. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowSystemTimingResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowSystemTimingResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ae446b45c99e9b4afa26726bce8ad23cc">◆ </a></span>showTable() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowTableResponse">ShowTableResponse</a> gpudb::GPUdb::showTable </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1ShowTableRequest">ShowTableRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Retrieves detailed information about a table, view, or schema, specified in <a href="/content/api/cpp/structgpudb_1_1ShowTableRequest#a4b7e6b1e0720e0453914de2e455d9b8e">tableName</a>. </p>
        <p>If the supplied <a href="/content/api/cpp/structgpudb_1_1ShowTableRequest#a4b7e6b1e0720e0453914de2e455d9b8e">tableName</a> is a schema the call can return information about either the schema itself or the tables and views it contains. If <a href="/content/api/cpp/structgpudb_1_1ShowTableRequest#a4b7e6b1e0720e0453914de2e455d9b8e">tableName</a> is empty, information about all schemas will be returned.</p>
        <p>If the option <a href="/content/api/cpp/namespacegpudb#a08e495592c514c3cb43220410cb8e8f1">get\_sizes</a> is set to <a href="/content/api/cpp/namespacegpudb#ad1805831e61943d412b1cba8ac9a35bb">true</a>, then the number of records in each table is returned (in <a href="/content/api/cpp/structgpudb_1_1ShowTableResponse#ac974c9256b30169d9ec3ec62eeb3c36a">sizes</a> and <a href="/content/api/cpp/structgpudb_1_1ShowTableResponse#afd86694abebad6e0da3659d7a80193f6">fullSizes</a>), along with the total number of objects across all requested tables (in <a href="/content/api/cpp/structgpudb_1_1ShowTableResponse#a8807aae341abb63dc99cc034324e29e8">totalSize</a> and <a href="/content/api/cpp/structgpudb_1_1ShowTableResponse#a018a4b950c65fe2365d8267b29d87694">totalFullSize</a>).</p>
        <p>For a schema, setting the <a href="/content/api/cpp/namespacegpudb#a2050a78788d443270f69a5e04d7f67c2">show\_children</a> option to <a href="/content/api/cpp/namespacegpudb#a4269fa8dff6b16d80aa3b46b2b83ac17">false</a> returns only information about the schema itself; setting <a href="/content/api/cpp/namespacegpudb#a2050a78788d443270f69a5e04d7f67c2">show\_children</a> to <a href="/content/api/cpp/namespacegpudb#ad1805831e61943d412b1cba8ac9a35bb">true</a> returns a list of tables and views contained in the schema, along with their corresponding detail.</p>
        <p>To retrieve a list of every table, view, and schema in the database, set <a href="/content/api/cpp/structgpudb_1_1ShowTableRequest#a4b7e6b1e0720e0453914de2e455d9b8e">tableName</a> to '\*' and <a href="/content/api/cpp/namespacegpudb#a2050a78788d443270f69a5e04d7f67c2">show\_children</a> to <a href="/content/api/cpp/namespacegpudb#ad1805831e61943d412b1cba8ac9a35bb">true</a>. When doing this, the returned <a href="/content/api/cpp/structgpudb_1_1ShowTableResponse#a8807aae341abb63dc99cc034324e29e8">totalSize</a> and <a href="/content/api/cpp/structgpudb_1_1ShowTableResponse#a018a4b950c65fe2365d8267b29d87694">totalFullSize</a> will not include the sizes of non-base tables (e.g., filters, views, joins, etc.).</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowTableRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowTableResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a7335f652dfe78271639dffd37424e279">◆ </a></span>showTable() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowTableResponse">ShowTableResponse</a> & gpudb::GPUdb::showTable </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1ShowTableRequest">ShowTableRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1ShowTableResponse">ShowTableResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Retrieves detailed information about a table, view, or schema, specified in <a href="/content/api/cpp/structgpudb_1_1ShowTableRequest#a4b7e6b1e0720e0453914de2e455d9b8e">tableName</a>. </p>
        <p>If the supplied <a href="/content/api/cpp/structgpudb_1_1ShowTableRequest#a4b7e6b1e0720e0453914de2e455d9b8e">tableName</a> is a schema the call can return information about either the schema itself or the tables and views it contains. If <a href="/content/api/cpp/structgpudb_1_1ShowTableRequest#a4b7e6b1e0720e0453914de2e455d9b8e">tableName</a> is empty, information about all schemas will be returned.</p>
        <p>If the option <a href="/content/api/cpp/namespacegpudb#a08e495592c514c3cb43220410cb8e8f1">get\_sizes</a> is set to <a href="/content/api/cpp/namespacegpudb#ad1805831e61943d412b1cba8ac9a35bb">true</a>, then the number of records in each table is returned (in <a href="/content/api/cpp/structgpudb_1_1ShowTableResponse#ac974c9256b30169d9ec3ec62eeb3c36a">sizes</a> and <a href="/content/api/cpp/structgpudb_1_1ShowTableResponse#afd86694abebad6e0da3659d7a80193f6">fullSizes</a>), along with the total number of objects across all requested tables (in <a href="/content/api/cpp/structgpudb_1_1ShowTableResponse#a8807aae341abb63dc99cc034324e29e8">totalSize</a> and <a href="/content/api/cpp/structgpudb_1_1ShowTableResponse#a018a4b950c65fe2365d8267b29d87694">totalFullSize</a>).</p>
        <p>For a schema, setting the <a href="/content/api/cpp/namespacegpudb#a2050a78788d443270f69a5e04d7f67c2">show\_children</a> option to <a href="/content/api/cpp/namespacegpudb#a4269fa8dff6b16d80aa3b46b2b83ac17">false</a> returns only information about the schema itself; setting <a href="/content/api/cpp/namespacegpudb#a2050a78788d443270f69a5e04d7f67c2">show\_children</a> to <a href="/content/api/cpp/namespacegpudb#ad1805831e61943d412b1cba8ac9a35bb">true</a> returns a list of tables and views contained in the schema, along with their corresponding detail.</p>
        <p>To retrieve a list of every table, view, and schema in the database, set <a href="/content/api/cpp/structgpudb_1_1ShowTableRequest#a4b7e6b1e0720e0453914de2e455d9b8e">tableName</a> to '\*' and <a href="/content/api/cpp/namespacegpudb#a2050a78788d443270f69a5e04d7f67c2">show\_children</a> to <a href="/content/api/cpp/namespacegpudb#ad1805831e61943d412b1cba8ac9a35bb">true</a>. When doing this, the returned <a href="/content/api/cpp/structgpudb_1_1ShowTableResponse#a8807aae341abb63dc99cc034324e29e8">totalSize</a> and <a href="/content/api/cpp/structgpudb_1_1ShowTableResponse#a018a4b950c65fe2365d8267b29d87694">totalFullSize</a> will not include the sizes of non-base tables (e.g., filters, views, joins, etc.).</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowTableRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowTableResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowTableResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a0ba64d599891431a9d2aff56dca5a9ab">◆ </a></span>showTable() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowTableResponse">ShowTableResponse</a> gpudb::GPUdb::showTable </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Retrieves detailed information about a table, view, or schema, specified in <span>tableName</span>. </p>
        <p>If the supplied <span>tableName</span> is a schema the call can return information about either the schema itself or the tables and views it contains. If <span>tableName</span> is empty, information about all schemas will be returned.</p>
        <p>If the option <a href="/content/api/cpp/namespacegpudb#a08e495592c514c3cb43220410cb8e8f1">get\_sizes</a> is set to <a href="/content/api/cpp/namespacegpudb#ad1805831e61943d412b1cba8ac9a35bb">true</a>, then the number of records in each table is returned (in <a href="/content/api/cpp/structgpudb_1_1ShowTableResponse#ac974c9256b30169d9ec3ec62eeb3c36a">sizes</a> and <a href="/content/api/cpp/structgpudb_1_1ShowTableResponse#afd86694abebad6e0da3659d7a80193f6">fullSizes</a>), along with the total number of objects across all requested tables (in <a href="/content/api/cpp/structgpudb_1_1ShowTableResponse#a8807aae341abb63dc99cc034324e29e8">totalSize</a> and <a href="/content/api/cpp/structgpudb_1_1ShowTableResponse#a018a4b950c65fe2365d8267b29d87694">totalFullSize</a>).</p>
        <p>For a schema, setting the <a href="/content/api/cpp/namespacegpudb#a2050a78788d443270f69a5e04d7f67c2">show\_children</a> option to <a href="/content/api/cpp/namespacegpudb#a4269fa8dff6b16d80aa3b46b2b83ac17">false</a> returns only information about the schema itself; setting <a href="/content/api/cpp/namespacegpudb#a2050a78788d443270f69a5e04d7f67c2">show\_children</a> to <a href="/content/api/cpp/namespacegpudb#ad1805831e61943d412b1cba8ac9a35bb">true</a> returns a list of tables and views contained in the schema, along with their corresponding detail.</p>
        <p>To retrieve a list of every table, view, and schema in the database, set <span>tableName</span> to '\*' and <a href="/content/api/cpp/namespacegpudb#a2050a78788d443270f69a5e04d7f67c2">show\_children</a> to <a href="/content/api/cpp/namespacegpudb#ad1805831e61943d412b1cba8ac9a35bb">true</a>. When doing this, the returned <a href="/content/api/cpp/structgpudb_1_1ShowTableResponse#a8807aae341abb63dc99cc034324e29e8">totalSize</a> and <a href="/content/api/cpp/structgpudb_1_1ShowTableResponse#a018a4b950c65fe2365d8267b29d87694">totalFullSize</a> will not include the sizes of non-base tables (e.g., filters, views, joins, etc.).</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of the table for which to retrieve the information, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. If blank, then returns information about all tables and views. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a735630dad9efd53c31b0b0fa52ae1ad1">show\_table\_dependencies</a>: Include view dependencies in the output. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad1805831e61943d412b1cba8ac9a35bb">show\_table\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a4269fa8dff6b16d80aa3b46b2b83ac17">show\_table\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a4269fa8dff6b16d80aa3b46b2b83ac17">show\_table\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#abd45e351002cdc18070124420e622613">show\_table\_force\_synchronous</a>: If <a href="/content/api/cpp/namespacegpudb#ad1805831e61943d412b1cba8ac9a35bb">true</a> then the table sizes will wait for read lock before returning. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad1805831e61943d412b1cba8ac9a35bb">show\_table\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a4269fa8dff6b16d80aa3b46b2b83ac17">show\_table\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ad1805831e61943d412b1cba8ac9a35bb">show\_table\_true</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a4887573e85d4f28b7cc65d6b749ca916">show\_table\_get\_access\_data</a>: If <a href="/content/api/cpp/namespacegpudb#ad1805831e61943d412b1cba8ac9a35bb">true</a> then data about the last read, write, alter and create will be returned. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad1805831e61943d412b1cba8ac9a35bb">show\_table\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a4269fa8dff6b16d80aa3b46b2b83ac17">show\_table\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a4269fa8dff6b16d80aa3b46b2b83ac17">show\_table\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#af46b7d7cfe0ac4e0c7684c38a05ca8bb">show\_table\_get\_cached\_sizes</a>: If <a href="/content/api/cpp/namespacegpudb#ad1805831e61943d412b1cba8ac9a35bb">true</a> then the number of records in each table, along with a cumulative count, will be returned; blank, otherwise. This version will return the sizes cached at rank 0, which may be stale if there is a multihead insert occurring. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad1805831e61943d412b1cba8ac9a35bb">show\_table\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a4269fa8dff6b16d80aa3b46b2b83ac17">show\_table\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a4269fa8dff6b16d80aa3b46b2b83ac17">show\_table\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a08e495592c514c3cb43220410cb8e8f1">show\_table\_get\_sizes</a>: If <a href="/content/api/cpp/namespacegpudb#ad1805831e61943d412b1cba8ac9a35bb">true</a> then the number of records in each table, along with a cumulative count, will be returned; blank, otherwise. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad1805831e61943d412b1cba8ac9a35bb">show\_table\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a4269fa8dff6b16d80aa3b46b2b83ac17">show\_table\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a4269fa8dff6b16d80aa3b46b2b83ac17">show\_table\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a20222de151678b742be3a6813ae4391b">show\_table\_referencing\_materialized\_views</a>: Include materialized views using this table as a source in the output. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad1805831e61943d412b1cba8ac9a35bb">show\_table\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a4269fa8dff6b16d80aa3b46b2b83ac17">show\_table\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a4269fa8dff6b16d80aa3b46b2b83ac17">show\_table\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a9687184475da56c512706aa32bded1e4">show\_table\_skip\_additional\_info</a>: If <a href="/content/api/cpp/namespacegpudb#ad1805831e61943d412b1cba8ac9a35bb">true</a> then the response will not populate the additional\_info field. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad1805831e61943d412b1cba8ac9a35bb">show\_table\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a4269fa8dff6b16d80aa3b46b2b83ac17">show\_table\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a4269fa8dff6b16d80aa3b46b2b83ac17">show\_table\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#adfe860ba6674377154ea7638965ab8ff">show\_table\_no\_error\_if\_not\_exists</a>: If <a href="/content/api/cpp/namespacegpudb#a4269fa8dff6b16d80aa3b46b2b83ac17">false</a> will return an error if the provided <span>tableName</span> does not exist. If <a href="/content/api/cpp/namespacegpudb#ad1805831e61943d412b1cba8ac9a35bb">true</a> then it will return an empty result. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad1805831e61943d412b1cba8ac9a35bb">show\_table\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a4269fa8dff6b16d80aa3b46b2b83ac17">show\_table\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a4269fa8dff6b16d80aa3b46b2b83ac17">show\_table\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#acd4480b6f7845086f4ebd787cc2f3038">show\_table\_skip\_temp\_schemas</a>: If <a href="/content/api/cpp/namespacegpudb#ad1805831e61943d412b1cba8ac9a35bb">true</a> then the table list will not include tables from SYS\_TEMP and other system temporary schemas. This is the default behavior for non-admin users. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad1805831e61943d412b1cba8ac9a35bb">show\_table\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a4269fa8dff6b16d80aa3b46b2b83ac17">show\_table\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a4269fa8dff6b16d80aa3b46b2b83ac17">show\_table\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a2050a78788d443270f69a5e04d7f67c2">show\_table\_show\_children</a>: If <span>tableName</span> is a schema, then <a href="/content/api/cpp/namespacegpudb#ad1805831e61943d412b1cba8ac9a35bb">true</a> will return information about the tables and views in the schema, and <a href="/content/api/cpp/namespacegpudb#a4269fa8dff6b16d80aa3b46b2b83ac17">false</a> will return information about the schema itself. If <span>tableName</span> is a table or view, <a href="/content/api/cpp/namespacegpudb#a2050a78788d443270f69a5e04d7f67c2">show\_children</a> must be <a href="/content/api/cpp/namespacegpudb#a4269fa8dff6b16d80aa3b46b2b83ac17">false</a>. If <span>tableName</span> is empty, then <a href="/content/api/cpp/namespacegpudb#a2050a78788d443270f69a5e04d7f67c2">show\_children</a> must be <a href="/content/api/cpp/namespacegpudb#ad1805831e61943d412b1cba8ac9a35bb">true</a>. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad1805831e61943d412b1cba8ac9a35bb">show\_table\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a4269fa8dff6b16d80aa3b46b2b83ac17">show\_table\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ad1805831e61943d412b1cba8ac9a35bb">show\_table\_true</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a16da9c4b995d47af198c8ad820432a6c">show\_table\_get\_column\_info</a>: If <a href="/content/api/cpp/namespacegpudb#ad1805831e61943d412b1cba8ac9a35bb">true</a> then column info (memory usage, etc) will be returned. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad1805831e61943d412b1cba8ac9a35bb">show\_table\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a4269fa8dff6b16d80aa3b46b2b83ac17">show\_table\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a4269fa8dff6b16d80aa3b46b2b83ac17">show\_table\_false</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowTableResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a9af84c2e52f527a087c8153eabb8ee89">◆ </a></span>showTable() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowTableResponse">ShowTableResponse</a> & gpudb::GPUdb::showTable </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1ShowTableResponse">ShowTableResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Retrieves detailed information about a table, view, or schema, specified in <span>tableName</span>. </p>
        <p>If the supplied <span>tableName</span> is a schema the call can return information about either the schema itself or the tables and views it contains. If <span>tableName</span> is empty, information about all schemas will be returned.</p>
        <p>If the option <a href="/content/api/cpp/namespacegpudb#a08e495592c514c3cb43220410cb8e8f1">get\_sizes</a> is set to <a href="/content/api/cpp/namespacegpudb#ad1805831e61943d412b1cba8ac9a35bb">true</a>, then the number of records in each table is returned (in <a href="/content/api/cpp/structgpudb_1_1ShowTableResponse#ac974c9256b30169d9ec3ec62eeb3c36a">sizes</a> and <a href="/content/api/cpp/structgpudb_1_1ShowTableResponse#afd86694abebad6e0da3659d7a80193f6">fullSizes</a>), along with the total number of objects across all requested tables (in <a href="/content/api/cpp/structgpudb_1_1ShowTableResponse#a8807aae341abb63dc99cc034324e29e8">totalSize</a> and <a href="/content/api/cpp/structgpudb_1_1ShowTableResponse#a018a4b950c65fe2365d8267b29d87694">totalFullSize</a>).</p>
        <p>For a schema, setting the <a href="/content/api/cpp/namespacegpudb#a2050a78788d443270f69a5e04d7f67c2">show\_children</a> option to <a href="/content/api/cpp/namespacegpudb#a4269fa8dff6b16d80aa3b46b2b83ac17">false</a> returns only information about the schema itself; setting <a href="/content/api/cpp/namespacegpudb#a2050a78788d443270f69a5e04d7f67c2">show\_children</a> to <a href="/content/api/cpp/namespacegpudb#ad1805831e61943d412b1cba8ac9a35bb">true</a> returns a list of tables and views contained in the schema, along with their corresponding detail.</p>
        <p>To retrieve a list of every table, view, and schema in the database, set <span>tableName</span> to '\*' and <a href="/content/api/cpp/namespacegpudb#a2050a78788d443270f69a5e04d7f67c2">show\_children</a> to <a href="/content/api/cpp/namespacegpudb#ad1805831e61943d412b1cba8ac9a35bb">true</a>. When doing this, the returned <a href="/content/api/cpp/structgpudb_1_1ShowTableResponse#a8807aae341abb63dc99cc034324e29e8">totalSize</a> and <a href="/content/api/cpp/structgpudb_1_1ShowTableResponse#a018a4b950c65fe2365d8267b29d87694">totalFullSize</a> will not include the sizes of non-base tables (e.g., filters, views, joins, etc.).</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of the table for which to retrieve the information, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. If blank, then returns information about all tables and views. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a735630dad9efd53c31b0b0fa52ae1ad1">show\_table\_dependencies</a>: Include view dependencies in the output. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad1805831e61943d412b1cba8ac9a35bb">show\_table\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a4269fa8dff6b16d80aa3b46b2b83ac17">show\_table\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a4269fa8dff6b16d80aa3b46b2b83ac17">show\_table\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#abd45e351002cdc18070124420e622613">show\_table\_force\_synchronous</a>: If <a href="/content/api/cpp/namespacegpudb#ad1805831e61943d412b1cba8ac9a35bb">true</a> then the table sizes will wait for read lock before returning. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad1805831e61943d412b1cba8ac9a35bb">show\_table\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a4269fa8dff6b16d80aa3b46b2b83ac17">show\_table\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ad1805831e61943d412b1cba8ac9a35bb">show\_table\_true</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a4887573e85d4f28b7cc65d6b749ca916">show\_table\_get\_access\_data</a>: If <a href="/content/api/cpp/namespacegpudb#ad1805831e61943d412b1cba8ac9a35bb">true</a> then data about the last read, write, alter and create will be returned. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad1805831e61943d412b1cba8ac9a35bb">show\_table\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a4269fa8dff6b16d80aa3b46b2b83ac17">show\_table\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a4269fa8dff6b16d80aa3b46b2b83ac17">show\_table\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#af46b7d7cfe0ac4e0c7684c38a05ca8bb">show\_table\_get\_cached\_sizes</a>: If <a href="/content/api/cpp/namespacegpudb#ad1805831e61943d412b1cba8ac9a35bb">true</a> then the number of records in each table, along with a cumulative count, will be returned; blank, otherwise. This version will return the sizes cached at rank 0, which may be stale if there is a multihead insert occurring. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad1805831e61943d412b1cba8ac9a35bb">show\_table\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a4269fa8dff6b16d80aa3b46b2b83ac17">show\_table\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a4269fa8dff6b16d80aa3b46b2b83ac17">show\_table\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a08e495592c514c3cb43220410cb8e8f1">show\_table\_get\_sizes</a>: If <a href="/content/api/cpp/namespacegpudb#ad1805831e61943d412b1cba8ac9a35bb">true</a> then the number of records in each table, along with a cumulative count, will be returned; blank, otherwise. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad1805831e61943d412b1cba8ac9a35bb">show\_table\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a4269fa8dff6b16d80aa3b46b2b83ac17">show\_table\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a4269fa8dff6b16d80aa3b46b2b83ac17">show\_table\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a20222de151678b742be3a6813ae4391b">show\_table\_referencing\_materialized\_views</a>: Include materialized views using this table as a source in the output. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad1805831e61943d412b1cba8ac9a35bb">show\_table\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a4269fa8dff6b16d80aa3b46b2b83ac17">show\_table\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a4269fa8dff6b16d80aa3b46b2b83ac17">show\_table\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a9687184475da56c512706aa32bded1e4">show\_table\_skip\_additional\_info</a>: If <a href="/content/api/cpp/namespacegpudb#ad1805831e61943d412b1cba8ac9a35bb">true</a> then the response will not populate the additional\_info field. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad1805831e61943d412b1cba8ac9a35bb">show\_table\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a4269fa8dff6b16d80aa3b46b2b83ac17">show\_table\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a4269fa8dff6b16d80aa3b46b2b83ac17">show\_table\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#adfe860ba6674377154ea7638965ab8ff">show\_table\_no\_error\_if\_not\_exists</a>: If <a href="/content/api/cpp/namespacegpudb#a4269fa8dff6b16d80aa3b46b2b83ac17">false</a> will return an error if the provided <span>tableName</span> does not exist. If <a href="/content/api/cpp/namespacegpudb#ad1805831e61943d412b1cba8ac9a35bb">true</a> then it will return an empty result. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad1805831e61943d412b1cba8ac9a35bb">show\_table\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a4269fa8dff6b16d80aa3b46b2b83ac17">show\_table\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a4269fa8dff6b16d80aa3b46b2b83ac17">show\_table\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#acd4480b6f7845086f4ebd787cc2f3038">show\_table\_skip\_temp\_schemas</a>: If <a href="/content/api/cpp/namespacegpudb#ad1805831e61943d412b1cba8ac9a35bb">true</a> then the table list will not include tables from SYS\_TEMP and other system temporary schemas. This is the default behavior for non-admin users. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad1805831e61943d412b1cba8ac9a35bb">show\_table\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a4269fa8dff6b16d80aa3b46b2b83ac17">show\_table\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a4269fa8dff6b16d80aa3b46b2b83ac17">show\_table\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a2050a78788d443270f69a5e04d7f67c2">show\_table\_show\_children</a>: If <span>tableName</span> is a schema, then <a href="/content/api/cpp/namespacegpudb#ad1805831e61943d412b1cba8ac9a35bb">true</a> will return information about the tables and views in the schema, and <a href="/content/api/cpp/namespacegpudb#a4269fa8dff6b16d80aa3b46b2b83ac17">false</a> will return information about the schema itself. If <span>tableName</span> is a table or view, <a href="/content/api/cpp/namespacegpudb#a2050a78788d443270f69a5e04d7f67c2">show\_children</a> must be <a href="/content/api/cpp/namespacegpudb#a4269fa8dff6b16d80aa3b46b2b83ac17">false</a>. If <span>tableName</span> is empty, then <a href="/content/api/cpp/namespacegpudb#a2050a78788d443270f69a5e04d7f67c2">show\_children</a> must be <a href="/content/api/cpp/namespacegpudb#ad1805831e61943d412b1cba8ac9a35bb">true</a>. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad1805831e61943d412b1cba8ac9a35bb">show\_table\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a4269fa8dff6b16d80aa3b46b2b83ac17">show\_table\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ad1805831e61943d412b1cba8ac9a35bb">show\_table\_true</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a16da9c4b995d47af198c8ad820432a6c">show\_table\_get\_column\_info</a>: If <a href="/content/api/cpp/namespacegpudb#ad1805831e61943d412b1cba8ac9a35bb">true</a> then column info (memory usage, etc) will be returned. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad1805831e61943d412b1cba8ac9a35bb">show\_table\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a4269fa8dff6b16d80aa3b46b2b83ac17">show\_table\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a4269fa8dff6b16d80aa3b46b2b83ac17">show\_table\_false</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowTableResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowTableResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a8011e9d5df312e8f50583cc4b153dde8">◆ </a></span>showTableMetadata() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowTableMetadataResponse">ShowTableMetadataResponse</a> gpudb::GPUdb::showTableMetadata </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1ShowTableMetadataRequest">ShowTableMetadataRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Retrieves the user provided metadata for the specified tables. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowTableMetadataRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowTableMetadataResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ab7bc6afc0682e126a425727d883ebbad">◆ </a></span>showTableMetadata() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowTableMetadataResponse">ShowTableMetadataResponse</a> & gpudb::GPUdb::showTableMetadata </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1ShowTableMetadataRequest">ShowTableMetadataRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1ShowTableMetadataResponse">ShowTableMetadataResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Retrieves the user provided metadata for the specified tables. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowTableMetadataRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowTableMetadataResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowTableMetadataResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ab1250090726533a5265355e7c0bff521">◆ </a></span>showTableMetadata() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowTableMetadataResponse">ShowTableMetadataResponse</a> gpudb::GPUdb::showTableMetadata </td>
            <td>(</td>
            <td>const std::vector\< std::string > &</td>
            <td><span><span>tableNames</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Retrieves the user provided metadata for the specified tables. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableNames</td>
                <td>Names of tables whose metadata will be fetched, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. All provided tables must exist, or an error is returned. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowTableMetadataResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a94dc914ac5b5e5634a95ff88b3902be2">◆ </a></span>showTableMetadata() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowTableMetadataResponse">ShowTableMetadataResponse</a> & gpudb::GPUdb::showTableMetadata </td>
            <td>(</td>
            <td>const std::vector\< std::string > &</td>
            <td><span><span>tableNames</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1ShowTableMetadataResponse">ShowTableMetadataResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Retrieves the user provided metadata for the specified tables. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableNames</td>
                <td>Names of tables whose metadata will be fetched, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. All provided tables must exist, or an error is returned. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowTableMetadataResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowTableMetadataResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a1b9e0abd0e04244cff2813881f72615e">◆ </a></span>showTableMonitors() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowTableMonitorsResponse">ShowTableMonitorsResponse</a> gpudb::GPUdb::showTableMonitors </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1ShowTableMonitorsRequest">ShowTableMonitorsRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Show table monitors and their properties. </p>
        <p>Table monitors are created using <a href="#ab379d6656d94cb2e54be2671ecd05d6c">createTableMonitor</a>. Returns detailed information about existing table monitors.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowTableMonitorsRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowTableMonitorsResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a3bae1cd6313e43f990e4eb4a554f8a1d">◆ </a></span>showTableMonitors() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowTableMonitorsResponse">ShowTableMonitorsResponse</a> & gpudb::GPUdb::showTableMonitors </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1ShowTableMonitorsRequest">ShowTableMonitorsRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1ShowTableMonitorsResponse">ShowTableMonitorsResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Show table monitors and their properties. </p>
        <p>Table monitors are created using <a href="#ab379d6656d94cb2e54be2671ecd05d6c">createTableMonitor</a>. Returns detailed information about existing table monitors.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowTableMonitorsRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowTableMonitorsResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowTableMonitorsResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ad36ad1ac000458de39912ad045100bb4">◆ </a></span>showTableMonitors() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowTableMonitorsResponse">ShowTableMonitorsResponse</a> gpudb::GPUdb::showTableMonitors </td>
            <td>(</td>
            <td>const std::vector\< std::string > &</td>
            <td><span><span>monitorIds</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Show table monitors and their properties. </p>
        <p>Table monitors are created using <a href="#a562dc443f79f57ea572cb5ec0f2e8093">createTableMonitor</a>. Returns detailed information about existing table monitors.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>monitorIds</td>
                <td>List of monitors to be shown. An empty list or a single entry with an empty string returns all table monitors. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowTableMonitorsResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ac78e4c6b00a6dc553affd5f6a7681c04">◆ </a></span>showTableMonitors() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowTableMonitorsResponse">ShowTableMonitorsResponse</a> & gpudb::GPUdb::showTableMonitors </td>
            <td>(</td>
            <td>const std::vector\< std::string > &</td>
            <td><span><span>monitorIds</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1ShowTableMonitorsResponse">ShowTableMonitorsResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Show table monitors and their properties. </p>
        <p>Table monitors are created using <a href="#a562dc443f79f57ea572cb5ec0f2e8093">createTableMonitor</a>. Returns detailed information about existing table monitors.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>monitorIds</td>
                <td>List of monitors to be shown. An empty list or a single entry with an empty string returns all table monitors. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowTableMonitorsResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowTableMonitorsResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#aa176b992328cb4ac634c06e9683f4120">◆ </a></span>showTablesByType() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowTablesByTypeResponse">ShowTablesByTypeResponse</a> gpudb::GPUdb::showTablesByType </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1ShowTablesByTypeRequest">ShowTablesByTypeRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Gets names of the tables whose type matches the given criteria. </p>
        <p>Each table has a particular type. This type comprises the schema and properties of the table and sometimes a type label. This function allows a look up of the existing tables based on full or partial type information. The operation is synchronous.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowTablesByTypeRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowTablesByTypeResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a5d9dae6c5d5e405c5a3c802ac330db8d">◆ </a></span>showTablesByType() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowTablesByTypeResponse">ShowTablesByTypeResponse</a> & gpudb::GPUdb::showTablesByType </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1ShowTablesByTypeRequest">ShowTablesByTypeRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1ShowTablesByTypeResponse">ShowTablesByTypeResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Gets names of the tables whose type matches the given criteria. </p>
        <p>Each table has a particular type. This type comprises the schema and properties of the table and sometimes a type label. This function allows a look up of the existing tables based on full or partial type information. The operation is synchronous.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowTablesByTypeRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowTablesByTypeResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowTablesByTypeResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ace4dedcb98f864f1dfdcd7e3901f5017">◆ </a></span>showTablesByType() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowTablesByTypeResponse">ShowTablesByTypeResponse</a> gpudb::GPUdb::showTablesByType </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>typeId</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>label</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Gets names of the tables whose type matches the given criteria. </p>
        <p>Each table has a particular type. This type comprises the schema and properties of the table and sometimes a type label. This function allows a look up of the existing tables based on full or partial type information. The operation is synchronous.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>typeId</td>
                <td><a href="/content/api/cpp/classgpudb_1_1Type">Type</a> id returned by a call to <a href="#a1698840c08d7212878c9c1dac3f94cfc">createType</a>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>label</td>
                <td>Optional user supplied label which can be used instead of the type\_id to retrieve all tables with the given label. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowTablesByTypeResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ab97b8f8e43007329fc0978ee9b179003">◆ </a></span>showTablesByType() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowTablesByTypeResponse">ShowTablesByTypeResponse</a> & gpudb::GPUdb::showTablesByType </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>typeId</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>label</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1ShowTablesByTypeResponse">ShowTablesByTypeResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Gets names of the tables whose type matches the given criteria. </p>
        <p>Each table has a particular type. This type comprises the schema and properties of the table and sometimes a type label. This function allows a look up of the existing tables based on full or partial type information. The operation is synchronous.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>typeId</td>
                <td><a href="/content/api/cpp/classgpudb_1_1Type">Type</a> id returned by a call to <a href="#a1698840c08d7212878c9c1dac3f94cfc">createType</a>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>label</td>
                <td>Optional user supplied label which can be used instead of the type\_id to retrieve all tables with the given label. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowTablesByTypeResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowTablesByTypeResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#aa866be48a1507fae7b1f04cabb2dec7b">◆ </a></span>showTriggers() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowTriggersResponse">ShowTriggersResponse</a> gpudb::GPUdb::showTriggers </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1ShowTriggersRequest">ShowTriggersRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Retrieves information regarding the specified triggers or all existing triggers currently active. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowTriggersRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowTriggersResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a056e32dfb35638f25ff6ce6209b64361">◆ </a></span>showTriggers() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowTriggersResponse">ShowTriggersResponse</a> & gpudb::GPUdb::showTriggers </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1ShowTriggersRequest">ShowTriggersRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1ShowTriggersResponse">ShowTriggersResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Retrieves information regarding the specified triggers or all existing triggers currently active. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowTriggersRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowTriggersResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowTriggersResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a1850c13a2596e38b3adb5b66f1019bdf">◆ </a></span>showTriggers() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowTriggersResponse">ShowTriggersResponse</a> gpudb::GPUdb::showTriggers </td>
            <td>(</td>
            <td>const std::vector\< std::string > &</td>
            <td><span><span>triggerIds</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Retrieves information regarding the specified triggers or all existing triggers currently active. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>triggerIds</td>
                <td>List of IDs of the triggers whose information is to be retrieved. An empty list means information will be retrieved on all active triggers. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowTriggersResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a79726472baf60c0c5c4ed28c7e1d1c62">◆ </a></span>showTriggers() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowTriggersResponse">ShowTriggersResponse</a> & gpudb::GPUdb::showTriggers </td>
            <td>(</td>
            <td>const std::vector\< std::string > &</td>
            <td><span><span>triggerIds</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1ShowTriggersResponse">ShowTriggersResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Retrieves information regarding the specified triggers or all existing triggers currently active. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>triggerIds</td>
                <td>List of IDs of the triggers whose information is to be retrieved. An empty list means information will be retrieved on all active triggers. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowTriggersResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowTriggersResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a7e24fcb79c117b482b208c0ef5460a13">◆ </a></span>showTypes() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowTypesResponse">ShowTypesResponse</a> gpudb::GPUdb::showTypes </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1ShowTypesRequest">ShowTypesRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Retrieves information for the specified data type ID or type label. </p>
        <p>For all data types that match the input criteria, the database returns the type ID, the type schema, the label (if available), and the type's column properties.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowTypesRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowTypesResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ad04a5739c19607646621ffb136131e59">◆ </a></span>showTypes() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowTypesResponse">ShowTypesResponse</a> & gpudb::GPUdb::showTypes </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1ShowTypesRequest">ShowTypesRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1ShowTypesResponse">ShowTypesResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Retrieves information for the specified data type ID or type label. </p>
        <p>For all data types that match the input criteria, the database returns the type ID, the type schema, the label (if available), and the type's column properties.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowTypesRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowTypesResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowTypesResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#af7d8d4d6feabebbcb4d876490e0189ec">◆ </a></span>showTypes() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowTypesResponse">ShowTypesResponse</a> gpudb::GPUdb::showTypes </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>typeId</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>label</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Retrieves information for the specified data type ID or type label. </p>
        <p>For all data types that match the input criteria, the database returns the type ID, the type schema, the label (if available), and the type's column properties.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>typeId</td>
                <td><a href="/content/api/cpp/classgpudb_1_1Type">Type</a> Id returned in response to a call to <a href="#a1698840c08d7212878c9c1dac3f94cfc">createType</a>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>label</td>
                <td>Option string that was supplied by user in a call to <a href="#a1698840c08d7212878c9c1dac3f94cfc">createType</a>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ad985e107decf23b22821a2da171d0e23">show\_types\_no\_join\_types</a>: When set to 'true', no join types will be included. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a4b3326fb359c1438b971e52d0f65a6b7">show\_types\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad1db6240541c3ee8d8076062bc341f04">show\_types\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ad1db6240541c3ee8d8076062bc341f04">show\_types\_false</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowTypesResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a51dafaa30b1649127b257efea07d8e6e">◆ </a></span>showTypes() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowTypesResponse">ShowTypesResponse</a> & gpudb::GPUdb::showTypes </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>typeId</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>label</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1ShowTypesResponse">ShowTypesResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Retrieves information for the specified data type ID or type label. </p>
        <p>For all data types that match the input criteria, the database returns the type ID, the type schema, the label (if available), and the type's column properties.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>typeId</td>
                <td><a href="/content/api/cpp/classgpudb_1_1Type">Type</a> Id returned in response to a call to <a href="#a1698840c08d7212878c9c1dac3f94cfc">createType</a>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>label</td>
                <td>Option string that was supplied by user in a call to <a href="#a1698840c08d7212878c9c1dac3f94cfc">createType</a>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ad985e107decf23b22821a2da171d0e23">show\_types\_no\_join\_types</a>: When set to 'true', no join types will be included. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a4b3326fb359c1438b971e52d0f65a6b7">show\_types\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad1db6240541c3ee8d8076062bc341f04">show\_types\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ad1db6240541c3ee8d8076062bc341f04">show\_types\_false</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowTypesResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowTypesResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a05a25ebc31d43eb7006d745e42ae3481">◆ </a></span>showVideo() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowVideoResponse">ShowVideoResponse</a> gpudb::GPUdb::showVideo </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1ShowVideoRequest">ShowVideoRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Retrieves information about rendered videos. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowVideoRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowVideoResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ae38f09ef1534eef8c6a6f750ef82746c">◆ </a></span>showVideo() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowVideoResponse">ShowVideoResponse</a> & gpudb::GPUdb::showVideo </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1ShowVideoRequest">ShowVideoRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1ShowVideoResponse">ShowVideoResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Retrieves information about rendered videos. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowVideoRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowVideoResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowVideoResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a476a58d5c29335a022ac949d8cee8a5c">◆ </a></span>showVideo() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowVideoResponse">ShowVideoResponse</a> gpudb::GPUdb::showVideo </td>
            <td>(</td>
            <td>const std::vector\< std::string > &</td>
            <td><span><span>paths</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Retrieves information about rendered videos. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>paths</td>
                <td>The fully-qualified <a href="/content/tools/kifs/">KiFS</a> paths for the videos to show. If empty, shows all videos. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowVideoResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a121311ac48c0d3816ea00df3dc39f079">◆ </a></span>showVideo() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowVideoResponse">ShowVideoResponse</a> & gpudb::GPUdb::showVideo </td>
            <td>(</td>
            <td>const std::vector\< std::string > &</td>
            <td><span><span>paths</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1ShowVideoResponse">ShowVideoResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Retrieves information about rendered videos. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>paths</td>
                <td>The fully-qualified <a href="/content/tools/kifs/">KiFS</a> paths for the videos to show. If empty, shows all videos. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowVideoResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowVideoResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ad5bf0a554a3e41a63719b512f4c202d9">◆ </a></span>showWal() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowWalResponse">ShowWalResponse</a> gpudb::GPUdb::showWal </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1ShowWalRequest">ShowWalRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Requests table write-ahead log (WAL) properties. </p>
        <p>Returns information about the requested table WAL entries.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowWalRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowWalResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a73d6e73702f1b0522b80a2ffd0f9d392">◆ </a></span>showWal() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowWalResponse">ShowWalResponse</a> & gpudb::GPUdb::showWal </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1ShowWalRequest">ShowWalRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1ShowWalResponse">ShowWalResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Requests table write-ahead log (WAL) properties. </p>
        <p>Returns information about the requested table WAL entries.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowWalRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowWalResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowWalResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#aa65d48578b33db8e6f809c4f33733767">◆ </a></span>showWal() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowWalResponse">ShowWalResponse</a> gpudb::GPUdb::showWal </td>
            <td>(</td>
            <td>const std::vector\< std::string > &</td>
            <td><span><span>tableNames</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Requests table write-ahead log (WAL) properties. </p>
        <p>Returns information about the requested table WAL entries.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableNames</td>
                <td>List of tables to query. An asterisk returns all tables. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a7d7dabbaf85f5d4a800d086c78c317ee">show\_wal\_show\_settings</a>: If <a href="/content/api/cpp/namespacegpudb#a63617edea045707fb79da999e08dfb14">true</a> include a map of the WAL settings for the requested tables. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a63617edea045707fb79da999e08dfb14">show\_wal\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a276b631f1c7f67b28ead3c7da577dbc1">show\_wal\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a63617edea045707fb79da999e08dfb14">show\_wal\_true</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowWalResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ae90a350f2c13f5f6528ca9c87b21c9b6">◆ </a></span>showWal() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1ShowWalResponse">ShowWalResponse</a> & gpudb::GPUdb::showWal </td>
            <td>(</td>
            <td>const std::vector\< std::string > &</td>
            <td><span><span>tableNames</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1ShowWalResponse">ShowWalResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Requests table write-ahead log (WAL) properties. </p>
        <p>Returns information about the requested table WAL entries.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableNames</td>
                <td>List of tables to query. An asterisk returns all tables. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a7d7dabbaf85f5d4a800d086c78c317ee">show\_wal\_show\_settings</a>: If <a href="/content/api/cpp/namespacegpudb#a63617edea045707fb79da999e08dfb14">true</a> include a map of the WAL settings for the requested tables. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a63617edea045707fb79da999e08dfb14">show\_wal\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a276b631f1c7f67b28ead3c7da577dbc1">show\_wal\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a63617edea045707fb79da999e08dfb14">show\_wal\_true</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1ShowWalResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1ShowWalResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a53c721cb54a46730bbc465ee3a4a6dc3">◆ </a></span>solveGraph() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1SolveGraphResponse">SolveGraphResponse</a> gpudb::GPUdb::solveGraph </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1SolveGraphRequest">SolveGraphRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Solves an existing graph for a type of problem (e.g., shortest path, page rank, traveling salesman, etc.) using source nodes, destination nodes, and additional, optional weights and restrictions. </p>
        <p>IMPORTANT: It's highly recommended that you review the <a href="/content/graph_solver/network_graph_solver/">Graphs and Solvers</a> concepts documentation, the <a href="/content/guides/graph_rest_guide/">Graph REST Tutorial</a>, and/or some <a href="/content/guides/tags/graph-solve">/solve/graph examples</a> before using this endpoint.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1SolveGraphRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1SolveGraphResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a0a3a244ab7b1ff59db92a225ac01c733">◆ </a></span>solveGraph() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1SolveGraphResponse">SolveGraphResponse</a> & gpudb::GPUdb::solveGraph </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1SolveGraphRequest">SolveGraphRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1SolveGraphResponse">SolveGraphResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Solves an existing graph for a type of problem (e.g., shortest path, page rank, traveling salesman, etc.) using source nodes, destination nodes, and additional, optional weights and restrictions. </p>
        <p>IMPORTANT: It's highly recommended that you review the <a href="/content/graph_solver/network_graph_solver/">Graphs and Solvers</a> concepts documentation, the <a href="/content/guides/graph_rest_guide/">Graph REST Tutorial</a>, and/or some <a href="/content/guides/tags/graph-solve">/solve/graph examples</a> before using this endpoint.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1SolveGraphRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1SolveGraphResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1SolveGraphResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#af09b181ad497eac4c7b759f55e612bce">◆ </a></span>solveGraph() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1SolveGraphResponse">SolveGraphResponse</a> gpudb::GPUdb::solveGraph </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>graphName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< std::string > &</td>
            <td><span><span>weightsOnEdges</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< std::string > &</td>
            <td><span><span>restrictions</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>solverType</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< std::string > &</td>
            <td><span><span>sourceNodes</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< std::string > &</td>
            <td><span><span>destinationNodes</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>solutionTable</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Solves an existing graph for a type of problem (e.g., shortest path, page rank, traveling salesman, etc.) using source nodes, destination nodes, and additional, optional weights and restrictions. </p>
        <p>IMPORTANT: It's highly recommended that you review the <a href="/content/graph_solver/network_graph_solver/">Graphs and Solvers</a> concepts documentation, the <a href="/content/guides/graph_rest_guide/">Graph REST Tutorial</a>, and/or some <a href="/content/guides/tags/graph-solve">/solve/graph examples</a> before using this endpoint.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>graphName</td>
                <td>Name of the graph resource to solve. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>weightsOnEdges</td>
                <td>Additional weights to apply to the edges of an existing graph. Weights must be specified using <a href="/content/graph_solver/network_graph_solver/#identifiers">identifiers</a>; identifiers are grouped as <a href="/content/graph_solver/network_graph_solver/#id-combos">combinations</a>. Identifiers can be used with existing column names, e.g., 'table.column AS WEIGHTS\_EDGE\_ID', expressions, e.g., 'ST\_LENGTH(wkt) AS WEIGHTS\_VALUESPECIFIED', or constant values, e.g., '4, 15, 2 AS WEIGHTS\_VALUESPECIFIED'. Any provided weights will be added (in the case of 'WEIGHTS\_VALUESPECIFIED') to or multiplied with (in the case of 'WEIGHTS\_FACTORSPECIFIED') the existing weight(s). If using constant values in an identifier combination, the number of values specified must match across the combination. The default value is an empty vector. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>restrictions</td>
                <td>Additional restrictions to apply to the nodes/edges of an existing graph. Restrictions must be specified using <a href="/content/graph_solver/network_graph_solver/#identifiers">identifiers</a>; identifiers are grouped as <a href="/content/graph_solver/network_graph_solver/#id-combos">combinations</a>. Identifiers can be used with existing column names, e.g., 'table.column AS RESTRICTIONS\_EDGE\_ID', expressions, e.g., 'column/2 AS RESTRICTIONS\_VALUECOMPARED', or constant values, e.g., '0, 0, 0, 1 AS RESTRICTIONS\_ONOFFCOMPARED'. If using constant values in an identifier combination, the number of values specified must match across the combination. If remove\_previous\_restrictions option is set to true, any provided restrictions will replace the existing restrictions. Otherwise, any provided restrictions will be added (in the case of 'RESTRICTIONS\_VALUECOMPARED') to or replaced (in the case of 'RESTRICTIONS\_ONOFFCOMPARED'). The default value is an empty vector. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>solverType</td>

                <td>
                  The type of solver to use for the graph. Supported values:

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#ae3b812a81f69a78fd8d5d647fafa5481">solve\_graph\_SHORTEST\_PATH</a>: Solves for the optimal (shortest) path based on weights and restrictions from one source to destinations nodes. Also known as the Dijkstra solver. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ae0a7de078ffe4f01ad76d59abdf9b5d9">solve\_graph\_PAGE\_RANK</a>: Solves for the probability of each destination node being visited based on the links of the graph topology. Weights are not required to use this solver. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a359aa5b0d86984e7b726fc44e0a75135">solve\_graph\_PROBABILITY\_RANK</a>: Solves for the transitional probability (Hidden Markov) for each node based on the weights (probability assigned over given edges). </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a791e46f2427253d72f0f62ac02697638">solve\_graph\_CENTRALITY</a>: Solves for the degree of a node to depict how many pairs of individuals that would have to go through the node to reach one another in the minimum number of hops. Also known as betweenness. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a36ef6a3d26c650d2e7211ef384017d10">solve\_graph\_MULTIPLE\_ROUTING</a>: Solves for finding the minimum cost cumulative path for a round-trip starting from the given source and visiting each given destination node once then returning to the source. Also known as the traveling salesman problem. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a93c55f5359b1cf749b364e3bd3423915">solve\_graph\_INVERSE\_SHORTEST\_PATH</a>: Solves for finding the optimal path cost for each destination node to route to the source node. Also known as inverse Dijkstra or the service man routing problem. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a9b43cfca9481e85e6f58e011e7c3343f">solve\_graph\_BACKHAUL\_ROUTING</a>: Solves for optimal routes that connect remote asset nodes to the fixed (backbone) asset nodes. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a220953cb2e8752a1f55a57c008da6bc2">solve\_graph\_ALLPATHS</a>: Solves for paths that would give costs between max and min solution radia - Make sure to limit by the 'max\_solution\_targets' option. Min cost should be >= shortest\_path cost. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ab9916de68907d55093048d821a40eb2d">solve\_graph\_STATS\_ALL</a>: Solves for graph statistics such as graph diameter, longest pairs, vertex valences, topology numbers, average and max cluster sizes, etc. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a582e582c96386dccad065c0fb91b3b70">solve\_graph\_CLOSENESS</a>: Solves for the centrality closeness score per node as the sum of the inverse shortest path costs to all nodes in the graph. </li>
                  </ul>

                  The default value is <a href="/content/api/cpp/namespacegpudb#ae3b812a81f69a78fd8d5d647fafa5481">solve\_graph\_SHORTEST\_PATH</a>.
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>sourceNodes</td>
                <td>It can be one of the nodal identifiers - e.g: 'NODE\_WKTPOINT' for source nodes. For <a href="/content/api/cpp/namespacegpudb#a9b43cfca9481e85e6f58e011e7c3343f">BACKHAUL\_ROUTING</a>, this list depicts the fixed assets. The default value is an empty vector. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>destinationNodes</td>
                <td>It can be one of the nodal identifiers - e.g: 'NODE\_WKTPOINT' for destination (target) nodes. For <a href="/content/api/cpp/namespacegpudb#a9b43cfca9481e85e6f58e011e7c3343f">BACKHAUL\_ROUTING</a>, this list depicts the remote assets. The default value is an empty vector. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>solutionTable</td>
                <td>Name of the table to store the solution, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. The default value is 'graph\_solutions'. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Additional parameters.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a0cf14c3c628cda97655ba9f2b78adf99">solve\_graph\_max\_solution\_radius</a>: For <a href="/content/api/cpp/namespacegpudb#a220953cb2e8752a1f55a57c008da6bc2">ALLPATHS</a>, <a href="/content/api/cpp/namespacegpudb#ae3b812a81f69a78fd8d5d647fafa5481">SHORTEST\_PATH</a> and <a href="/content/api/cpp/namespacegpudb#a93c55f5359b1cf749b364e3bd3423915">INVERSE\_SHORTEST\_PATH</a> solvers only. Sets the maximum solution cost radius, which ignores the <span>destinationNodes</span> list and instead outputs the nodes within the radius sorted by ascending cost. If set to '0.0', the setting is ignored. The default value is '0.0'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ac372dd646e6ce7e7dd38e158d39b5817">solve\_graph\_min\_solution\_radius</a>: For <a href="/content/api/cpp/namespacegpudb#a220953cb2e8752a1f55a57c008da6bc2">ALLPATHS</a>, <a href="/content/api/cpp/namespacegpudb#ae3b812a81f69a78fd8d5d647fafa5481">SHORTEST\_PATH</a> and <a href="/content/api/cpp/namespacegpudb#a93c55f5359b1cf749b364e3bd3423915">INVERSE\_SHORTEST\_PATH</a> solvers only. Applicable only when <a href="/content/api/cpp/namespacegpudb#a0cf14c3c628cda97655ba9f2b78adf99">max\_solution\_radius</a> is set. Sets the minimum solution cost radius, which ignores the <span>destinationNodes</span> list and instead outputs the nodes within the radius sorted by ascending cost. If set to '0.0', the setting is ignored. The default value is '0.0'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a5dbb4bfe25fcca830a1d2e5f72794480">solve\_graph\_max\_solution\_targets</a>: For <a href="/content/api/cpp/namespacegpudb#a220953cb2e8752a1f55a57c008da6bc2">ALLPATHS</a>, <a href="/content/api/cpp/namespacegpudb#ae3b812a81f69a78fd8d5d647fafa5481">SHORTEST\_PATH</a> and <a href="/content/api/cpp/namespacegpudb#a93c55f5359b1cf749b364e3bd3423915">INVERSE\_SHORTEST\_PATH</a> solvers only. Sets the maximum number of solution targets, which ignores the <span>destinationNodes</span> list and instead outputs no more than n number of nodes sorted by ascending cost where n is equal to the setting value. If set to 0, the setting is ignored. The default value is '1000'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a3b3fdd4b833c2e2aea70704b13ee080c">solve\_graph\_uniform\_weights</a>: When specified, assigns the given value to all the edges in the graph. Note that weights provided in <span>weightsOnEdges</span> will override this value. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a3d701158a1bd0fa7bf0db839cb61712c">solve\_graph\_left\_turn\_penalty</a>: This will add an additional weight over the edges labeled as 'left turn' if the 'add\_turn' option parameter of the <a href="#a025f78582e1d24c590888a3d29e19f36">createGraph</a> was invoked at graph creation. The default value is '0.0'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a3c5821a9881f792878c7afdbbd6c0ee3">solve\_graph\_right\_turn\_penalty</a>: This will add an additional weight over the edges labeled as' right turn' if the 'add\_turn' option parameter of the <a href="#a025f78582e1d24c590888a3d29e19f36">createGraph</a> was invoked at graph creation. The default value is '0.0'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a0cbfe715de05c26bfb4e7443ab741b47">solve\_graph\_intersection\_penalty</a>: This will add an additional weight over the edges labeled as 'intersection' if the 'add\_turn' option parameter of the <a href="#a025f78582e1d24c590888a3d29e19f36">createGraph</a> was invoked at graph creation. The default value is '0.0'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a5d9de19fd9cab98fc0a756bb2d9e6260">solve\_graph\_sharp\_turn\_penalty</a>: This will add an additional weight over the edges labeled as 'sharp turn' or 'u-turn' if the 'add\_turn' option parameter of the <a href="#a025f78582e1d24c590888a3d29e19f36">createGraph</a> was invoked at graph creation. The default value is '0.0'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a720bcae0490349ea669b90b47789b2dd">solve\_graph\_num\_best\_paths</a>: For <a href="/content/api/cpp/namespacegpudb#a36ef6a3d26c650d2e7211ef384017d10">MULTIPLE\_ROUTING</a> solvers only; sets the number of shortest paths computed from each node. This is the heuristic criterion. Default value of zero allows the number to be computed automatically by the solver. The user may want to override this parameter to speed-up the solver. The default value is '0'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a289a31f8f0de66143d110d5b9406be66">solve\_graph\_max\_num\_combinations</a>: For <a href="/content/api/cpp/namespacegpudb#a36ef6a3d26c650d2e7211ef384017d10">MULTIPLE\_ROUTING</a> solvers only; sets the cap on the combinatorial sequences generated. If the default value of two millions is overridden to a lesser value, it can potentially speed up the solver. The default value is '2000000'. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a457ff25b8acaf7630a394ce701c9de98">solve\_graph\_output\_edge\_path</a>: If true then concatenated edge IDs will be added as the EDGE path column of the solution table for each source and target pair in shortest path solves. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a512e5f5dd20503901261659851cb5ed4">solve\_graph\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a2c3ecb206a7271e1e10ec85a9d55f805">solve\_graph\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a2c3ecb206a7271e1e10ec85a9d55f805">solve\_graph\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ac8eafb3785ef9c47d29edfda7f45e42d">solve\_graph\_output\_wkt\_path</a>: If true then concatenated wkt line segments will be added as the Wktroute column of the solution table for each source and target pair in shortest path solves. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a512e5f5dd20503901261659851cb5ed4">solve\_graph\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a2c3ecb206a7271e1e10ec85a9d55f805">solve\_graph\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a512e5f5dd20503901261659851cb5ed4">solve\_graph\_true</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a17ac9149a30dbb803f115d11e1ba8566">solve\_graph\_server\_id</a>: Indicates which graph server(s) to send the request to. Default is to send to the server, amongst those containing the corresponding graph, that has the most computational bandwidth. For SHORTEST\_PATH solver type, the input is split amongst the server containing the corresponding graph. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aa6462eacb15ddbb34f38325e931debe5">solve\_graph\_convergence\_limit</a>: For <a href="/content/api/cpp/namespacegpudb#ae0a7de078ffe4f01ad76d59abdf9b5d9">PAGE\_RANK</a> solvers only; Maximum percent relative threshold on the page rank scores of each node between consecutive iterations to satisfy convergence. Default value is 1 (one) percent. The default value is '1.0'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a3632fd32a3a1d5884ccf81c79eace435">solve\_graph\_max\_iterations</a>: For <a href="/content/api/cpp/namespacegpudb#ae0a7de078ffe4f01ad76d59abdf9b5d9">PAGE\_RANK</a> solvers only; Maximum number of page rank iterations for satisfying convergence. Default value is 100. The default value is '100'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a70323311b4ed78cd4c6e3e019fa7bf97">solve\_graph\_max\_runs</a>: For all <a href="/content/api/cpp/namespacegpudb#a791e46f2427253d72f0f62ac02697638">CENTRALITY</a> solvers only; Sets the maximum number of shortest path runs; maximum possible value is the number of nodes in the graph. Default value of 0 enables this value to be auto computed by the solver. The default value is '0'. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a108be0864ea1c98e5c12eaed54611b02">solve\_graph\_output\_clusters</a>: For <a href="/content/api/cpp/namespacegpudb#ab9916de68907d55093048d821a40eb2d">STATS\_ALL</a> solvers only; the cluster index for each node will be inserted as an additional column in the output. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a512e5f5dd20503901261659851cb5ed4">solve\_graph\_true</a>: An additional column 'CLUSTER' will be added for each node. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a2c3ecb206a7271e1e10ec85a9d55f805">solve\_graph\_false</a>: No extra cluster info per node will be available in the output. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a2c3ecb206a7271e1e10ec85a9d55f805">solve\_graph\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a861b87445c307864bd24cb4a162986c7">solve\_graph\_solve\_heuristic</a>: Specify heuristic search criterion only for the geo graphs and shortest path solves towards a single target. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ab1ed7902af439b227fa152cb619c3fa1">solve\_graph\_astar</a>: Employs A-STAR heuristics to speed up the shortest path traversal. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a1c0eb21723ec35e97d6548579c7fb144">solve\_graph\_none</a>: No heuristics are applied. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a1c0eb21723ec35e97d6548579c7fb144">solve\_graph\_none</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a966d4b263d95dd979f810edc31c778b8">solve\_graph\_astar\_radius</a>: For path solvers only when 'solve\_heuristic' option is 'astar'. The shortest path traversal front includes nodes only within this radius (kilometers) as it moves towards the target location. The default value is '70'. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1SolveGraphResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a4fc28f54b6a27b284e37f62fe92abb61">◆ </a></span>solveGraph() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1SolveGraphResponse">SolveGraphResponse</a> & gpudb::GPUdb::solveGraph </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>graphName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< std::string > &</td>
            <td><span><span>weightsOnEdges</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< std::string > &</td>
            <td><span><span>restrictions</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>solverType</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< std::string > &</td>
            <td><span><span>sourceNodes</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< std::string > &</td>
            <td><span><span>destinationNodes</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>solutionTable</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1SolveGraphResponse">SolveGraphResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Solves an existing graph for a type of problem (e.g., shortest path, page rank, traveling salesman, etc.) using source nodes, destination nodes, and additional, optional weights and restrictions. </p>
        <p>IMPORTANT: It's highly recommended that you review the <a href="/content/graph_solver/network_graph_solver/">Graphs and Solvers</a> concepts documentation, the <a href="/content/guides/graph_rest_guide/">Graph REST Tutorial</a>, and/or some <a href="/content/guides/tags/graph-solve">/solve/graph examples</a> before using this endpoint.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>graphName</td>
                <td>Name of the graph resource to solve. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>weightsOnEdges</td>
                <td>Additional weights to apply to the edges of an existing graph. Weights must be specified using <a href="/content/graph_solver/network_graph_solver/#identifiers">identifiers</a>; identifiers are grouped as <a href="/content/graph_solver/network_graph_solver/#id-combos">combinations</a>. Identifiers can be used with existing column names, e.g., 'table.column AS WEIGHTS\_EDGE\_ID', expressions, e.g., 'ST\_LENGTH(wkt) AS WEIGHTS\_VALUESPECIFIED', or constant values, e.g., '4, 15, 2 AS WEIGHTS\_VALUESPECIFIED'. Any provided weights will be added (in the case of 'WEIGHTS\_VALUESPECIFIED') to or multiplied with (in the case of 'WEIGHTS\_FACTORSPECIFIED') the existing weight(s). If using constant values in an identifier combination, the number of values specified must match across the combination. The default value is an empty vector. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>restrictions</td>
                <td>Additional restrictions to apply to the nodes/edges of an existing graph. Restrictions must be specified using <a href="/content/graph_solver/network_graph_solver/#identifiers">identifiers</a>; identifiers are grouped as <a href="/content/graph_solver/network_graph_solver/#id-combos">combinations</a>. Identifiers can be used with existing column names, e.g., 'table.column AS RESTRICTIONS\_EDGE\_ID', expressions, e.g., 'column/2 AS RESTRICTIONS\_VALUECOMPARED', or constant values, e.g., '0, 0, 0, 1 AS RESTRICTIONS\_ONOFFCOMPARED'. If using constant values in an identifier combination, the number of values specified must match across the combination. If remove\_previous\_restrictions option is set to true, any provided restrictions will replace the existing restrictions. Otherwise, any provided restrictions will be added (in the case of 'RESTRICTIONS\_VALUECOMPARED') to or replaced (in the case of 'RESTRICTIONS\_ONOFFCOMPARED'). The default value is an empty vector. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>solverType</td>

                <td>
                  The type of solver to use for the graph. Supported values:

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#ae3b812a81f69a78fd8d5d647fafa5481">solve\_graph\_SHORTEST\_PATH</a>: Solves for the optimal (shortest) path based on weights and restrictions from one source to destinations nodes. Also known as the Dijkstra solver. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ae0a7de078ffe4f01ad76d59abdf9b5d9">solve\_graph\_PAGE\_RANK</a>: Solves for the probability of each destination node being visited based on the links of the graph topology. Weights are not required to use this solver. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a359aa5b0d86984e7b726fc44e0a75135">solve\_graph\_PROBABILITY\_RANK</a>: Solves for the transitional probability (Hidden Markov) for each node based on the weights (probability assigned over given edges). </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a791e46f2427253d72f0f62ac02697638">solve\_graph\_CENTRALITY</a>: Solves for the degree of a node to depict how many pairs of individuals that would have to go through the node to reach one another in the minimum number of hops. Also known as betweenness. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a36ef6a3d26c650d2e7211ef384017d10">solve\_graph\_MULTIPLE\_ROUTING</a>: Solves for finding the minimum cost cumulative path for a round-trip starting from the given source and visiting each given destination node once then returning to the source. Also known as the traveling salesman problem. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a93c55f5359b1cf749b364e3bd3423915">solve\_graph\_INVERSE\_SHORTEST\_PATH</a>: Solves for finding the optimal path cost for each destination node to route to the source node. Also known as inverse Dijkstra or the service man routing problem. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a9b43cfca9481e85e6f58e011e7c3343f">solve\_graph\_BACKHAUL\_ROUTING</a>: Solves for optimal routes that connect remote asset nodes to the fixed (backbone) asset nodes. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a220953cb2e8752a1f55a57c008da6bc2">solve\_graph\_ALLPATHS</a>: Solves for paths that would give costs between max and min solution radia - Make sure to limit by the 'max\_solution\_targets' option. Min cost should be >= shortest\_path cost. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ab9916de68907d55093048d821a40eb2d">solve\_graph\_STATS\_ALL</a>: Solves for graph statistics such as graph diameter, longest pairs, vertex valences, topology numbers, average and max cluster sizes, etc. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a582e582c96386dccad065c0fb91b3b70">solve\_graph\_CLOSENESS</a>: Solves for the centrality closeness score per node as the sum of the inverse shortest path costs to all nodes in the graph. </li>
                  </ul>

                  The default value is <a href="/content/api/cpp/namespacegpudb#ae3b812a81f69a78fd8d5d647fafa5481">solve\_graph\_SHORTEST\_PATH</a>.
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>sourceNodes</td>
                <td>It can be one of the nodal identifiers - e.g: 'NODE\_WKTPOINT' for source nodes. For <a href="/content/api/cpp/namespacegpudb#a9b43cfca9481e85e6f58e011e7c3343f">BACKHAUL\_ROUTING</a>, this list depicts the fixed assets. The default value is an empty vector. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>destinationNodes</td>
                <td>It can be one of the nodal identifiers - e.g: 'NODE\_WKTPOINT' for destination (target) nodes. For <a href="/content/api/cpp/namespacegpudb#a9b43cfca9481e85e6f58e011e7c3343f">BACKHAUL\_ROUTING</a>, this list depicts the remote assets. The default value is an empty vector. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>solutionTable</td>
                <td>Name of the table to store the solution, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. The default value is 'graph\_solutions'. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Additional parameters.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a0cf14c3c628cda97655ba9f2b78adf99">solve\_graph\_max\_solution\_radius</a>: For <a href="/content/api/cpp/namespacegpudb#a220953cb2e8752a1f55a57c008da6bc2">ALLPATHS</a>, <a href="/content/api/cpp/namespacegpudb#ae3b812a81f69a78fd8d5d647fafa5481">SHORTEST\_PATH</a> and <a href="/content/api/cpp/namespacegpudb#a93c55f5359b1cf749b364e3bd3423915">INVERSE\_SHORTEST\_PATH</a> solvers only. Sets the maximum solution cost radius, which ignores the <span>destinationNodes</span> list and instead outputs the nodes within the radius sorted by ascending cost. If set to '0.0', the setting is ignored. The default value is '0.0'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ac372dd646e6ce7e7dd38e158d39b5817">solve\_graph\_min\_solution\_radius</a>: For <a href="/content/api/cpp/namespacegpudb#a220953cb2e8752a1f55a57c008da6bc2">ALLPATHS</a>, <a href="/content/api/cpp/namespacegpudb#ae3b812a81f69a78fd8d5d647fafa5481">SHORTEST\_PATH</a> and <a href="/content/api/cpp/namespacegpudb#a93c55f5359b1cf749b364e3bd3423915">INVERSE\_SHORTEST\_PATH</a> solvers only. Applicable only when <a href="/content/api/cpp/namespacegpudb#a0cf14c3c628cda97655ba9f2b78adf99">max\_solution\_radius</a> is set. Sets the minimum solution cost radius, which ignores the <span>destinationNodes</span> list and instead outputs the nodes within the radius sorted by ascending cost. If set to '0.0', the setting is ignored. The default value is '0.0'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a5dbb4bfe25fcca830a1d2e5f72794480">solve\_graph\_max\_solution\_targets</a>: For <a href="/content/api/cpp/namespacegpudb#a220953cb2e8752a1f55a57c008da6bc2">ALLPATHS</a>, <a href="/content/api/cpp/namespacegpudb#ae3b812a81f69a78fd8d5d647fafa5481">SHORTEST\_PATH</a> and <a href="/content/api/cpp/namespacegpudb#a93c55f5359b1cf749b364e3bd3423915">INVERSE\_SHORTEST\_PATH</a> solvers only. Sets the maximum number of solution targets, which ignores the <span>destinationNodes</span> list and instead outputs no more than n number of nodes sorted by ascending cost where n is equal to the setting value. If set to 0, the setting is ignored. The default value is '1000'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a3b3fdd4b833c2e2aea70704b13ee080c">solve\_graph\_uniform\_weights</a>: When specified, assigns the given value to all the edges in the graph. Note that weights provided in <span>weightsOnEdges</span> will override this value. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a3d701158a1bd0fa7bf0db839cb61712c">solve\_graph\_left\_turn\_penalty</a>: This will add an additional weight over the edges labeled as 'left turn' if the 'add\_turn' option parameter of the <a href="#a025f78582e1d24c590888a3d29e19f36">createGraph</a> was invoked at graph creation. The default value is '0.0'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a3c5821a9881f792878c7afdbbd6c0ee3">solve\_graph\_right\_turn\_penalty</a>: This will add an additional weight over the edges labeled as' right turn' if the 'add\_turn' option parameter of the <a href="#a025f78582e1d24c590888a3d29e19f36">createGraph</a> was invoked at graph creation. The default value is '0.0'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a0cbfe715de05c26bfb4e7443ab741b47">solve\_graph\_intersection\_penalty</a>: This will add an additional weight over the edges labeled as 'intersection' if the 'add\_turn' option parameter of the <a href="#a025f78582e1d24c590888a3d29e19f36">createGraph</a> was invoked at graph creation. The default value is '0.0'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a5d9de19fd9cab98fc0a756bb2d9e6260">solve\_graph\_sharp\_turn\_penalty</a>: This will add an additional weight over the edges labeled as 'sharp turn' or 'u-turn' if the 'add\_turn' option parameter of the <a href="#a025f78582e1d24c590888a3d29e19f36">createGraph</a> was invoked at graph creation. The default value is '0.0'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a720bcae0490349ea669b90b47789b2dd">solve\_graph\_num\_best\_paths</a>: For <a href="/content/api/cpp/namespacegpudb#a36ef6a3d26c650d2e7211ef384017d10">MULTIPLE\_ROUTING</a> solvers only; sets the number of shortest paths computed from each node. This is the heuristic criterion. Default value of zero allows the number to be computed automatically by the solver. The user may want to override this parameter to speed-up the solver. The default value is '0'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a289a31f8f0de66143d110d5b9406be66">solve\_graph\_max\_num\_combinations</a>: For <a href="/content/api/cpp/namespacegpudb#a36ef6a3d26c650d2e7211ef384017d10">MULTIPLE\_ROUTING</a> solvers only; sets the cap on the combinatorial sequences generated. If the default value of two millions is overridden to a lesser value, it can potentially speed up the solver. The default value is '2000000'. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a457ff25b8acaf7630a394ce701c9de98">solve\_graph\_output\_edge\_path</a>: If true then concatenated edge IDs will be added as the EDGE path column of the solution table for each source and target pair in shortest path solves. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a512e5f5dd20503901261659851cb5ed4">solve\_graph\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a2c3ecb206a7271e1e10ec85a9d55f805">solve\_graph\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a2c3ecb206a7271e1e10ec85a9d55f805">solve\_graph\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ac8eafb3785ef9c47d29edfda7f45e42d">solve\_graph\_output\_wkt\_path</a>: If true then concatenated wkt line segments will be added as the Wktroute column of the solution table for each source and target pair in shortest path solves. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a512e5f5dd20503901261659851cb5ed4">solve\_graph\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a2c3ecb206a7271e1e10ec85a9d55f805">solve\_graph\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a512e5f5dd20503901261659851cb5ed4">solve\_graph\_true</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a17ac9149a30dbb803f115d11e1ba8566">solve\_graph\_server\_id</a>: Indicates which graph server(s) to send the request to. Default is to send to the server, amongst those containing the corresponding graph, that has the most computational bandwidth. For SHORTEST\_PATH solver type, the input is split amongst the server containing the corresponding graph. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aa6462eacb15ddbb34f38325e931debe5">solve\_graph\_convergence\_limit</a>: For <a href="/content/api/cpp/namespacegpudb#ae0a7de078ffe4f01ad76d59abdf9b5d9">PAGE\_RANK</a> solvers only; Maximum percent relative threshold on the page rank scores of each node between consecutive iterations to satisfy convergence. Default value is 1 (one) percent. The default value is '1.0'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a3632fd32a3a1d5884ccf81c79eace435">solve\_graph\_max\_iterations</a>: For <a href="/content/api/cpp/namespacegpudb#ae0a7de078ffe4f01ad76d59abdf9b5d9">PAGE\_RANK</a> solvers only; Maximum number of page rank iterations for satisfying convergence. Default value is 100. The default value is '100'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a70323311b4ed78cd4c6e3e019fa7bf97">solve\_graph\_max\_runs</a>: For all <a href="/content/api/cpp/namespacegpudb#a791e46f2427253d72f0f62ac02697638">CENTRALITY</a> solvers only; Sets the maximum number of shortest path runs; maximum possible value is the number of nodes in the graph. Default value of 0 enables this value to be auto computed by the solver. The default value is '0'. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a108be0864ea1c98e5c12eaed54611b02">solve\_graph\_output\_clusters</a>: For <a href="/content/api/cpp/namespacegpudb#ab9916de68907d55093048d821a40eb2d">STATS\_ALL</a> solvers only; the cluster index for each node will be inserted as an additional column in the output. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a512e5f5dd20503901261659851cb5ed4">solve\_graph\_true</a>: An additional column 'CLUSTER' will be added for each node. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a2c3ecb206a7271e1e10ec85a9d55f805">solve\_graph\_false</a>: No extra cluster info per node will be available in the output. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a2c3ecb206a7271e1e10ec85a9d55f805">solve\_graph\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a861b87445c307864bd24cb4a162986c7">solve\_graph\_solve\_heuristic</a>: Specify heuristic search criterion only for the geo graphs and shortest path solves towards a single target. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ab1ed7902af439b227fa152cb619c3fa1">solve\_graph\_astar</a>: Employs A-STAR heuristics to speed up the shortest path traversal. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a1c0eb21723ec35e97d6548579c7fb144">solve\_graph\_none</a>: No heuristics are applied. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a1c0eb21723ec35e97d6548579c7fb144">solve\_graph\_none</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a966d4b263d95dd979f810edc31c778b8">solve\_graph\_astar\_radius</a>: For path solvers only when 'solve\_heuristic' option is 'astar'. The shortest path traversal front includes nodes only within this radius (kilometers) as it moves towards the target location. The default value is '70'. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1SolveGraphResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1SolveGraphResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a939b9f5e991775a4929de352c43074ae">◆ </a></span>submitRequest() <span>\[1/3]</span></h2>

    <div>
      <div>
        <div> template\<typename TRequest, typename TResponse> </div>

        <table>
          <tr>
            <td>
              <table>
                <tr>
                  <td>TResponse & gpudb::GPUdb::submitRequest </td>
                  <td>(</td>
                  <td>const char \*</td>
                  <td><span><span>endpoint</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const TRequest &</td>
                  <td><span><span>request</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>TResponse &</td>
                  <td><span><span>response</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const bool</td>
                  <td><span><span>enableCompression</span></span><span> = </span><span>false</span> ) const</td>
                </tr>
              </table>
            </td>

            <td> <span><span>inline</span></span> </td>
          </tr>
        </table>
      </div>

      <div>
        <p>Definition at line <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp#L445">445</a> of file <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">GPUdb.hpp</a>.</p>
      </div>
    </div>

    <h2><span><a href="#ab5e9179e7d4dd1ef359860bf74fc640c">◆ </a></span>submitRequest() <span>\[2/3]</span></h2>

    <div>
      <div>
        <div> template\<typename TRequest, typename TResponse> </div>

        <table>
          <tr>
            <td>
              <table>
                <tr>
                  <td>TResponse & gpudb::GPUdb::submitRequest </td>
                  <td>(</td>
                  <td>const <a href="/content/api/cpp/classgpudb_1_1HttpUrl">HttpUrl</a> &</td>
                  <td><span><span>url</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const TRequest &</td>
                  <td><span><span>request</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>TResponse &</td>
                  <td><span><span>response</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const bool</td>
                  <td><span><span>enableCompression</span></span><span> = </span><span>false</span> ) const</td>
                </tr>
              </table>
            </td>

            <td> <span><span>inline</span></span> </td>
          </tr>
        </table>
      </div>

      <div>
        <p>Definition at line <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp#L372">372</a> of file <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">GPUdb.hpp</a>.</p>
      </div>
    </div>

    <h2><span><a href="#a640c8e86578a9dd9d93e368b934bfd1f">◆ </a></span>submitRequest() <span>\[3/3]</span></h2>

    <div>
      <div>
        <div> template\<typename TRequest, typename TResponse> </div>

        <table>
          <tr>
            <td>
              <table>
                <tr>
                  <td>TResponse & gpudb::GPUdb::submitRequest </td>
                  <td>(</td>
                  <td>const std::string &</td>
                  <td><span><span>endpoint</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const TRequest &</td>
                  <td><span><span>request</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>TResponse &</td>
                  <td><span><span>response</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const bool</td>
                  <td><span><span>enableCompression</span></span><span> = </span><span>false</span> ) const</td>
                </tr>
              </table>
            </td>

            <td> <span><span>inline</span></span> </td>
          </tr>
        </table>
      </div>

      <div>
        <p>Definition at line <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp#L408">408</a> of file <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">GPUdb.hpp</a>.</p>
      </div>
    </div>

    <h2><span><a href="#a8c5649302a6ad92cf21b1023a602965c">◆ </a></span>submitRequestToHostManager() <span>\[1/2]</span></h2>

    <div>
      <div>
        <div> template\<typename TRequest, typename TResponse> </div>

        <table>
          <tr>
            <td>
              <table>
                <tr>
                  <td>TResponse & gpudb::GPUdb::submitRequestToHostManager </td>
                  <td>(</td>
                  <td>const char \*</td>
                  <td><span><span>endpoint</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const TRequest &</td>
                  <td><span><span>request</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>TResponse &</td>
                  <td><span><span>response</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const bool</td>
                  <td><span><span>enableCompression</span></span><span> = </span><span>false</span> ) const</td>
                </tr>
              </table>
            </td>

            <td> <span><span>inline</span></span> </td>
          </tr>
        </table>
      </div>

      <div>
        <p>Submit an HTTP request to the host manager. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>endpoint</td>
                <td>The endpoint for which the request is made. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>request</td>
                <td>The request object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response</td>
                <td>The response object in which the return values will be saved. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>enableCompression</td>
                <td>Optional boolean flag indicating whether any compression should be used. Default is false.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div>a reference to the response object. </div>
        </div>

        <p>Definition at line <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp#L520">520</a> of file <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">GPUdb.hpp</a>.</p>
      </div>
    </div>

    <h2><span><a href="#a5ed7d74b744aa18779313910508c582e">◆ </a></span>submitRequestToHostManager() <span>\[2/2]</span></h2>

    <div>
      <div>
        <div> template\<typename TRequest, typename TResponse> </div>

        <table>
          <tr>
            <td>
              <table>
                <tr>
                  <td>TResponse & gpudb::GPUdb::submitRequestToHostManager </td>
                  <td>(</td>
                  <td>const std::string &</td>
                  <td><span><span>endpoint</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const TRequest &</td>
                  <td><span><span>request</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>TResponse &</td>
                  <td><span><span>response</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const bool</td>
                  <td><span><span>enableCompression</span></span><span> = </span><span>false</span> ) const</td>
                </tr>
              </table>
            </td>

            <td> <span><span>inline</span></span> </td>
          </tr>
        </table>
      </div>

      <div>
        <p>Submit an HTTP request to the host manager. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>endpoint</td>
                <td>The endpoint for which the request is made. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>request</td>
                <td>The request object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response</td>
                <td>The response object in which the return values will be saved. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>enableCompression</td>
                <td>Optional boolean flag indicating whether any compression should be used. Default is false.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div>a reference to the response object. </div>
        </div>

        <p>Definition at line <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp#L469">469</a> of file <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">GPUdb.hpp</a>.</p>
      </div>
    </div>

    <h2><span><a href="#aab8ecc365dc0afeb16302ff9fdafc206">◆ </a></span>updateHostManagerPort()</h2>

    <div>
      <div>
        <table>
          <tr>
            <td>void gpudb::GPUdb::updateHostManagerPort </td>
            <td>(</td>

            <td>
              <span>
                <span />
              </span>
            </td>

            <td>)</td>

            <td />
          </tr>
        </table>
      </div>

      <div>
        <p>Update the host manager port by inquiring the server. </p>
      </div>
    </div>

    <h2><span><a href="#aa82b29b715fe503ada9587cd7ac8e5f7">◆ </a></span>updateRecords() <span>\[1/4]</span></h2>

    <div>
      <div>
        <div> template\<typename TRequest> </div>

        <table>
          <tr>
            <td>
              <table>
                <tr>
                  <td><a href="/content/api/cpp/structgpudb_1_1UpdateRecordsResponse">UpdateRecordsResponse</a> gpudb::GPUdb::updateRecords </td>
                  <td>(</td>
                  <td>const std::string &</td>
                  <td><span><span>tableName</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const std::vector\< std::string > &</td>
                  <td><span><span>expressions</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const std::vector\< std::map\< std::string, boost::optional\< std::string > > > &</td>
                  <td><span><span>newValuesMaps</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const std::vector\< TRequest > &</td>
                  <td><span><span>data</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const std::map\< std::string, std::string > &</td>
                  <td><span><span>options</span></span> ) const</td>
                </tr>
              </table>
            </td>

            <td> <span><span>inline</span></span> </td>
          </tr>
        </table>
      </div>

      <div>
        <p>Runs multiple predicate-based updates in a single call. </p>
        <p>With the list of given expressions, any matching record's column values will be updated as provided in <span>newValuesMaps</span>. There is also an optional 'upsert' capability where if a particular predicate doesn't match any existing record, then a new record can be inserted.</p>
        <p>Note that this operation can only be run on an original table and not on a result view.</p>
        <p>This operation can update primary key values. By default only 'pure primary key' predicates are allowed when updating primary key values. If the primary key for a table is the column 'attr1', then the operation will only accept predicates of the form: "attr1 == 'foo'" if the attr1 column is being updated. For a composite primary key (e.g. columns 'attr1' and 'attr2') then this operation will only accept predicates of the form: "(attr1 == 'foo') and (attr2 == 'bar')". Meaning, all primary key columns must appear in an equality predicate in the expressions. Furthermore each 'pure primary key' predicate must be unique within a given request. These restrictions can be removed by utilizing some available options through <span>options</span>.</p>
        <p>The <a href="/content/api/cpp/namespacegpudb#a7605a7a3a0274ce44efaa471344dcef2">update\_on\_existing\_pk</a> option specifies the record primary key collision policy for tables with a <a href="/content/concepts/tables/#primary-keys">primary key</a>, while <a href="/content/api/cpp/namespacegpudb#aba9511e40d021bad06b9dc8680f20ded">ignore\_existing\_pk</a> specifies the record primary key collision error-suppression policy when those collisions result in the update being rejected. Both are ignored on tables with no primary key.</p>

        <div>
          <div>Template Parameters</div>

          <div>
            <table>
              <tr>
                <td>TRequest</td>
                <td>The type of object being added.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of table to be updated, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. Must be a currently existing table and not a view. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>expressions</td>
                <td>A list of the actual predicates, one for each update; format should follow the guidelines <a href="#ac5b65e73c01c331f1fcfb21b0e8d67ce">here</a>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>newValuesMaps</td>
                <td>List of new values for the matching records. Each element is a map with (key, value) pairs where the keys are the names of the columns whose values are to be updated; the values are the new values. The number of elements in the list should match the length of <span>expressions</span>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>data</td>
                <td>An <span>optional</span> list of new binary-avro encoded records to insert, one for each update. If one of <span>expressions</span> does not yield a matching record to be updated, then the corresponding element from this list will be added to the table. The default value is an empty vector. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#afcbdcbe97048f032546d0d11edf6c365">update\_records\_global\_expression</a>: An optional global expression to reduce the search space of the predicates listed in <span>expressions</span>. The default value is ''. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a3b69b89e59b979d4b18cb472ac74e3f7">update\_records\_bypass\_safety\_checks</a>: When set to <a href="/content/api/cpp/namespacegpudb#a285c1caa5b443115c8d8f7c8638740e6">true</a>, all predicates are available for primary key updates. Keep in mind that it is possible to destroy data in this case, since a single predicate may match multiple objects (potentially all of records of a table), and then updating all of those records to have the same primary key will, due to the primary key uniqueness constraints, effectively delete all but one of those updated records. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a285c1caa5b443115c8d8f7c8638740e6">update\_records\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#abb0d038b0eefbedd53545f6ec7e312b6">update\_records\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#abb0d038b0eefbedd53545f6ec7e312b6">update\_records\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#abb40caf1f8c69661ca410ffc19ea9d0f">update\_records\_error\_handling</a>: Specifies how record errors are handled during the update's reinsert (including any alternate insert records supplied via <span>data</span>). When set, this option is authoritative for the reinsert. Primary-key collision behavior is governed by <a href="/content/api/cpp/namespacegpudb#a7605a7a3a0274ce44efaa471344dcef2">update\_on\_existing\_pk</a> and <a href="/content/api/cpp/namespacegpudb#aba9511e40d021bad06b9dc8680f20ded">ignore\_existing\_pk</a>. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a6f0b4c7326c0de0eefe77ffc7a2bccb2">update\_records\_permissive</a>: Records with bad column values are kept when possible: the offending column is filled with its default value if one exists, otherwise with null if the column is nullable; if neither is possible the record is skipped and reported. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ab629a2a88c015e4833dbec0731799e9a">update\_records\_skip</a>: Records with bad values are skipped and reported; the rest of the batch is applied. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a512234873c8cc9a421649fbac2fd02b1">update\_records\_abort</a>: Stops the update and rejects the remaining batch when any record is incorrect. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a512234873c8cc9a421649fbac2fd02b1">update\_records\_abort</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a7605a7a3a0274ce44efaa471344dcef2">update\_records\_update\_on\_existing\_pk</a>: Specifies the record collision policy for updating a table with a <a href="/content/concepts/tables/#primary-keys">primary key</a>. There are two ways that a record collision can occur. The first is an "update collision", which happens when the update changes the value of the updated record's primary key, and that new primary key already exists as the primary key of another record in the table. The second is an "insert collision", which occurs when a given filter in <span>expressions</span> finds no records to update, and the alternate insert record given in <span>data</span> (or <span>recordsToInsertStr</span>) contains a primary key matching that of an existing record in the table. If <a href="/content/api/cpp/namespacegpudb#a7605a7a3a0274ce44efaa471344dcef2">update\_on\_existing\_pk</a> is set to <a href="/content/api/cpp/namespacegpudb#a285c1caa5b443115c8d8f7c8638740e6">true</a>, "update collisions" will result in the existing record collided into being removed and the record updated with values specified in <span>newValuesMaps</span> taking its place; "insert collisions" will result in the collided-into record being updated with the values in <span>data</span> / <span>recordsToInsertStr</span> (if given). If set to <a href="/content/api/cpp/namespacegpudb#abb0d038b0eefbedd53545f6ec7e312b6">false</a>, the existing collided-into record will remain unchanged, while the update will be rejected and the error handled as determined by <a href="/content/api/cpp/namespacegpudb#aba9511e40d021bad06b9dc8680f20ded">ignore\_existing\_pk</a>. If the specified table does not have a primary key, then this option has no effect. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a285c1caa5b443115c8d8f7c8638740e6">update\_records\_true</a>: Overwrite the collided-into record when updating a record's primary key or inserting an alternate record causes a primary key collision between the record being updated/inserted and another existing record in the table </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#abb0d038b0eefbedd53545f6ec7e312b6">update\_records\_false</a>: Reject updates which cause primary key collisions between the record being updated/inserted and an existing record in the table </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#abb0d038b0eefbedd53545f6ec7e312b6">update\_records\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a2de71c9660b5fe22e9b81a193883b0b2">update\_records\_pk\_conflict\_predicate\_higher</a>: The record with higher value for the column resolves the primary-key insert conflict. The default value is ''. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a57249f8219482449d3a883f1c1a9073d">update\_records\_pk\_conflict\_predicate\_lower</a>: The record with lower value for the column resolves the primary-key insert conflict. The default value is ''. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#aba9511e40d021bad06b9dc8680f20ded">update\_records\_ignore\_existing\_pk</a>: Specifies the record collision error-suppression policy for updating a table with a <a href="/content/concepts/tables/#primary-keys">primary key</a>, only used when primary key record collisions are rejected (<a href="/content/api/cpp/namespacegpudb#a7605a7a3a0274ce44efaa471344dcef2">update\_on\_existing\_pk</a> is <a href="/content/api/cpp/namespacegpudb#abb0d038b0eefbedd53545f6ec7e312b6">false</a>). If set to <a href="/content/api/cpp/namespacegpudb#a285c1caa5b443115c8d8f7c8638740e6">true</a>, any record update that is rejected for resulting in a primary key collision with an existing table record will be ignored with no error generated. If <a href="/content/api/cpp/namespacegpudb#abb0d038b0eefbedd53545f6ec7e312b6">false</a>, the rejection of any update for resulting in a primary key collision will cause an error to be reported. If the specified table does not have a primary key or if <a href="/content/api/cpp/namespacegpudb#a7605a7a3a0274ce44efaa471344dcef2">update\_on\_existing\_pk</a> is <a href="/content/api/cpp/namespacegpudb#a285c1caa5b443115c8d8f7c8638740e6">true</a>, then this option has no effect. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a285c1caa5b443115c8d8f7c8638740e6">update\_records\_true</a>: Ignore updates that result in primary key collisions with existing records. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#abb0d038b0eefbedd53545f6ec7e312b6">update\_records\_false</a>: Treat as errors any updates that result in primary key collisions with existing records. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#abb0d038b0eefbedd53545f6ec7e312b6">update\_records\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a8563f5f0f820e418db2f279f6e50ed46">update\_records\_update\_partition</a>: Force qualifying records to be deleted and reinserted so their partition membership will be reevaluated. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a285c1caa5b443115c8d8f7c8638740e6">update\_records\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#abb0d038b0eefbedd53545f6ec7e312b6">update\_records\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#abb0d038b0eefbedd53545f6ec7e312b6">update\_records\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a867bf5271cecb6a47d7254dd0a2a80e6">update\_records\_enable\_inplace\_updates</a>: If set to <a href="/content/api/cpp/namespacegpudb#a285c1caa5b443115c8d8f7c8638740e6">true</a>, qualifying records are modified in place. If set to <a href="/content/api/cpp/namespacegpudb#abb0d038b0eefbedd53545f6ec7e312b6">false</a>, they are updated by deleting the existing record and inserting a replacement (delete and insert), which prevents the change from being reflected in dependent materialized views until they are refreshed. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a285c1caa5b443115c8d8f7c8638740e6">update\_records\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#abb0d038b0eefbedd53545f6ec7e312b6">update\_records\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a285c1caa5b443115c8d8f7c8638740e6">update\_records\_true</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a8dee87951398b8f91f1076d69884a1ce">update\_records\_enable\_worker\_oop\_update</a>: For an out-of-place update (delete and insert), controls where the replacement records are reinserted. If set to <a href="/content/api/cpp/namespacegpudb#a285c1caa5b443115c8d8f7c8638740e6">true</a>, the workers that own the data reinsert them directly, avoiding a round trip through the head node; a shard-key change reshards the replacements to their new owning workers. If set to <a href="/content/api/cpp/namespacegpudb#abb0d038b0eefbedd53545f6ec7e312b6">false</a>, the replacement records are reinserted from the head node. Overrides the feature.enable\_worker\_oop\_update@ configuration default. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a285c1caa5b443115c8d8f7c8638740e6">update\_records\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#abb0d038b0eefbedd53545f6ec7e312b6">update\_records\_false</a> </li>
                      </ul>
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#add7d9885f8ee4c8626ca1382f1f2b693">update\_records\_truncate\_strings</a>: If set to <a href="/content/api/cpp/namespacegpudb#a285c1caa5b443115c8d8f7c8638740e6">true</a>, any strings which are too long for their charN string fields will be truncated to fit. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a285c1caa5b443115c8d8f7c8638740e6">update\_records\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#abb0d038b0eefbedd53545f6ec7e312b6">update\_records\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#abb0d038b0eefbedd53545f6ec7e312b6">update\_records\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#acb63acfa8b6cde789b126ee99561d5de">update\_records\_use\_expressions\_in\_new\_values\_maps</a>: When set to <a href="/content/api/cpp/namespacegpudb#a285c1caa5b443115c8d8f7c8638740e6">true</a>, all new values in <span>newValuesMaps</span> are considered as expression values. When set to <a href="/content/api/cpp/namespacegpudb#abb0d038b0eefbedd53545f6ec7e312b6">false</a>, all new values in <span>newValuesMaps</span> are considered as constants. NOTE: When <a href="/content/api/cpp/namespacegpudb#a285c1caa5b443115c8d8f7c8638740e6">true</a>, string constants will need to be quoted to avoid being evaluated as expressions. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a285c1caa5b443115c8d8f7c8638740e6">update\_records\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#abb0d038b0eefbedd53545f6ec7e312b6">update\_records\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#abb0d038b0eefbedd53545f6ec7e312b6">update\_records\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a7e44ada8bf08b366e29972017837ba70">update\_records\_record\_id</a>: ID of a single record to be updated (returned in the call to <a href="#a1cbbfefa7a3d6b4570f1be6734a8d849">insertRecords</a> or <a href="#ad07e8ca5da326049590fc62762c630a1">getRecordsFromCollection</a>). </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1UpdateRecordsResponse">Response</a> object containing the result of the operation. </div>
        </div>

        <p>Definition at line <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">53085</a> of file <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">GPUdb.hpp</a>.</p>
      </div>
    </div>

    <h2><span><a href="#a6d725e31070f46da74ac0b24254711da">◆ </a></span>updateRecords() <span>\[2/4]</span></h2>

    <div>
      <div>
        <div> template\<typename TRequest> </div>

        <table>
          <tr>
            <td>
              <table>
                <tr>
                  <td><a href="/content/api/cpp/structgpudb_1_1UpdateRecordsResponse">UpdateRecordsResponse</a> & gpudb::GPUdb::updateRecords </td>
                  <td>(</td>
                  <td>const std::string &</td>
                  <td><span><span>tableName</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const std::vector\< std::string > &</td>
                  <td><span><span>expressions</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const std::vector\< std::map\< std::string, boost::optional\< std::string > > > &</td>
                  <td><span><span>newValuesMaps</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const std::vector\< TRequest > &</td>
                  <td><span><span>data</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const std::map\< std::string, std::string > &</td>
                  <td><span><span>options</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td><a href="/content/api/cpp/structgpudb_1_1UpdateRecordsResponse">UpdateRecordsResponse</a> &</td>
                  <td><span><span>response\_</span></span> ) const</td>
                </tr>
              </table>
            </td>

            <td> <span><span>inline</span></span> </td>
          </tr>
        </table>
      </div>

      <div>
        <p>Runs multiple predicate-based updates in a single call. </p>
        <p>With the list of given expressions, any matching record's column values will be updated as provided in <span>newValuesMaps</span>. There is also an optional 'upsert' capability where if a particular predicate doesn't match any existing record, then a new record can be inserted.</p>
        <p>Note that this operation can only be run on an original table and not on a result view.</p>
        <p>This operation can update primary key values. By default only 'pure primary key' predicates are allowed when updating primary key values. If the primary key for a table is the column 'attr1', then the operation will only accept predicates of the form: "attr1 == 'foo'" if the attr1 column is being updated. For a composite primary key (e.g. columns 'attr1' and 'attr2') then this operation will only accept predicates of the form: "(attr1 == 'foo') and (attr2 == 'bar')". Meaning, all primary key columns must appear in an equality predicate in the expressions. Furthermore each 'pure primary key' predicate must be unique within a given request. These restrictions can be removed by utilizing some available options through <span>options</span>.</p>
        <p>The <a href="/content/api/cpp/namespacegpudb#a7605a7a3a0274ce44efaa471344dcef2">update\_on\_existing\_pk</a> option specifies the record primary key collision policy for tables with a <a href="/content/concepts/tables/#primary-keys">primary key</a>, while <a href="/content/api/cpp/namespacegpudb#aba9511e40d021bad06b9dc8680f20ded">ignore\_existing\_pk</a> specifies the record primary key collision error-suppression policy when those collisions result in the update being rejected. Both are ignored on tables with no primary key.</p>

        <div>
          <div>Template Parameters</div>

          <div>
            <table>
              <tr>
                <td>TRequest</td>
                <td>The type of object being added.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of table to be updated, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. Must be a currently existing table and not a view. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>expressions</td>
                <td>A list of the actual predicates, one for each update; format should follow the guidelines <a href="#ac5b65e73c01c331f1fcfb21b0e8d67ce">here</a>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>newValuesMaps</td>
                <td>List of new values for the matching records. Each element is a map with (key, value) pairs where the keys are the names of the columns whose values are to be updated; the values are the new values. The number of elements in the list should match the length of <span>expressions</span>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>data</td>
                <td>An <span>optional</span> list of new binary-avro encoded records to insert, one for each update. If one of <span>expressions</span> does not yield a matching record to be updated, then the corresponding element from this list will be added to the table. The default value is an empty vector. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#afcbdcbe97048f032546d0d11edf6c365">update\_records\_global\_expression</a>: An optional global expression to reduce the search space of the predicates listed in <span>expressions</span>. The default value is ''. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a3b69b89e59b979d4b18cb472ac74e3f7">update\_records\_bypass\_safety\_checks</a>: When set to <a href="/content/api/cpp/namespacegpudb#a285c1caa5b443115c8d8f7c8638740e6">true</a>, all predicates are available for primary key updates. Keep in mind that it is possible to destroy data in this case, since a single predicate may match multiple objects (potentially all of records of a table), and then updating all of those records to have the same primary key will, due to the primary key uniqueness constraints, effectively delete all but one of those updated records. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a285c1caa5b443115c8d8f7c8638740e6">update\_records\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#abb0d038b0eefbedd53545f6ec7e312b6">update\_records\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#abb0d038b0eefbedd53545f6ec7e312b6">update\_records\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#abb40caf1f8c69661ca410ffc19ea9d0f">update\_records\_error\_handling</a>: Specifies how record errors are handled during the update's reinsert (including any alternate insert records supplied via <span>data</span>). When set, this option is authoritative for the reinsert. Primary-key collision behavior is governed by <a href="/content/api/cpp/namespacegpudb#a7605a7a3a0274ce44efaa471344dcef2">update\_on\_existing\_pk</a> and <a href="/content/api/cpp/namespacegpudb#aba9511e40d021bad06b9dc8680f20ded">ignore\_existing\_pk</a>. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a6f0b4c7326c0de0eefe77ffc7a2bccb2">update\_records\_permissive</a>: Records with bad column values are kept when possible: the offending column is filled with its default value if one exists, otherwise with null if the column is nullable; if neither is possible the record is skipped and reported. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ab629a2a88c015e4833dbec0731799e9a">update\_records\_skip</a>: Records with bad values are skipped and reported; the rest of the batch is applied. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a512234873c8cc9a421649fbac2fd02b1">update\_records\_abort</a>: Stops the update and rejects the remaining batch when any record is incorrect. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a512234873c8cc9a421649fbac2fd02b1">update\_records\_abort</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a7605a7a3a0274ce44efaa471344dcef2">update\_records\_update\_on\_existing\_pk</a>: Specifies the record collision policy for updating a table with a <a href="/content/concepts/tables/#primary-keys">primary key</a>. There are two ways that a record collision can occur. The first is an "update collision", which happens when the update changes the value of the updated record's primary key, and that new primary key already exists as the primary key of another record in the table. The second is an "insert collision", which occurs when a given filter in <span>expressions</span> finds no records to update, and the alternate insert record given in <span>data</span> (or <span>recordsToInsertStr</span>) contains a primary key matching that of an existing record in the table. If <a href="/content/api/cpp/namespacegpudb#a7605a7a3a0274ce44efaa471344dcef2">update\_on\_existing\_pk</a> is set to <a href="/content/api/cpp/namespacegpudb#a285c1caa5b443115c8d8f7c8638740e6">true</a>, "update collisions" will result in the existing record collided into being removed and the record updated with values specified in <span>newValuesMaps</span> taking its place; "insert collisions" will result in the collided-into record being updated with the values in <span>data</span> / <span>recordsToInsertStr</span> (if given). If set to <a href="/content/api/cpp/namespacegpudb#abb0d038b0eefbedd53545f6ec7e312b6">false</a>, the existing collided-into record will remain unchanged, while the update will be rejected and the error handled as determined by <a href="/content/api/cpp/namespacegpudb#aba9511e40d021bad06b9dc8680f20ded">ignore\_existing\_pk</a>. If the specified table does not have a primary key, then this option has no effect. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a285c1caa5b443115c8d8f7c8638740e6">update\_records\_true</a>: Overwrite the collided-into record when updating a record's primary key or inserting an alternate record causes a primary key collision between the record being updated/inserted and another existing record in the table </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#abb0d038b0eefbedd53545f6ec7e312b6">update\_records\_false</a>: Reject updates which cause primary key collisions between the record being updated/inserted and an existing record in the table </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#abb0d038b0eefbedd53545f6ec7e312b6">update\_records\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a2de71c9660b5fe22e9b81a193883b0b2">update\_records\_pk\_conflict\_predicate\_higher</a>: The record with higher value for the column resolves the primary-key insert conflict. The default value is ''. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a57249f8219482449d3a883f1c1a9073d">update\_records\_pk\_conflict\_predicate\_lower</a>: The record with lower value for the column resolves the primary-key insert conflict. The default value is ''. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#aba9511e40d021bad06b9dc8680f20ded">update\_records\_ignore\_existing\_pk</a>: Specifies the record collision error-suppression policy for updating a table with a <a href="/content/concepts/tables/#primary-keys">primary key</a>, only used when primary key record collisions are rejected (<a href="/content/api/cpp/namespacegpudb#a7605a7a3a0274ce44efaa471344dcef2">update\_on\_existing\_pk</a> is <a href="/content/api/cpp/namespacegpudb#abb0d038b0eefbedd53545f6ec7e312b6">false</a>). If set to <a href="/content/api/cpp/namespacegpudb#a285c1caa5b443115c8d8f7c8638740e6">true</a>, any record update that is rejected for resulting in a primary key collision with an existing table record will be ignored with no error generated. If <a href="/content/api/cpp/namespacegpudb#abb0d038b0eefbedd53545f6ec7e312b6">false</a>, the rejection of any update for resulting in a primary key collision will cause an error to be reported. If the specified table does not have a primary key or if <a href="/content/api/cpp/namespacegpudb#a7605a7a3a0274ce44efaa471344dcef2">update\_on\_existing\_pk</a> is <a href="/content/api/cpp/namespacegpudb#a285c1caa5b443115c8d8f7c8638740e6">true</a>, then this option has no effect. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a285c1caa5b443115c8d8f7c8638740e6">update\_records\_true</a>: Ignore updates that result in primary key collisions with existing records. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#abb0d038b0eefbedd53545f6ec7e312b6">update\_records\_false</a>: Treat as errors any updates that result in primary key collisions with existing records. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#abb0d038b0eefbedd53545f6ec7e312b6">update\_records\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a8563f5f0f820e418db2f279f6e50ed46">update\_records\_update\_partition</a>: Force qualifying records to be deleted and reinserted so their partition membership will be reevaluated. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a285c1caa5b443115c8d8f7c8638740e6">update\_records\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#abb0d038b0eefbedd53545f6ec7e312b6">update\_records\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#abb0d038b0eefbedd53545f6ec7e312b6">update\_records\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a867bf5271cecb6a47d7254dd0a2a80e6">update\_records\_enable\_inplace\_updates</a>: If set to <a href="/content/api/cpp/namespacegpudb#a285c1caa5b443115c8d8f7c8638740e6">true</a>, qualifying records are modified in place. If set to <a href="/content/api/cpp/namespacegpudb#abb0d038b0eefbedd53545f6ec7e312b6">false</a>, they are updated by deleting the existing record and inserting a replacement (delete and insert), which prevents the change from being reflected in dependent materialized views until they are refreshed. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a285c1caa5b443115c8d8f7c8638740e6">update\_records\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#abb0d038b0eefbedd53545f6ec7e312b6">update\_records\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a285c1caa5b443115c8d8f7c8638740e6">update\_records\_true</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a8dee87951398b8f91f1076d69884a1ce">update\_records\_enable\_worker\_oop\_update</a>: For an out-of-place update (delete and insert), controls where the replacement records are reinserted. If set to <a href="/content/api/cpp/namespacegpudb#a285c1caa5b443115c8d8f7c8638740e6">true</a>, the workers that own the data reinsert them directly, avoiding a round trip through the head node; a shard-key change reshards the replacements to their new owning workers. If set to <a href="/content/api/cpp/namespacegpudb#abb0d038b0eefbedd53545f6ec7e312b6">false</a>, the replacement records are reinserted from the head node. Overrides the feature.enable\_worker\_oop\_update@ configuration default. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a285c1caa5b443115c8d8f7c8638740e6">update\_records\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#abb0d038b0eefbedd53545f6ec7e312b6">update\_records\_false</a> </li>
                      </ul>
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#add7d9885f8ee4c8626ca1382f1f2b693">update\_records\_truncate\_strings</a>: If set to <a href="/content/api/cpp/namespacegpudb#a285c1caa5b443115c8d8f7c8638740e6">true</a>, any strings which are too long for their charN string fields will be truncated to fit. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a285c1caa5b443115c8d8f7c8638740e6">update\_records\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#abb0d038b0eefbedd53545f6ec7e312b6">update\_records\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#abb0d038b0eefbedd53545f6ec7e312b6">update\_records\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#acb63acfa8b6cde789b126ee99561d5de">update\_records\_use\_expressions\_in\_new\_values\_maps</a>: When set to <a href="/content/api/cpp/namespacegpudb#a285c1caa5b443115c8d8f7c8638740e6">true</a>, all new values in <span>newValuesMaps</span> are considered as expression values. When set to <a href="/content/api/cpp/namespacegpudb#abb0d038b0eefbedd53545f6ec7e312b6">false</a>, all new values in <span>newValuesMaps</span> are considered as constants. NOTE: When <a href="/content/api/cpp/namespacegpudb#a285c1caa5b443115c8d8f7c8638740e6">true</a>, string constants will need to be quoted to avoid being evaluated as expressions. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a285c1caa5b443115c8d8f7c8638740e6">update\_records\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#abb0d038b0eefbedd53545f6ec7e312b6">update\_records\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#abb0d038b0eefbedd53545f6ec7e312b6">update\_records\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a7e44ada8bf08b366e29972017837ba70">update\_records\_record\_id</a>: ID of a single record to be updated (returned in the call to <a href="#a1cbbfefa7a3d6b4570f1be6734a8d849">insertRecords</a> or <a href="#ad07e8ca5da326049590fc62762c630a1">getRecordsFromCollection</a>). </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1UpdateRecordsResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1UpdateRecordsResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>

        <p>Definition at line <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">53433</a> of file <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">GPUdb.hpp</a>.</p>
      </div>
    </div>

    <h2><span><a href="#a9db9f3f48674be912871065a523157bd">◆ </a></span>updateRecords() <span>\[3/4]</span></h2>

    <div>
      <div>
        <div> template\<typename TRequest> </div>

        <table>
          <tr>
            <td>
              <table>
                <tr>
                  <td><a href="/content/api/cpp/structgpudb_1_1UpdateRecordsResponse">UpdateRecordsResponse</a> gpudb::GPUdb::updateRecords </td>
                  <td>(</td>
                  <td>const <a href="/content/api/cpp/structgpudb_1_1UpdateRecordsRequest">UpdateRecordsRequest</a>\< TRequest > &</td>
                  <td><span><span>request\_</span></span></td>
                  <td>)</td>
                  <td> const</td>
                </tr>
              </table>
            </td>

            <td> <span><span>inline</span></span> </td>
          </tr>
        </table>
      </div>

      <div>
        <p>Runs multiple predicate-based updates in a single call. </p>
        <p>With the list of given expressions, any matching record's column values will be updated as provided in <a href="/content/api/cpp/structgpudb_1_1UpdateRecordsRequest#aa8c782f275a2cdb43c450e327b9ed9af">newValuesMaps</a>. There is also an optional 'upsert' capability where if a particular predicate doesn't match any existing record, then a new record can be inserted.</p>
        <p>Note that this operation can only be run on an original table and not on a result view.</p>
        <p>This operation can update primary key values. By default only 'pure primary key' predicates are allowed when updating primary key values. If the primary key for a table is the column 'attr1', then the operation will only accept predicates of the form: "attr1 == 'foo'" if the attr1 column is being updated. For a composite primary key (e.g. columns 'attr1' and 'attr2') then this operation will only accept predicates of the form: "(attr1 == 'foo') and (attr2 == 'bar')". Meaning, all primary key columns must appear in an equality predicate in the expressions. Furthermore each 'pure primary key' predicate must be unique within a given request. These restrictions can be removed by utilizing some available options through <a href="/content/api/cpp/structgpudb_1_1UpdateRecordsRequest#a18fb3a3ccb139b176ff6368ad015cc49">options</a>.</p>
        <p>The <a href="/content/api/cpp/namespacegpudb#a7605a7a3a0274ce44efaa471344dcef2">update\_on\_existing\_pk</a> option specifies the record primary key collision policy for tables with a <a href="/content/concepts/tables/#primary-keys">primary key</a>, while <a href="/content/api/cpp/namespacegpudb#aba9511e40d021bad06b9dc8680f20ded">ignore\_existing\_pk</a> specifies the record primary key collision error-suppression policy when those collisions result in the update being rejected. Both are ignored on tables with no primary key.</p>

        <div>
          <div>Template Parameters</div>

          <div>
            <table>
              <tr>
                <td>TRequest</td>
                <td>The type of object being added.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1UpdateRecordsRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1UpdateRecordsResponse">Response</a> object containing the result of the operation. </div>
        </div>

        <p>Definition at line <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">52688</a> of file <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">GPUdb.hpp</a>.</p>
      </div>
    </div>

    <h2><span><a href="#a4807b97a4e4bf7fc1c59f216850e17e8">◆ </a></span>updateRecords() <span>\[4/4]</span></h2>

    <div>
      <div>
        <div> template\<typename TRequest> </div>

        <table>
          <tr>
            <td>
              <table>
                <tr>
                  <td><a href="/content/api/cpp/structgpudb_1_1UpdateRecordsResponse">UpdateRecordsResponse</a> & gpudb::GPUdb::updateRecords </td>
                  <td>(</td>
                  <td>const <a href="/content/api/cpp/structgpudb_1_1UpdateRecordsRequest">UpdateRecordsRequest</a>\< TRequest > &</td>
                  <td><span><span>request\_</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td><a href="/content/api/cpp/structgpudb_1_1UpdateRecordsResponse">UpdateRecordsResponse</a> &</td>
                  <td><span><span>response\_</span></span> ) const</td>
                </tr>
              </table>
            </td>

            <td> <span><span>inline</span></span> </td>
          </tr>
        </table>
      </div>

      <div>
        <p>Runs multiple predicate-based updates in a single call. </p>
        <p>With the list of given expressions, any matching record's column values will be updated as provided in <a href="/content/api/cpp/structgpudb_1_1UpdateRecordsRequest#aa8c782f275a2cdb43c450e327b9ed9af">newValuesMaps</a>. There is also an optional 'upsert' capability where if a particular predicate doesn't match any existing record, then a new record can be inserted.</p>
        <p>Note that this operation can only be run on an original table and not on a result view.</p>
        <p>This operation can update primary key values. By default only 'pure primary key' predicates are allowed when updating primary key values. If the primary key for a table is the column 'attr1', then the operation will only accept predicates of the form: "attr1 == 'foo'" if the attr1 column is being updated. For a composite primary key (e.g. columns 'attr1' and 'attr2') then this operation will only accept predicates of the form: "(attr1 == 'foo') and (attr2 == 'bar')". Meaning, all primary key columns must appear in an equality predicate in the expressions. Furthermore each 'pure primary key' predicate must be unique within a given request. These restrictions can be removed by utilizing some available options through <a href="/content/api/cpp/structgpudb_1_1UpdateRecordsRequest#a18fb3a3ccb139b176ff6368ad015cc49">options</a>.</p>
        <p>The <a href="/content/api/cpp/namespacegpudb#a7605a7a3a0274ce44efaa471344dcef2">update\_on\_existing\_pk</a> option specifies the record primary key collision policy for tables with a <a href="/content/concepts/tables/#primary-keys">primary key</a>, while <a href="/content/api/cpp/namespacegpudb#aba9511e40d021bad06b9dc8680f20ded">ignore\_existing\_pk</a> specifies the record primary key collision error-suppression policy when those collisions result in the update being rejected. Both are ignored on tables with no primary key.</p>

        <div>
          <div>Template Parameters</div>

          <div>
            <table>
              <tr>
                <td>TRequest</td>
                <td>The type of object being added.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1UpdateRecordsRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1UpdateRecordsResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1UpdateRecordsResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>

        <p>Definition at line <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">52743</a> of file <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">GPUdb.hpp</a>.</p>
      </div>
    </div>

    <h2><span><a href="#afa5f0d470237751f291fc535cff990e7">◆ </a></span>updateRecordsRaw() <span>\[1/2]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1UpdateRecordsResponse">UpdateRecordsResponse</a> gpudb::GPUdb::updateRecordsRaw </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1RawUpdateRecordsRequest">RawUpdateRecordsRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Runs multiple predicate-based updates in a single call. </p>
        <p>With the list of given expressions, any matching record's column values will be updated as provided in <a href="/content/api/cpp/structgpudb_1_1RawUpdateRecordsRequest#a08649327276a2c1ecfef5f0a574e4a95">newValuesMaps</a>. There is also an optional 'upsert' capability where if a particular predicate doesn't match any existing record, then a new record can be inserted.</p>
        <p>Note that this operation can only be run on an original table and not on a result view.</p>
        <p>This operation can update primary key values. By default only 'pure primary key' predicates are allowed when updating primary key values. If the primary key for a table is the column 'attr1', then the operation will only accept predicates of the form: "attr1 == 'foo'" if the attr1 column is being updated. For a composite primary key (e.g. columns 'attr1' and 'attr2') then this operation will only accept predicates of the form: "(attr1 == 'foo') and (attr2 == 'bar')". Meaning, all primary key columns must appear in an equality predicate in the expressions. Furthermore each 'pure primary key' predicate must be unique within a given request. These restrictions can be removed by utilizing some available options through <a href="/content/api/cpp/structgpudb_1_1RawUpdateRecordsRequest#a1414565b5a00d5872f69b34a4b37abac">options</a>.</p>
        <p>The <a href="/content/api/cpp/namespacegpudb#a7605a7a3a0274ce44efaa471344dcef2">update\_on\_existing\_pk</a> option specifies the record primary key collision policy for tables with a <a href="/content/concepts/tables/#primary-keys">primary key</a>, while <a href="/content/api/cpp/namespacegpudb#aba9511e40d021bad06b9dc8680f20ded">ignore\_existing\_pk</a> specifies the record primary key collision error-suppression policy when those collisions result in the update being rejected. Both are ignored on tables with no primary key.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1RawUpdateRecordsRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1UpdateRecordsResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#abc974f0c50ac67f437c2c388a91273d4">◆ </a></span>updateRecordsRaw() <span>\[2/2]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1UpdateRecordsResponse">UpdateRecordsResponse</a> & gpudb::GPUdb::updateRecordsRaw </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1RawUpdateRecordsRequest">RawUpdateRecordsRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1UpdateRecordsResponse">UpdateRecordsResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Runs multiple predicate-based updates in a single call. </p>
        <p>With the list of given expressions, any matching record's column values will be updated as provided in <a href="/content/api/cpp/structgpudb_1_1RawUpdateRecordsRequest#a08649327276a2c1ecfef5f0a574e4a95">newValuesMaps</a>. There is also an optional 'upsert' capability where if a particular predicate doesn't match any existing record, then a new record can be inserted.</p>
        <p>Note that this operation can only be run on an original table and not on a result view.</p>
        <p>This operation can update primary key values. By default only 'pure primary key' predicates are allowed when updating primary key values. If the primary key for a table is the column 'attr1', then the operation will only accept predicates of the form: "attr1 == 'foo'" if the attr1 column is being updated. For a composite primary key (e.g. columns 'attr1' and 'attr2') then this operation will only accept predicates of the form: "(attr1 == 'foo') and (attr2 == 'bar')". Meaning, all primary key columns must appear in an equality predicate in the expressions. Furthermore each 'pure primary key' predicate must be unique within a given request. These restrictions can be removed by utilizing some available options through <a href="/content/api/cpp/structgpudb_1_1RawUpdateRecordsRequest#a1414565b5a00d5872f69b34a4b37abac">options</a>.</p>
        <p>The <a href="/content/api/cpp/namespacegpudb#a7605a7a3a0274ce44efaa471344dcef2">update\_on\_existing\_pk</a> option specifies the record primary key collision policy for tables with a <a href="/content/concepts/tables/#primary-keys">primary key</a>, while <a href="/content/api/cpp/namespacegpudb#aba9511e40d021bad06b9dc8680f20ded">ignore\_existing\_pk</a> specifies the record primary key collision error-suppression policy when those collisions result in the update being rejected. Both are ignored on tables with no primary key.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1RawUpdateRecordsRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1UpdateRecordsResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1UpdateRecordsResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a536c56e50bedb45ae384af8de3b6483a">◆ </a></span>uploadFiles() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1UploadFilesResponse">UploadFilesResponse</a> gpudb::GPUdb::uploadFiles </td>
            <td>(</td>
            <td>const std::vector\< std::string > &</td>
            <td><span><span>fileNames</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< std::vector\< uint8\_t > > &</td>
            <td><span><span>fileData</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Uploads one or more files to <a href="/content/tools/kifs/">KiFS</a>. </p>
        <p>There are two methods for uploading files: load files in their entirety, or load files in parts. The latter is recommended for files of approximately 60 MB or larger.</p>
        <p>To upload files in their entirety, populate <span>fileNames</span> with the file names to upload into on KiFS, and their respective byte content in <span>fileData</span>.</p>
        <p>Multiple steps are involved when uploading in multiple parts. Only one file at a time can be uploaded in this manner. A user-provided UUID is utilized to tie all the upload steps together for a given file. To upload a file in multiple parts:</p>

        <ol type="1">
          <li>Provide the file name in <span>fileNames</span>, the UUID in the <a href="/content/api/cpp/namespacegpudb#a65246e8181f323fb96754920c739c729">multipart\_upload\_uuid</a> key in <span>options</span>, and a <a href="/content/api/cpp/namespacegpudb#aefa497aafc701aeec6547ed26d7cd3f9">multipart\_operation</a> value of <a href="/content/api/cpp/namespacegpudb#a3201903fca3dce04ad707acf29ef8c10">init</a>.</li>
          <li>Upload one or more parts by providing the file name, the part data in <span>fileData</span>, the UUID, a <a href="/content/api/cpp/namespacegpudb#aefa497aafc701aeec6547ed26d7cd3f9">multipart\_operation</a> value of <a href="/content/api/cpp/namespacegpudb#a7aabace8d060d2d116d535c7ffaf321e">upload\_part</a>, and the part number in the <a href="/content/api/cpp/namespacegpudb#ab7bdf631809f0261f4d848272e454707">multipart\_upload\_part\_number</a>. The part numbers must start at 1 and increase incrementally. Parts may not be uploaded out of order.</li>
          <li>Complete the upload by providing the file name, the UUID, and a <a href="/content/api/cpp/namespacegpudb#aefa497aafc701aeec6547ed26d7cd3f9">multipart\_operation</a> value of <a href="/content/api/cpp/namespacegpudb#a5346cda4a05914f26713e5ef38d9556d">complete</a>.</li>
        </ol>

        <p>Multipart uploads in progress may be canceled by providing the file name, the UUID, and a <a href="/content/api/cpp/namespacegpudb#aefa497aafc701aeec6547ed26d7cd3f9">multipart\_operation</a> value of <a href="/content/api/cpp/namespacegpudb#adf4f84c5144965902ec3b8a4b378e784">cancel</a>. If an new upload is initialized with a different UUID for an existing upload in progress, the pre-existing upload is automatically canceled in favor of the new upload.</p>
        <p>The multipart upload must be completed for the file to be usable in KiFS. Information about multipart uploads in progress is available in <a href="#a96bb343ffbdcbfdfa09e2cb3d850b12f">showFiles</a>.</p>
        <p>File data may be pre-encoded using base64 encoding. This should be indicated using the <a href="/content/api/cpp/namespacegpudb#a95bfae57ffedca8f66cacc69c59d9c82">file\_encoding</a> option, and is recommended when using JSON serialization.</p>
        <p>Each file path must reside in a top-level KiFS directory, i.e. one of the directories listed in <a href="#a9c29f706c737f08808675066fe0cb14a">showDirectories</a>. The user must have write permission on the directory. Nested directories are permitted in file name paths. Directories are delineated with the directory separator of '/'. For example, given the file path '/a/b/c/d.txt', 'a' must be a KiFS directory.</p>
        <p>These characters are allowed in file name paths: letters, numbers, spaces, the path delimiter of '/', and the characters: '.' '-' ':' '\[' ']' '(' ')' '#' '='.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>fileNames</td>
                <td>An array of full file name paths to be used for the files uploaded to KiFS. File names may have any number of nested directories in their paths, but the top-level directory must be an existing KiFS directory. Each file must reside in or under a top-level directory. A full file name path cannot be larger than 1024 characters. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>fileData</td>
                <td>File data for the files being uploaded, for the respective files in <span>fileNames</span>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a95bfae57ffedca8f66cacc69c59d9c82">upload\_files\_file\_encoding</a>: Encoding that has been applied to the uploaded file data. When using JSON serialization it is recommended to utilize <a href="/content/api/cpp/namespacegpudb#abc24dd0ea3385cd1c9c16250efb6198b">base64</a>. The caller is responsible for encoding the data provided in this payload. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#abc24dd0ea3385cd1c9c16250efb6198b">upload\_files\_base64</a>: Specifies that the file data being uploaded has been base64 encoded. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a24ccdfbeae55019c35ff0e75c02c7e99">upload\_files\_none</a>: The uploaded file data has not been encoded. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a24ccdfbeae55019c35ff0e75c02c7e99">upload\_files\_none</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#aefa497aafc701aeec6547ed26d7cd3f9">upload\_files\_multipart\_operation</a>: Multipart upload operation to perform. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a24ccdfbeae55019c35ff0e75c02c7e99">upload\_files\_none</a>: Default, indicates this is not a multipart upload. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a3201903fca3dce04ad707acf29ef8c10">upload\_files\_init</a>: Initialize a multipart file upload. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a7aabace8d060d2d116d535c7ffaf321e">upload\_files\_upload\_part</a>: Uploads a part of the specified multipart file upload. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a5346cda4a05914f26713e5ef38d9556d">upload\_files\_complete</a>: Complete the specified multipart file upload. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#adf4f84c5144965902ec3b8a4b378e784">upload\_files\_cancel</a>: Cancel the specified multipart file upload. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a24ccdfbeae55019c35ff0e75c02c7e99">upload\_files\_none</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a65246e8181f323fb96754920c739c729">upload\_files\_multipart\_upload\_uuid</a>: UUID to uniquely identify a multipart upload. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ab7bdf631809f0261f4d848272e454707">upload\_files\_multipart\_upload\_part\_number</a>: Incremental part number for each part in a multipart upload. Part numbers start at 1, increment by 1, and must be uploaded sequentially </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#aeb96de16614aae3e73110ecb21c528bb">upload\_files\_delete\_if\_exists</a>: If <a href="/content/api/cpp/namespacegpudb#a41c732a8e805c01030afa230c5161499">true</a>, any existing files specified in <span>fileNames</span> will be deleted prior to start of upload. Otherwise the file is replaced once the upload completes. Rollback of the original file is no longer possible if the upload is cancelled, aborted or fails if the file was deleted beforehand. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a41c732a8e805c01030afa230c5161499">upload\_files\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ae1e8ec0f953598ae77b2d34e02910a43">upload\_files\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ae1e8ec0f953598ae77b2d34e02910a43">upload\_files\_false</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1UploadFilesResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a93bc72bce3e201e33b4a41ced2e514a4">◆ </a></span>uploadFiles() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1UploadFilesResponse">UploadFilesResponse</a> & gpudb::GPUdb::uploadFiles </td>
            <td>(</td>
            <td>const std::vector\< std::string > &</td>
            <td><span><span>fileNames</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< std::vector\< uint8\_t > > &</td>
            <td><span><span>fileData</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1UploadFilesResponse">UploadFilesResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Uploads one or more files to <a href="/content/tools/kifs/">KiFS</a>. </p>
        <p>There are two methods for uploading files: load files in their entirety, or load files in parts. The latter is recommended for files of approximately 60 MB or larger.</p>
        <p>To upload files in their entirety, populate <span>fileNames</span> with the file names to upload into on KiFS, and their respective byte content in <span>fileData</span>.</p>
        <p>Multiple steps are involved when uploading in multiple parts. Only one file at a time can be uploaded in this manner. A user-provided UUID is utilized to tie all the upload steps together for a given file. To upload a file in multiple parts:</p>

        <ol type="1">
          <li>Provide the file name in <span>fileNames</span>, the UUID in the <a href="/content/api/cpp/namespacegpudb#a65246e8181f323fb96754920c739c729">multipart\_upload\_uuid</a> key in <span>options</span>, and a <a href="/content/api/cpp/namespacegpudb#aefa497aafc701aeec6547ed26d7cd3f9">multipart\_operation</a> value of <a href="/content/api/cpp/namespacegpudb#a3201903fca3dce04ad707acf29ef8c10">init</a>.</li>
          <li>Upload one or more parts by providing the file name, the part data in <span>fileData</span>, the UUID, a <a href="/content/api/cpp/namespacegpudb#aefa497aafc701aeec6547ed26d7cd3f9">multipart\_operation</a> value of <a href="/content/api/cpp/namespacegpudb#a7aabace8d060d2d116d535c7ffaf321e">upload\_part</a>, and the part number in the <a href="/content/api/cpp/namespacegpudb#ab7bdf631809f0261f4d848272e454707">multipart\_upload\_part\_number</a>. The part numbers must start at 1 and increase incrementally. Parts may not be uploaded out of order.</li>
          <li>Complete the upload by providing the file name, the UUID, and a <a href="/content/api/cpp/namespacegpudb#aefa497aafc701aeec6547ed26d7cd3f9">multipart\_operation</a> value of <a href="/content/api/cpp/namespacegpudb#a5346cda4a05914f26713e5ef38d9556d">complete</a>.</li>
        </ol>

        <p>Multipart uploads in progress may be canceled by providing the file name, the UUID, and a <a href="/content/api/cpp/namespacegpudb#aefa497aafc701aeec6547ed26d7cd3f9">multipart\_operation</a> value of <a href="/content/api/cpp/namespacegpudb#adf4f84c5144965902ec3b8a4b378e784">cancel</a>. If an new upload is initialized with a different UUID for an existing upload in progress, the pre-existing upload is automatically canceled in favor of the new upload.</p>
        <p>The multipart upload must be completed for the file to be usable in KiFS. Information about multipart uploads in progress is available in <a href="#a96bb343ffbdcbfdfa09e2cb3d850b12f">showFiles</a>.</p>
        <p>File data may be pre-encoded using base64 encoding. This should be indicated using the <a href="/content/api/cpp/namespacegpudb#a95bfae57ffedca8f66cacc69c59d9c82">file\_encoding</a> option, and is recommended when using JSON serialization.</p>
        <p>Each file path must reside in a top-level KiFS directory, i.e. one of the directories listed in <a href="#a9c29f706c737f08808675066fe0cb14a">showDirectories</a>. The user must have write permission on the directory. Nested directories are permitted in file name paths. Directories are delineated with the directory separator of '/'. For example, given the file path '/a/b/c/d.txt', 'a' must be a KiFS directory.</p>
        <p>These characters are allowed in file name paths: letters, numbers, spaces, the path delimiter of '/', and the characters: '.' '-' ':' '\[' ']' '(' ')' '#' '='.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>fileNames</td>
                <td>An array of full file name paths to be used for the files uploaded to KiFS. File names may have any number of nested directories in their paths, but the top-level directory must be an existing KiFS directory. Each file must reside in or under a top-level directory. A full file name path cannot be larger than 1024 characters. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>fileData</td>
                <td>File data for the files being uploaded, for the respective files in <span>fileNames</span>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a95bfae57ffedca8f66cacc69c59d9c82">upload\_files\_file\_encoding</a>: Encoding that has been applied to the uploaded file data. When using JSON serialization it is recommended to utilize <a href="/content/api/cpp/namespacegpudb#abc24dd0ea3385cd1c9c16250efb6198b">base64</a>. The caller is responsible for encoding the data provided in this payload. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#abc24dd0ea3385cd1c9c16250efb6198b">upload\_files\_base64</a>: Specifies that the file data being uploaded has been base64 encoded. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a24ccdfbeae55019c35ff0e75c02c7e99">upload\_files\_none</a>: The uploaded file data has not been encoded. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a24ccdfbeae55019c35ff0e75c02c7e99">upload\_files\_none</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#aefa497aafc701aeec6547ed26d7cd3f9">upload\_files\_multipart\_operation</a>: Multipart upload operation to perform. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a24ccdfbeae55019c35ff0e75c02c7e99">upload\_files\_none</a>: Default, indicates this is not a multipart upload. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a3201903fca3dce04ad707acf29ef8c10">upload\_files\_init</a>: Initialize a multipart file upload. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a7aabace8d060d2d116d535c7ffaf321e">upload\_files\_upload\_part</a>: Uploads a part of the specified multipart file upload. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a5346cda4a05914f26713e5ef38d9556d">upload\_files\_complete</a>: Complete the specified multipart file upload. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#adf4f84c5144965902ec3b8a4b378e784">upload\_files\_cancel</a>: Cancel the specified multipart file upload. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a24ccdfbeae55019c35ff0e75c02c7e99">upload\_files\_none</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a65246e8181f323fb96754920c739c729">upload\_files\_multipart\_upload\_uuid</a>: UUID to uniquely identify a multipart upload. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ab7bdf631809f0261f4d848272e454707">upload\_files\_multipart\_upload\_part\_number</a>: Incremental part number for each part in a multipart upload. Part numbers start at 1, increment by 1, and must be uploaded sequentially </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#aeb96de16614aae3e73110ecb21c528bb">upload\_files\_delete\_if\_exists</a>: If <a href="/content/api/cpp/namespacegpudb#a41c732a8e805c01030afa230c5161499">true</a>, any existing files specified in <span>fileNames</span> will be deleted prior to start of upload. Otherwise the file is replaced once the upload completes. Rollback of the original file is no longer possible if the upload is cancelled, aborted or fails if the file was deleted beforehand. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a41c732a8e805c01030afa230c5161499">upload\_files\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ae1e8ec0f953598ae77b2d34e02910a43">upload\_files\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ae1e8ec0f953598ae77b2d34e02910a43">upload\_files\_false</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1UploadFilesResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1UploadFilesResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#abf858a844a619c04135d680ce9a2fe4c">◆ </a></span>uploadFiles() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1UploadFilesResponse">UploadFilesResponse</a> gpudb::GPUdb::uploadFiles </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1UploadFilesRequest">UploadFilesRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Uploads one or more files to <a href="/content/tools/kifs/">KiFS</a>. </p>
        <p>There are two methods for uploading files: load files in their entirety, or load files in parts. The latter is recommended for files of approximately 60 MB or larger.</p>
        <p>To upload files in their entirety, populate <a href="/content/api/cpp/structgpudb_1_1UploadFilesRequest#a635c1a228f350b94ac8e87aea41074c3">fileNames</a> with the file names to upload into on KiFS, and their respective byte content in <a href="/content/api/cpp/structgpudb_1_1UploadFilesRequest#a116f2ceace6df94cd9420a5f9f1b89d1">fileData</a>.</p>
        <p>Multiple steps are involved when uploading in multiple parts. Only one file at a time can be uploaded in this manner. A user-provided UUID is utilized to tie all the upload steps together for a given file. To upload a file in multiple parts:</p>

        <ol type="1">
          <li>Provide the file name in <a href="/content/api/cpp/structgpudb_1_1UploadFilesRequest#a635c1a228f350b94ac8e87aea41074c3">fileNames</a>, the UUID in the <a href="/content/api/cpp/namespacegpudb#a65246e8181f323fb96754920c739c729">multipart\_upload\_uuid</a> key in <a href="/content/api/cpp/structgpudb_1_1UploadFilesRequest#a9be7f5ebb5c62f79a09b0bade94bc858">options</a>, and a <a href="/content/api/cpp/namespacegpudb#aefa497aafc701aeec6547ed26d7cd3f9">multipart\_operation</a> value of <a href="/content/api/cpp/namespacegpudb#a3201903fca3dce04ad707acf29ef8c10">init</a>.</li>
          <li>Upload one or more parts by providing the file name, the part data in <a href="/content/api/cpp/structgpudb_1_1UploadFilesRequest#a116f2ceace6df94cd9420a5f9f1b89d1">fileData</a>, the UUID, a <a href="/content/api/cpp/namespacegpudb#aefa497aafc701aeec6547ed26d7cd3f9">multipart\_operation</a> value of <a href="/content/api/cpp/namespacegpudb#a7aabace8d060d2d116d535c7ffaf321e">upload\_part</a>, and the part number in the <a href="/content/api/cpp/namespacegpudb#ab7bdf631809f0261f4d848272e454707">multipart\_upload\_part\_number</a>. The part numbers must start at 1 and increase incrementally. Parts may not be uploaded out of order.</li>
          <li>Complete the upload by providing the file name, the UUID, and a <a href="/content/api/cpp/namespacegpudb#aefa497aafc701aeec6547ed26d7cd3f9">multipart\_operation</a> value of <a href="/content/api/cpp/namespacegpudb#a5346cda4a05914f26713e5ef38d9556d">complete</a>.</li>
        </ol>

        <p>Multipart uploads in progress may be canceled by providing the file name, the UUID, and a <a href="/content/api/cpp/namespacegpudb#aefa497aafc701aeec6547ed26d7cd3f9">multipart\_operation</a> value of <a href="/content/api/cpp/namespacegpudb#adf4f84c5144965902ec3b8a4b378e784">cancel</a>. If an new upload is initialized with a different UUID for an existing upload in progress, the pre-existing upload is automatically canceled in favor of the new upload.</p>
        <p>The multipart upload must be completed for the file to be usable in KiFS. Information about multipart uploads in progress is available in <a href="#a25eed62c5697242506cc5e336925b45d">showFiles</a>.</p>
        <p>File data may be pre-encoded using base64 encoding. This should be indicated using the <a href="/content/api/cpp/namespacegpudb#a95bfae57ffedca8f66cacc69c59d9c82">file\_encoding</a> option, and is recommended when using JSON serialization.</p>
        <p>Each file path must reside in a top-level KiFS directory, i.e. one of the directories listed in <a href="#a4938a2b931ab7710d13c4eb46caeb79b">showDirectories</a>. The user must have write permission on the directory. Nested directories are permitted in file name paths. Directories are delineated with the directory separator of '/'. For example, given the file path '/a/b/c/d.txt', 'a' must be a KiFS directory.</p>
        <p>These characters are allowed in file name paths: letters, numbers, spaces, the path delimiter of '/', and the characters: '.' '-' ':' '\[' ']' '(' ')' '#' '='.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1UploadFilesRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1UploadFilesResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#afcd36af3a42361e0ed7d8faaf8eef005">◆ </a></span>uploadFiles() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1UploadFilesResponse">UploadFilesResponse</a> & gpudb::GPUdb::uploadFiles </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1UploadFilesRequest">UploadFilesRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1UploadFilesResponse">UploadFilesResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Uploads one or more files to <a href="/content/tools/kifs/">KiFS</a>. </p>
        <p>There are two methods for uploading files: load files in their entirety, or load files in parts. The latter is recommended for files of approximately 60 MB or larger.</p>
        <p>To upload files in their entirety, populate <a href="/content/api/cpp/structgpudb_1_1UploadFilesRequest#a635c1a228f350b94ac8e87aea41074c3">fileNames</a> with the file names to upload into on KiFS, and their respective byte content in <a href="/content/api/cpp/structgpudb_1_1UploadFilesRequest#a116f2ceace6df94cd9420a5f9f1b89d1">fileData</a>.</p>
        <p>Multiple steps are involved when uploading in multiple parts. Only one file at a time can be uploaded in this manner. A user-provided UUID is utilized to tie all the upload steps together for a given file. To upload a file in multiple parts:</p>

        <ol type="1">
          <li>Provide the file name in <a href="/content/api/cpp/structgpudb_1_1UploadFilesRequest#a635c1a228f350b94ac8e87aea41074c3">fileNames</a>, the UUID in the <a href="/content/api/cpp/namespacegpudb#a65246e8181f323fb96754920c739c729">multipart\_upload\_uuid</a> key in <a href="/content/api/cpp/structgpudb_1_1UploadFilesRequest#a9be7f5ebb5c62f79a09b0bade94bc858">options</a>, and a <a href="/content/api/cpp/namespacegpudb#aefa497aafc701aeec6547ed26d7cd3f9">multipart\_operation</a> value of <a href="/content/api/cpp/namespacegpudb#a3201903fca3dce04ad707acf29ef8c10">init</a>.</li>
          <li>Upload one or more parts by providing the file name, the part data in <a href="/content/api/cpp/structgpudb_1_1UploadFilesRequest#a116f2ceace6df94cd9420a5f9f1b89d1">fileData</a>, the UUID, a <a href="/content/api/cpp/namespacegpudb#aefa497aafc701aeec6547ed26d7cd3f9">multipart\_operation</a> value of <a href="/content/api/cpp/namespacegpudb#a7aabace8d060d2d116d535c7ffaf321e">upload\_part</a>, and the part number in the <a href="/content/api/cpp/namespacegpudb#ab7bdf631809f0261f4d848272e454707">multipart\_upload\_part\_number</a>. The part numbers must start at 1 and increase incrementally. Parts may not be uploaded out of order.</li>
          <li>Complete the upload by providing the file name, the UUID, and a <a href="/content/api/cpp/namespacegpudb#aefa497aafc701aeec6547ed26d7cd3f9">multipart\_operation</a> value of <a href="/content/api/cpp/namespacegpudb#a5346cda4a05914f26713e5ef38d9556d">complete</a>.</li>
        </ol>

        <p>Multipart uploads in progress may be canceled by providing the file name, the UUID, and a <a href="/content/api/cpp/namespacegpudb#aefa497aafc701aeec6547ed26d7cd3f9">multipart\_operation</a> value of <a href="/content/api/cpp/namespacegpudb#adf4f84c5144965902ec3b8a4b378e784">cancel</a>. If an new upload is initialized with a different UUID for an existing upload in progress, the pre-existing upload is automatically canceled in favor of the new upload.</p>
        <p>The multipart upload must be completed for the file to be usable in KiFS. Information about multipart uploads in progress is available in <a href="#a25eed62c5697242506cc5e336925b45d">showFiles</a>.</p>
        <p>File data may be pre-encoded using base64 encoding. This should be indicated using the <a href="/content/api/cpp/namespacegpudb#a95bfae57ffedca8f66cacc69c59d9c82">file\_encoding</a> option, and is recommended when using JSON serialization.</p>
        <p>Each file path must reside in a top-level KiFS directory, i.e. one of the directories listed in <a href="#a4938a2b931ab7710d13c4eb46caeb79b">showDirectories</a>. The user must have write permission on the directory. Nested directories are permitted in file name paths. Directories are delineated with the directory separator of '/'. For example, given the file path '/a/b/c/d.txt', 'a' must be a KiFS directory.</p>
        <p>These characters are allowed in file name paths: letters, numbers, spaces, the path delimiter of '/', and the characters: '.' '-' ':' '\[' ']' '(' ')' '#' '='.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1UploadFilesRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1UploadFilesResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1UploadFilesResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a8632d9278407bd6b2010f0bb50e5c4b9">◆ </a></span>uploadFilesFromurl() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1UploadFilesFromurlResponse">UploadFilesFromurlResponse</a> gpudb::GPUdb::uploadFilesFromurl </td>
            <td>(</td>
            <td>const std::vector\< std::string > &</td>
            <td><span><span>fileNames</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< std::string > &</td>
            <td><span><span>urls</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Uploads one or more files to <a href="/content/tools/kifs/">KiFS</a>. </p>
        <p>Each file path must reside in a top-level KiFS directory, i.e. one of the directories listed in <a href="#a9c29f706c737f08808675066fe0cb14a">showDirectories</a>. The user must have write permission on the directory. Nested directories are permitted in file name paths. Directories are delineated with the directory separator of '/'. For example, given the file path '/a/b/c/d.txt', 'a' must be a KiFS directory.</p>
        <p>These characters are allowed in file name paths: letters, numbers, spaces, the path delimiter of '/', and the characters: '.' '-' ':' '\[' ']' '(' ')' '#' '='.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>fileNames</td>
                <td>An array of full file name paths to be used for the files uploaded to KiFS. File names may have any number of nested directories in their paths, but the top-level directory must be an existing KiFS directory. Each file must reside in or under a top-level directory. A full file name path cannot be larger than 1024 characters. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>urls</td>
                <td>List of URLs to upload, for each respective file in <span>fileNames</span>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1UploadFilesFromurlResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a7afbe9b58aca628f2d85a321c34c0a12">◆ </a></span>uploadFilesFromurl() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1UploadFilesFromurlResponse">UploadFilesFromurlResponse</a> & gpudb::GPUdb::uploadFilesFromurl </td>
            <td>(</td>
            <td>const std::vector\< std::string > &</td>
            <td><span><span>fileNames</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< std::string > &</td>
            <td><span><span>urls</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1UploadFilesFromurlResponse">UploadFilesFromurlResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Uploads one or more files to <a href="/content/tools/kifs/">KiFS</a>. </p>
        <p>Each file path must reside in a top-level KiFS directory, i.e. one of the directories listed in <a href="#a9c29f706c737f08808675066fe0cb14a">showDirectories</a>. The user must have write permission on the directory. Nested directories are permitted in file name paths. Directories are delineated with the directory separator of '/'. For example, given the file path '/a/b/c/d.txt', 'a' must be a KiFS directory.</p>
        <p>These characters are allowed in file name paths: letters, numbers, spaces, the path delimiter of '/', and the characters: '.' '-' ':' '\[' ']' '(' ')' '#' '='.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>fileNames</td>
                <td>An array of full file name paths to be used for the files uploaded to KiFS. File names may have any number of nested directories in their paths, but the top-level directory must be an existing KiFS directory. Each file must reside in or under a top-level directory. A full file name path cannot be larger than 1024 characters. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>urls</td>
                <td>List of URLs to upload, for each respective file in <span>fileNames</span>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>
                <td>Optional parameters. The default value is an empty map. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1UploadFilesFromurlResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1UploadFilesFromurlResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ab62cc7f905247d940fd812c2d6a69f69">◆ </a></span>uploadFilesFromurl() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1UploadFilesFromurlResponse">UploadFilesFromurlResponse</a> gpudb::GPUdb::uploadFilesFromurl </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1UploadFilesFromurlRequest">UploadFilesFromurlRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Uploads one or more files to <a href="/content/tools/kifs/">KiFS</a>. </p>
        <p>Each file path must reside in a top-level KiFS directory, i.e. one of the directories listed in <a href="#a4938a2b931ab7710d13c4eb46caeb79b">showDirectories</a>. The user must have write permission on the directory. Nested directories are permitted in file name paths. Directories are delineated with the directory separator of '/'. For example, given the file path '/a/b/c/d.txt', 'a' must be a KiFS directory.</p>
        <p>These characters are allowed in file name paths: letters, numbers, spaces, the path delimiter of '/', and the characters: '.' '-' ':' '\[' ']' '(' ')' '#' '='.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1UploadFilesFromurlRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1UploadFilesFromurlResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a5add4bdb41a2fb23de1456566864b58c">◆ </a></span>uploadFilesFromurl() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1UploadFilesFromurlResponse">UploadFilesFromurlResponse</a> & gpudb::GPUdb::uploadFilesFromurl </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1UploadFilesFromurlRequest">UploadFilesFromurlRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1UploadFilesFromurlResponse">UploadFilesFromurlResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Uploads one or more files to <a href="/content/tools/kifs/">KiFS</a>. </p>
        <p>Each file path must reside in a top-level KiFS directory, i.e. one of the directories listed in <a href="#a4938a2b931ab7710d13c4eb46caeb79b">showDirectories</a>. The user must have write permission on the directory. Nested directories are permitted in file name paths. Directories are delineated with the directory separator of '/'. For example, given the file path '/a/b/c/d.txt', 'a' must be a KiFS directory.</p>
        <p>These characters are allowed in file name paths: letters, numbers, spaces, the path delimiter of '/', and the characters: '.' '-' ':' '\[' ']' '(' ')' '#' '='.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1UploadFilesFromurlRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1UploadFilesFromurlResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1UploadFilesFromurlResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a325cc59d8043c7103b453f94e822e341">◆ </a></span>verifyBackup() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1VerifyBackupResponse">VerifyBackupResponse</a> gpudb::GPUdb::verifyBackup </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>backupName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>datasourceName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Inspects the requested database <a href="/content/admin/backup_restore/#database-backup">backup(s)</a> for conformity at the remote file store accessible via the <a href="/content/concepts/data_sources/">data source</a> specified by <span>datasourceName</span>. </p>
        <p>By default all snapshots are inspected unless the option <a href="/content/api/cpp/namespacegpudb#ac281b7978044af859ef0c89b25f66fa8">backup\_id</a> is used to target a specific instance. Returns backup verification results.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>backupName</td>
                <td>Name of the backup. An empty string or '<span>' will check all existing backups. Any text followed by a '</span>' will inspect backups whose name starts with that text. The default value is ''. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>datasourceName</td>
                <td>Data source through which the backup is accessible. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#ac281b7978044af859ef0c89b25f66fa8">verify\_backup\_backup\_id</a>: ID of the snapshot to verify. Set to '-1' to verify all snapshots in the backup. Leave empty to verify only the most recent snapshot. The default value is '-1'. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1VerifyBackupResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ac9214f0312c763965a52b68aa3c543d2">◆ </a></span>verifyBackup() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1VerifyBackupResponse">VerifyBackupResponse</a> & gpudb::GPUdb::verifyBackup </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>backupName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>datasourceName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1VerifyBackupResponse">VerifyBackupResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Inspects the requested database <a href="/content/admin/backup_restore/#database-backup">backup(s)</a> for conformity at the remote file store accessible via the <a href="/content/concepts/data_sources/">data source</a> specified by <span>datasourceName</span>. </p>
        <p>By default all snapshots are inspected unless the option <a href="/content/api/cpp/namespacegpudb#ac281b7978044af859ef0c89b25f66fa8">backup\_id</a> is used to target a specific instance. Returns backup verification results.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>backupName</td>
                <td>Name of the backup. An empty string or '<span>' will check all existing backups. Any text followed by a '</span>' will inspect backups whose name starts with that text. The default value is ''. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>datasourceName</td>
                <td>Data source through which the backup is accessible. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#ac281b7978044af859ef0c89b25f66fa8">verify\_backup\_backup\_id</a>: ID of the snapshot to verify. Set to '-1' to verify all snapshots in the backup. Leave empty to verify only the most recent snapshot. The default value is '-1'. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1VerifyBackupResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1VerifyBackupResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#af5f5b0c2a7e2038b7155c5c0cd9df915">◆ </a></span>verifyBackup() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1VerifyBackupResponse">VerifyBackupResponse</a> gpudb::GPUdb::verifyBackup </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1VerifyBackupRequest">VerifyBackupRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Inspects the requested database <a href="/content/admin/backup_restore/#database-backup">backup(s)</a> for conformity at the remote file store accessible via the <a href="/content/concepts/data_sources/">data source</a> specified by <a href="/content/api/cpp/structgpudb_1_1VerifyBackupRequest#a11a6275bcd3c4cb59398efd08ceaa24b">datasourceName</a>. </p>
        <p>By default all snapshots are inspected unless the option <a href="/content/api/cpp/namespacegpudb#ac281b7978044af859ef0c89b25f66fa8">backup\_id</a> is used to target a specific instance. Returns backup verification results.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1VerifyBackupRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1VerifyBackupResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a285a2814137c3c2bfb4b72f12f3821ca">◆ </a></span>verifyBackup() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1VerifyBackupResponse">VerifyBackupResponse</a> & gpudb::GPUdb::verifyBackup </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1VerifyBackupRequest">VerifyBackupRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1VerifyBackupResponse">VerifyBackupResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Inspects the requested database <a href="/content/admin/backup_restore/#database-backup">backup(s)</a> for conformity at the remote file store accessible via the <a href="/content/concepts/data_sources/">data source</a> specified by <a href="/content/api/cpp/structgpudb_1_1VerifyBackupRequest#a11a6275bcd3c4cb59398efd08ceaa24b">datasourceName</a>. </p>
        <p>By default all snapshots are inspected unless the option <a href="/content/api/cpp/namespacegpudb#ac281b7978044af859ef0c89b25f66fa8">backup\_id</a> is used to target a specific instance. Returns backup verification results.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1VerifyBackupRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1VerifyBackupResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1VerifyBackupResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a20b374fed345959518ae9d1096be279b">◆ </a></span>visualizeImageChart() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1VisualizeImageChartResponse">VisualizeImageChartResponse</a> gpudb::GPUdb::visualizeImageChart </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< std::string > &</td>
            <td><span><span>xColumnNames</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< std::string > &</td>
            <td><span><span>yColumnNames</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const double</td>
            <td><span><span>minX</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const double</td>
            <td><span><span>maxX</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const double</td>
            <td><span><span>minY</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const double</td>
            <td><span><span>maxY</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const int32\_t</td>
            <td><span><span>width</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const int32\_t</td>
            <td><span><span>height</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>bgColor</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::vector\< std::string > > &</td>
            <td><span><span>styleOptions</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Scatter plot is the only plot type currently supported. </p>
        <p>A non-numeric column can be specified as x or y column and jitters can be added to them to avoid excessive overlapping. All color values must be in the format RRGGBB or AARRGGBB (to specify the alpha value). The image is contained in the <a href="/content/api/cpp/structgpudb_1_1VisualizeImageChartResponse#a7a857e2d9864e96a2f9bb7adbee789d2">imageData</a> field.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of the table containing the data to be drawn as a chart, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>xColumnNames</td>
                <td>Names of the columns containing the data mapped to the x axis of a chart. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>yColumnNames</td>
                <td>Names of the columns containing the data mapped to the y axis of a chart. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>minX</td>
                <td>Lower bound for the x column values. For non-numeric x column, each x column item is mapped to an integral value starting from 0. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>maxX</td>
                <td>Upper bound for the x column values. For non-numeric x column, each x column item is mapped to an integral value starting from 0. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>minY</td>
                <td>Lower bound for the y column values. For non-numeric y column, each y column item is mapped to an integral value starting from 0. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>maxY</td>
                <td>Upper bound for the y column values. For non-numeric y column, each y column item is mapped to an integral value starting from 0. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>width</td>
                <td>Width of the generated image in pixels. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>height</td>
                <td>Height of the generated image in pixels. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>bgColor</td>
                <td>Background color of the generated image. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>styleOptions</td>

                <td>
                  Rendering style options for a chart.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a24aa7921b4c6306d6b93c84e05e06354">visualize\_image\_chart\_pointcolor</a>: The color of points in the plot represented as a hexadecimal number. The default value is '0000FF'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ab4924e0dc08c60bd1d63951bbb2417f6">visualize\_image\_chart\_pointsize</a>: The size of points in the plot represented as number of pixels. The default value is '3'. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a4860eeae9d4ad84108f4c00c9398970d">visualize\_image\_chart\_pointshape</a>: The shape of points in the plot. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a78d16673e9cefb8cc6ac46d0b139798b">visualize\_image\_chart\_none</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a0730fc8fdd1a0438a6b90f191ba79884">visualize\_image\_chart\_circle</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a5c86f5c0c3e7378e19721bb898d6c96f">visualize\_image\_chart\_square</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a1e4064f742346098574ccb6b221421f1">visualize\_image\_chart\_diamond</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#abbaf926e55cfbf92ffbe5defebd1b2ef">visualize\_image\_chart\_hollowcircle</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a8022a791e14f2346fe0f3efba6eb6248">visualize\_image\_chart\_hollowsquare</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#af340a8e50a4d7deb99bb61c7e7b36347">visualize\_image\_chart\_hollowdiamond</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a5c86f5c0c3e7378e19721bb898d6c96f">visualize\_image\_chart\_square</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#ae26bec9ad1c71c21c6813f3b2688b580">visualize\_image\_chart\_cb\_pointcolors</a>: Point color class break information consisting of three entries: class-break attribute, class-break values/ranges, and point color values. This option overrides the pointcolor option if both are provided. Class-break ranges are represented in the form of "min:max". Class-break values/ranges and point color values are separated by cb\_delimiter, e.g. "price", "20:30;30:40;40:50", "0xFF0000;0x00FF00;0x0000FF". </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a63c86277e0c09f1a115eee0d381207ea">visualize\_image\_chart\_cb\_pointsizes</a>: Point size class break information consisting of three entries: class-break attribute, class-break values/ranges, and point size values. This option overrides the pointsize option if both are provided. Class-break ranges are represented in the form of "min:max". Class-break values/ranges and point size values are separated by cb\_delimiter, e.g. "states", "NY;TX;CA", "3;5;7". </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a1bf5aed71db90f7bddd0de0853b91a0c">visualize\_image\_chart\_cb\_pointshapes</a>: Point shape class break information consisting of three entries: class-break attribute, class-break values/ranges, and point shape names. This option overrides the pointshape option if both are provided. Class-break ranges are represented in the form of "min:max". Class-break values/ranges and point shape names are separated by cb\_delimiter, e.g. "states", "NY;TX;CA", "circle;square;diamond". </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a79f20b5244daa94e028ed7540849c8e7">visualize\_image\_chart\_cb\_delimiter</a>: A character or string which separates per-class values in a class-break style option string. The default value is ';'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a466af02008d901f7b6540782cca65e80">visualize\_image\_chart\_x\_order\_by</a>: An expression or aggregate expression by which non-numeric x column values are sorted, e.g. "avg(price) descending". </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a77d9c775a5e5a0e6c996b20402a0cf6b">visualize\_image\_chart\_y\_order\_by</a>: An expression or aggregate expression by which non-numeric y column values are sorted, e.g. "avg(price)", which defaults to "avg(price) ascending". </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#aff5074bf41616022ebc77a2596ee3b19">visualize\_image\_chart\_scale\_type\_x</a>: <a href="/content/api/cpp/classgpudb_1_1Type">Type</a> of x axis scale. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a78d16673e9cefb8cc6ac46d0b139798b">visualize\_image\_chart\_none</a>: No scale is applied to the x axis. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a34b76f475c3cdd013bbdee483bf3dc1e">visualize\_image\_chart\_log</a>: A base-10 log scale is applied to the x axis. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a78d16673e9cefb8cc6ac46d0b139798b">visualize\_image\_chart\_none</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a6f88054596485f3e28e807956126ef52">visualize\_image\_chart\_scale\_type\_y</a>: <a href="/content/api/cpp/classgpudb_1_1Type">Type</a> of y axis scale. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a78d16673e9cefb8cc6ac46d0b139798b">visualize\_image\_chart\_none</a>: No scale is applied to the y axis. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a34b76f475c3cdd013bbdee483bf3dc1e">visualize\_image\_chart\_log</a>: A base-10 log scale is applied to the y axis. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a78d16673e9cefb8cc6ac46d0b139798b">visualize\_image\_chart\_none</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#af75c337c081a257a9e0d96ff0b3de7f7">visualize\_image\_chart\_min\_max\_scaled</a>: If this options is set to <span>false</span>, this endpoint expects request's min/max values are not yet scaled. They will be scaled according to scale\_type\_x or scale\_type\_y for response. If this options is set to <span>true</span>, this endpoint expects request's min/max values are already scaled according to scale\_type\_x/scale\_type\_y. Response's min/max values will be equal to request's min/max values. The default value is 'false'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a732e095fd9a970667e775e4405fd7e2b">visualize\_image\_chart\_jitter\_x</a>: Amplitude of horizontal jitter applied to non-numeric x column values. The default value is '0.0'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a8fe44d0b17774563646c74e2ae49b995">visualize\_image\_chart\_jitter\_y</a>: Amplitude of vertical jitter applied to non-numeric y column values. The default value is '0.0'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a780b024ca9e2cc6f18063133f29b40b3">visualize\_image\_chart\_plot\_all</a>: If this options is set to <span>true</span>, all non-numeric column values are plotted ignoring min\_x, max\_x, min\_y and max\_y parameters. The default value is 'false'. </li>
                  </ul>
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a83ae29d8b1179e114787c6220a996225">visualize\_image\_chart\_image\_encoding</a>: Encoding to be applied to the output image. When using JSON serialization it is recommended to specify this as <a href="/content/api/cpp/namespacegpudb#abd8fb1b2afb330153f51bef806b6921c">base64</a>. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#abd8fb1b2afb330153f51bef806b6921c">visualize\_image\_chart\_base64</a>: Apply base64 encoding to the output image. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a78d16673e9cefb8cc6ac46d0b139798b">visualize\_image\_chart\_none</a>: Do not apply any additional encoding to the output image. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a78d16673e9cefb8cc6ac46d0b139798b">visualize\_image\_chart\_none</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1VisualizeImageChartResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a80e96dec306141c781a60f3e0c7992ea">◆ </a></span>visualizeImageChart() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1VisualizeImageChartResponse">VisualizeImageChartResponse</a> & gpudb::GPUdb::visualizeImageChart </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>tableName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< std::string > &</td>
            <td><span><span>xColumnNames</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< std::string > &</td>
            <td><span><span>yColumnNames</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const double</td>
            <td><span><span>minX</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const double</td>
            <td><span><span>maxX</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const double</td>
            <td><span><span>minY</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const double</td>
            <td><span><span>maxY</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const int32\_t</td>
            <td><span><span>width</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const int32\_t</td>
            <td><span><span>height</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>bgColor</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::vector\< std::string > > &</td>
            <td><span><span>styleOptions</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1VisualizeImageChartResponse">VisualizeImageChartResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Scatter plot is the only plot type currently supported. </p>
        <p>A non-numeric column can be specified as x or y column and jitters can be added to them to avoid excessive overlapping. All color values must be in the format RRGGBB or AARRGGBB (to specify the alpha value). The image is contained in the <a href="/content/api/cpp/structgpudb_1_1VisualizeImageChartResponse#a7a857e2d9864e96a2f9bb7adbee789d2">imageData</a> field.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>tableName</td>
                <td>Name of the table containing the data to be drawn as a chart, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a>. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>xColumnNames</td>
                <td>Names of the columns containing the data mapped to the x axis of a chart. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>yColumnNames</td>
                <td>Names of the columns containing the data mapped to the y axis of a chart. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>minX</td>
                <td>Lower bound for the x column values. For non-numeric x column, each x column item is mapped to an integral value starting from 0. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>maxX</td>
                <td>Upper bound for the x column values. For non-numeric x column, each x column item is mapped to an integral value starting from 0. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>minY</td>
                <td>Lower bound for the y column values. For non-numeric y column, each y column item is mapped to an integral value starting from 0. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>maxY</td>
                <td>Upper bound for the y column values. For non-numeric y column, each y column item is mapped to an integral value starting from 0. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>width</td>
                <td>Width of the generated image in pixels. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>height</td>
                <td>Height of the generated image in pixels. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>bgColor</td>
                <td>Background color of the generated image. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>styleOptions</td>

                <td>
                  Rendering style options for a chart.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a24aa7921b4c6306d6b93c84e05e06354">visualize\_image\_chart\_pointcolor</a>: The color of points in the plot represented as a hexadecimal number. The default value is '0000FF'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ab4924e0dc08c60bd1d63951bbb2417f6">visualize\_image\_chart\_pointsize</a>: The size of points in the plot represented as number of pixels. The default value is '3'. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a4860eeae9d4ad84108f4c00c9398970d">visualize\_image\_chart\_pointshape</a>: The shape of points in the plot. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a78d16673e9cefb8cc6ac46d0b139798b">visualize\_image\_chart\_none</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a0730fc8fdd1a0438a6b90f191ba79884">visualize\_image\_chart\_circle</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a5c86f5c0c3e7378e19721bb898d6c96f">visualize\_image\_chart\_square</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a1e4064f742346098574ccb6b221421f1">visualize\_image\_chart\_diamond</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#abbaf926e55cfbf92ffbe5defebd1b2ef">visualize\_image\_chart\_hollowcircle</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a8022a791e14f2346fe0f3efba6eb6248">visualize\_image\_chart\_hollowsquare</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#af340a8e50a4d7deb99bb61c7e7b36347">visualize\_image\_chart\_hollowdiamond</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a5c86f5c0c3e7378e19721bb898d6c96f">visualize\_image\_chart\_square</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#ae26bec9ad1c71c21c6813f3b2688b580">visualize\_image\_chart\_cb\_pointcolors</a>: Point color class break information consisting of three entries: class-break attribute, class-break values/ranges, and point color values. This option overrides the pointcolor option if both are provided. Class-break ranges are represented in the form of "min:max". Class-break values/ranges and point color values are separated by cb\_delimiter, e.g. "price", "20:30;30:40;40:50", "0xFF0000;0x00FF00;0x0000FF". </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a63c86277e0c09f1a115eee0d381207ea">visualize\_image\_chart\_cb\_pointsizes</a>: Point size class break information consisting of three entries: class-break attribute, class-break values/ranges, and point size values. This option overrides the pointsize option if both are provided. Class-break ranges are represented in the form of "min:max". Class-break values/ranges and point size values are separated by cb\_delimiter, e.g. "states", "NY;TX;CA", "3;5;7". </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a1bf5aed71db90f7bddd0de0853b91a0c">visualize\_image\_chart\_cb\_pointshapes</a>: Point shape class break information consisting of three entries: class-break attribute, class-break values/ranges, and point shape names. This option overrides the pointshape option if both are provided. Class-break ranges are represented in the form of "min:max". Class-break values/ranges and point shape names are separated by cb\_delimiter, e.g. "states", "NY;TX;CA", "circle;square;diamond". </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a79f20b5244daa94e028ed7540849c8e7">visualize\_image\_chart\_cb\_delimiter</a>: A character or string which separates per-class values in a class-break style option string. The default value is ';'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a466af02008d901f7b6540782cca65e80">visualize\_image\_chart\_x\_order\_by</a>: An expression or aggregate expression by which non-numeric x column values are sorted, e.g. "avg(price) descending". </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a77d9c775a5e5a0e6c996b20402a0cf6b">visualize\_image\_chart\_y\_order\_by</a>: An expression or aggregate expression by which non-numeric y column values are sorted, e.g. "avg(price)", which defaults to "avg(price) ascending". </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#aff5074bf41616022ebc77a2596ee3b19">visualize\_image\_chart\_scale\_type\_x</a>: <a href="/content/api/cpp/classgpudb_1_1Type">Type</a> of x axis scale. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a78d16673e9cefb8cc6ac46d0b139798b">visualize\_image\_chart\_none</a>: No scale is applied to the x axis. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a34b76f475c3cdd013bbdee483bf3dc1e">visualize\_image\_chart\_log</a>: A base-10 log scale is applied to the x axis. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a78d16673e9cefb8cc6ac46d0b139798b">visualize\_image\_chart\_none</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a6f88054596485f3e28e807956126ef52">visualize\_image\_chart\_scale\_type\_y</a>: <a href="/content/api/cpp/classgpudb_1_1Type">Type</a> of y axis scale. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a78d16673e9cefb8cc6ac46d0b139798b">visualize\_image\_chart\_none</a>: No scale is applied to the y axis. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a34b76f475c3cdd013bbdee483bf3dc1e">visualize\_image\_chart\_log</a>: A base-10 log scale is applied to the y axis. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a78d16673e9cefb8cc6ac46d0b139798b">visualize\_image\_chart\_none</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#af75c337c081a257a9e0d96ff0b3de7f7">visualize\_image\_chart\_min\_max\_scaled</a>: If this options is set to <span>false</span>, this endpoint expects request's min/max values are not yet scaled. They will be scaled according to scale\_type\_x or scale\_type\_y for response. If this options is set to <span>true</span>, this endpoint expects request's min/max values are already scaled according to scale\_type\_x/scale\_type\_y. Response's min/max values will be equal to request's min/max values. The default value is 'false'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a732e095fd9a970667e775e4405fd7e2b">visualize\_image\_chart\_jitter\_x</a>: Amplitude of horizontal jitter applied to non-numeric x column values. The default value is '0.0'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a8fe44d0b17774563646c74e2ae49b995">visualize\_image\_chart\_jitter\_y</a>: Amplitude of vertical jitter applied to non-numeric y column values. The default value is '0.0'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a780b024ca9e2cc6f18063133f29b40b3">visualize\_image\_chart\_plot\_all</a>: If this options is set to <span>true</span>, all non-numeric column values are plotted ignoring min\_x, max\_x, min\_y and max\_y parameters. The default value is 'false'. </li>
                  </ul>
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Optional parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a83ae29d8b1179e114787c6220a996225">visualize\_image\_chart\_image\_encoding</a>: Encoding to be applied to the output image. When using JSON serialization it is recommended to specify this as <a href="/content/api/cpp/namespacegpudb#abd8fb1b2afb330153f51bef806b6921c">base64</a>. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#abd8fb1b2afb330153f51bef806b6921c">visualize\_image\_chart\_base64</a>: Apply base64 encoding to the output image. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a78d16673e9cefb8cc6ac46d0b139798b">visualize\_image\_chart\_none</a>: Do not apply any additional encoding to the output image. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a78d16673e9cefb8cc6ac46d0b139798b">visualize\_image\_chart\_none</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1VisualizeImageChartResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1VisualizeImageChartResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a0bea9319cd2f5900e19533884300e13f">◆ </a></span>visualizeImageChart() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1VisualizeImageChartResponse">VisualizeImageChartResponse</a> gpudb::GPUdb::visualizeImageChart </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1VisualizeImageChartRequest">VisualizeImageChartRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Scatter plot is the only plot type currently supported. </p>
        <p>A non-numeric column can be specified as x or y column and jitters can be added to them to avoid excessive overlapping. All color values must be in the format RRGGBB or AARRGGBB (to specify the alpha value). The image is contained in the <a href="/content/api/cpp/structgpudb_1_1VisualizeImageChartResponse#a7a857e2d9864e96a2f9bb7adbee789d2">imageData</a> field.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1VisualizeImageChartRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1VisualizeImageChartResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ad7745a14c70622d3955074e6a0aa6891">◆ </a></span>visualizeImageChart() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1VisualizeImageChartResponse">VisualizeImageChartResponse</a> & gpudb::GPUdb::visualizeImageChart </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1VisualizeImageChartRequest">VisualizeImageChartRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1VisualizeImageChartResponse">VisualizeImageChartResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Scatter plot is the only plot type currently supported. </p>
        <p>A non-numeric column can be specified as x or y column and jitters can be added to them to avoid excessive overlapping. All color values must be in the format RRGGBB or AARRGGBB (to specify the alpha value). The image is contained in the <a href="/content/api/cpp/structgpudb_1_1VisualizeImageChartResponse#a7a857e2d9864e96a2f9bb7adbee789d2">imageData</a> field.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1VisualizeImageChartRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1VisualizeImageChartResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1VisualizeImageChartResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a04b488ae226bdc96633664a0bfcadbf3">◆ </a></span>visualizeIsochrone() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1VisualizeIsochroneResponse">VisualizeIsochroneResponse</a> gpudb::GPUdb::visualizeIsochrone </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>graphName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>sourceNode</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const double</td>
            <td><span><span>maxSolutionRadius</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< std::string > &</td>
            <td><span><span>weightsOnEdges</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< std::string > &</td>
            <td><span><span>restrictions</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const int32\_t</td>
            <td><span><span>numLevels</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const bool</td>
            <td><span><span>generateImage</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>levelsTable</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>styleOptions</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>solveOptions</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>contourOptions</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Generate an image containing isolines for travel results using an existing graph. </p>
        <p>Isolines represent curves of equal cost, with cost typically referring to the time or distance assigned as the weights of the underlying graph. See <a href="/content/graph_solver/network_graph_solver/">Graphs and Solvers</a> for more information on graphs.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>graphName</td>
                <td>Name of the graph on which the isochrone is to be computed. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>sourceNode</td>
                <td>Starting vertex on the underlying graph from/to which the isochrones are created. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>maxSolutionRadius</td>
                <td>Extent of the search radius around <span>sourceNode</span>. Set to '-1.0' for unrestricted search radius. The default value is -1.0. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>weightsOnEdges</td>
                <td>Additional weights to apply to the edges of an existing graph. Weights must be specified using <a href="/content/graph_solver/network_graph_solver/#identifiers">identifiers</a>; identifiers are grouped as <a href="/content/graph_solver/network_graph_solver/#id-combos">combinations</a>. Identifiers can be used with existing column names, e.g., 'table.column AS WEIGHTS\_EDGE\_ID', or expressions, e.g., 'ST\_LENGTH(wkt) AS WEIGHTS\_VALUESPECIFIED'. Any provided weights will be added (in the case of 'WEIGHTS\_VALUESPECIFIED') to or multiplied with (in the case of 'WEIGHTS\_FACTORSPECIFIED') the existing weight(s). The default value is an empty vector. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>restrictions</td>
                <td>Additional restrictions to apply to the nodes/edges of an existing graph. Restrictions must be specified using <a href="/content/graph_solver/network_graph_solver/#identifiers">identifiers</a>; identifiers are grouped as <a href="/content/graph_solver/network_graph_solver/#id-combos">combinations</a>. Identifiers can be used with existing column names, e.g., 'table.column AS RESTRICTIONS\_EDGE\_ID', or expressions, e.g., 'column/2 AS RESTRICTIONS\_VALUECOMPARED'. If <a href="/content/api/cpp/namespacegpudb#a3483d7b72a81b7938aab4c007a729fc4">remove\_previous\_restrictions</a> is set to <a href="/content/api/cpp/namespacegpudb#ac9afd2ad462e144ada1a2bcde60ef0a0">true</a>, any provided restrictions will replace the existing restrictions. If <a href="/content/api/cpp/namespacegpudb#a3483d7b72a81b7938aab4c007a729fc4">remove\_previous\_restrictions</a> is set to <a href="/content/api/cpp/namespacegpudb#a1fcf7ebbdee8d71a6ded7d06113c894f">false</a>, any provided restrictions will be added (in the case of 'RESTRICTIONS\_VALUECOMPARED') to or replaced (in the case of 'RESTRICTIONS\_ONOFFCOMPARED'). The default value is an empty vector. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>numLevels</td>
                <td>Number of equally-separated isochrones to compute. The default value is 1. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>generateImage</td>

                <td>
                  If set to <a href="/content/api/cpp/namespacegpudb#ac9afd2ad462e144ada1a2bcde60ef0a0">true</a>, generates a PNG image of the isochrones in the response. Supported values:

                  <ul>
                    <li> true </li>
                    <li> false </li>
                  </ul>

                  The default value is true.
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>levelsTable</td>
                <td>Name of the table to output the isochrones to, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a> and meeting <a href="/content/concepts/tables/#table-naming-criteria">table naming criteria</a>. The table will contain levels and their corresponding WKT geometry. If no value is provided, the table is not generated. The default value is ''. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>styleOptions</td>

                <td>
                  Various style related options of the isochrone image.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#afba8922f9412e3a149a8bb86dcc6d481">visualize\_isochrone\_line\_size</a>: The width of the contour lines in pixels. The default value is '3'. The minimum allowed value is '0'. The maximum allowed value is '20'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a042e5c8a04147b11daca2bde422a5e79">visualize\_isochrone\_color</a>: Color of generated isolines. All color values must be in the format RRGGBB or AARRGGBB (to specify the alpha value). If alpha is specified and flooded contours are enabled, it will be used for as the transparency of the latter. The default value is 'FF696969'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a94e193f2df29c3ddc10e5c867a69885a">visualize\_isochrone\_bg\_color</a>: When <span>generateImage</span> is set to <a href="/content/api/cpp/namespacegpudb#ac9afd2ad462e144ada1a2bcde60ef0a0">true</a>, background color of the generated image. All color values must be in the format RRGGBB or AARRGGBB (to specify the alpha value). The default value is '00000000'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a0505bf03c94c5e3a95c5a842362823f4">visualize\_isochrone\_text\_color</a>: When <a href="/content/api/cpp/namespacegpudb#a1be64b641b1965cec3851e603c405969">add\_labels</a> is set to <a href="/content/api/cpp/namespacegpudb#ac9afd2ad462e144ada1a2bcde60ef0a0">true</a>, color for the labels. All color values must be in the format RRGGBB or AARRGGBB (to specify the alpha value). The default value is 'FF000000'. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#acf0c726aff9c173eedc89f3ac923802b">visualize\_isochrone\_colormap</a>: Colormap for contours or fill-in regions when applicable. All color values must be in the format RRGGBB or AARRGGBB (to specify the alpha value). Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#af450f9ad252f5818f3faab770ec106fc">visualize\_isochrone\_jet</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a99518c55542c8d9c2767485ee06a457e">visualize\_isochrone\_accent</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aa2bc2c4a241eafb02a58ce6b0b56c4b6">visualize\_isochrone\_afmhot</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aea824d5c0e7efbfb4e8badf5afd6df8c">visualize\_isochrone\_autumn</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ae8afd1b8d033702e462f57a415eb449d">visualize\_isochrone\_binary</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#afdbbfb51f966dc6f769731497c29e2b0">visualize\_isochrone\_blues</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ab929fe079d960a14c0b3fb037acc6bfb">visualize\_isochrone\_bone</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a67784484d92e5c101aa96fe7d831bc2e">visualize\_isochrone\_brbg</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a9cdde45604c3a17d813a4c40e6eec83e">visualize\_isochrone\_brg</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a4c90d1708113a08a2df0028964c2861f">visualize\_isochrone\_bugn</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#adb23b122f5823bf26e89ae8156216c9a">visualize\_isochrone\_bupu</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a464e29d8288c820afac375f3676ea89a">visualize\_isochrone\_bwr</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ab017001b7a6025c13ffbbb55cef91fdf">visualize\_isochrone\_cmrmap</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aa723a1e350313a41a7760797e7167e72">visualize\_isochrone\_cool</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a67a269abcb2bc611bd7ded0ddc8b28f8">visualize\_isochrone\_coolwarm</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad7af98a1fbdb1741c79f77a8653a2d0e">visualize\_isochrone\_copper</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a25f592f808668f9ed3a74ee635f8ba47">visualize\_isochrone\_cubehelix</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a51304143d51c801aad399c2b51f3d148">visualize\_isochrone\_dark2</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a90f563854f7619f4208227c0de8ab16c">visualize\_isochrone\_flag</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a5b68ce98315d306c7e10c8d1d32ee1f7">visualize\_isochrone\_gist\_earth</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a53ca6af17e479f0ed3f809f88ad358ca">visualize\_isochrone\_gist\_gray</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a1d2352415c00c99b51b4b33c74dd6482">visualize\_isochrone\_gist\_heat</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a95618e1f50e078e0a1f2b33bfdf0bdd9">visualize\_isochrone\_gist\_ncar</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a1f12588665bf696bd13997d197daaabf">visualize\_isochrone\_gist\_rainbow</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a3886364f91d3f47416959ac7dac6b10f">visualize\_isochrone\_gist\_stern</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a2210090347a492bc575b4e130d5afeb9">visualize\_isochrone\_gist\_yarg</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aab9e1d08cf585fd4925955ec01654824">visualize\_isochrone\_gnbu</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a214f24bbd99cee8f1e96d4f11ec30d2d">visualize\_isochrone\_gnuplot2</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a9f0c58fb21b526597cd0ea59fe70c32c">visualize\_isochrone\_gnuplot</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a66d3659d233c817b9f3d25a52b17a97b">visualize\_isochrone\_gray</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a71ff947e932fb62351b82b49f286660a">visualize\_isochrone\_greens</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a898a92b52338668859c8fff5acedbeec">visualize\_isochrone\_greys</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a808427b57ae3eb05ae99d95ec09ad78f">visualize\_isochrone\_hot</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a4454d6455eb3661f1ff136f2b260ecf5">visualize\_isochrone\_hsv</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aac7ad6ae51438533e09823c5dc15181e">visualize\_isochrone\_inferno</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a35658ca974a14109c0b6d3aa12e5d070">visualize\_isochrone\_magma</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a36a9b3d763bac0f0bac6e59ffcedc190">visualize\_isochrone\_nipy\_spectral</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aa83517de13641533a92d22c2312a7540">visualize\_isochrone\_ocean</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a64bd356e937a3727080c1833ce2d0147">visualize\_isochrone\_oranges</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a6f7f4d05c464b7313069055705766170">visualize\_isochrone\_orrd</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a9ed6b15c10668d65a60119199c8ad50c">visualize\_isochrone\_paired</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a6a04a95b1913d754efb1da9abf977e09">visualize\_isochrone\_pastel1</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a2d69995d60aae35a6b3aeefe628b4e59">visualize\_isochrone\_pastel2</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a92c8e683641cfa9edb2871af88a1915c">visualize\_isochrone\_pink</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a5f041ef70452316bdd14ec7cc1cb631e">visualize\_isochrone\_piyg</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a450f314335de50e1f5d62e7e56d351de">visualize\_isochrone\_plasma</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ac3b93d7d122559918f0263e0520c3d33">visualize\_isochrone\_prgn</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#afaf940acc2f967a60a07cc0d7a171fda">visualize\_isochrone\_prism</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#af80e969b7dbfb2b8067d91a5fce7f693">visualize\_isochrone\_pubu</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a94b1903be04e04b173df4d8c6b57735f">visualize\_isochrone\_pubugn</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ab9760130bbd7458b5194ad7af2cb4ed9">visualize\_isochrone\_puor</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ac91c64dd0cb58aa121680d88a647d66a">visualize\_isochrone\_purd</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aef3a2cf6da1de27c1a8a589a818fedc0">visualize\_isochrone\_purples</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a04effe6bdfa8136ca474659ae5d023e0">visualize\_isochrone\_rainbow</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a98efa0fc0f0f485205388ea6bdf61e5e">visualize\_isochrone\_rdbu</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a734b3e30ce17b06252bb88b5fd225c04">visualize\_isochrone\_rdgy</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a40bb979922dbce13438862de1c20ea6f">visualize\_isochrone\_rdpu</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a0fd88b59fa60690529b8fb71cb4b46f8">visualize\_isochrone\_rdylbu</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ab228af3a08797803fae534c862bebf1f">visualize\_isochrone\_rdylgn</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad9e50d3187e16ab49f7f21eec64fa3a8">visualize\_isochrone\_reds</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a93886894e86282a3cf7c75e8c53c39ae">visualize\_isochrone\_seismic</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aca8e6ad12ed9920ac31c535d778a934f">visualize\_isochrone\_set1</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a94d1a397d69c60ef9f025f74e32e788d">visualize\_isochrone\_set2</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a141f8cc236e2d71da4d50c7c0568a466">visualize\_isochrone\_set3</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ae2f82a5f727664a81821e2c9daaa2e00">visualize\_isochrone\_spectral</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aa275df8af449954767204c293922fca0">visualize\_isochrone\_spring</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a46ef253b3a6cb1aec8c599cc583be9e5">visualize\_isochrone\_summer</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a77ca451bc67ea20f28b4e4489f1e008d">visualize\_isochrone\_terrain</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#af619e26140518cbf50ad3a20dea200b7">visualize\_isochrone\_viridis</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#afd2eb18c9fab60db99bab8fe1f7cab43">visualize\_isochrone\_winter</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a4d9fd202f936b9601aaac5c313e9258f">visualize\_isochrone\_wistia</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a1cd296889da7b5a34b81f8a723cec611">visualize\_isochrone\_ylgn</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a517e8f3064cdc1ca71e0e38de8bd4ea4">visualize\_isochrone\_ylgnbu</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ac461d6a9eb1a40c0f739e7aad43f2bc2">visualize\_isochrone\_ylorbr</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aa7a2140c4798cc9b8f244868417f85e7">visualize\_isochrone\_ylorrd</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#af450f9ad252f5818f3faab770ec106fc">visualize\_isochrone\_jet</a>.
                    </li>
                  </ul>
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>solveOptions</td>

                <td>
                  Solver specific parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a3483d7b72a81b7938aab4c007a729fc4">visualize\_isochrone\_remove\_previous\_restrictions</a>: Ignore the restrictions applied to the graph during the creation stage and only use the restrictions specified in this request if set to <a href="/content/api/cpp/namespacegpudb#ac9afd2ad462e144ada1a2bcde60ef0a0">true</a>. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ac9afd2ad462e144ada1a2bcde60ef0a0">visualize\_isochrone\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a1fcf7ebbdee8d71a6ded7d06113c894f">visualize\_isochrone\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a1fcf7ebbdee8d71a6ded7d06113c894f">visualize\_isochrone\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#ae6b56cae6b95bd6ec87d53f60be804a7">visualize\_isochrone\_restriction\_threshold\_value</a>: Value-based restriction comparison. Any node or edge with a 'RESTRICTIONS\_VALUECOMPARED' value greater than the <a href="/content/api/cpp/namespacegpudb#ae6b56cae6b95bd6ec87d53f60be804a7">restriction\_threshold\_value</a> will not be included in the solution. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a4dc28af7e326ce19fcf79d375a5fba78">visualize\_isochrone\_uniform\_weights</a>: When specified, assigns the given value to all the edges in the graph. Note that weights provided in <span>weightsOnEdges</span> will override this value. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>contourOptions</td>

                <td>
                  Contour specific parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a34c329f05f7179ea53f65c86c425d97f">visualize\_isochrone\_projection</a>: Spatial Reference System (i.e. EPSG Code). Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a10d74aebab8814a599ccbc5763f672fb">visualize\_isochrone\_3857</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad34828659d612628017bc2525bfb179a">visualize\_isochrone\_102100</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a324450ab53e47cd5d1b04fcb7ec83710">visualize\_isochrone\_900913</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ae93881b1c178dd582bf84f1b70169fcf">visualize\_isochrone\_EPSG\_4326</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a832462f7aa56859ffc3f65078354ccd0">visualize\_isochrone\_PLATE\_CARREE</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ac04816967d903f682fa6b033fea50e83">visualize\_isochrone\_EPSG\_900913</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ab208354411b31a8dbebcfd34245311bc">visualize\_isochrone\_EPSG\_102100</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a8925fca8e23cd9d0622ba6067f3ce1f1">visualize\_isochrone\_EPSG\_3857</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ae90833bee6d47168dfde507358c59268">visualize\_isochrone\_WEB\_MERCATOR</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a832462f7aa56859ffc3f65078354ccd0">visualize\_isochrone\_PLATE\_CARREE</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a9d22b3c5b54739e6fb5b4c24a99945f7">visualize\_isochrone\_width</a>: When <span>generateImage</span> is set to <a href="/content/api/cpp/namespacegpudb#ac9afd2ad462e144ada1a2bcde60ef0a0">true</a>, width of the generated image. The default value is '512'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a6fffbbfe7224587808e17635fbe3e68a">visualize\_isochrone\_height</a>: When <span>generateImage</span> is set to <a href="/content/api/cpp/namespacegpudb#ac9afd2ad462e144ada1a2bcde60ef0a0">true</a>, height of the generated image. If the default value is used, the <a href="/content/api/cpp/namespacegpudb#a6fffbbfe7224587808e17635fbe3e68a">height</a> is set to the value resulting from multiplying the aspect ratio by the <a href="/content/api/cpp/namespacegpudb#a9d22b3c5b54739e6fb5b4c24a99945f7">width</a>. The default value is '-1'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a5bbdef878b1eb27ec03008f0986074ad">visualize\_isochrone\_search\_radius</a>: When interpolating the graph solution to generate the isochrone, neighborhood of influence of sample data (in percent of the image/grid). The default value is '20'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ae81a20d2d6572efd5457eb1459760459">visualize\_isochrone\_grid\_size</a>: When interpolating the graph solution to generate the isochrone, number of subdivisions along the x axis when building the grid (the y is computed using the aspect ratio of the output image). The default value is '100'. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#afc0852bb81429c3014ca5957e8a31d6d">visualize\_isochrone\_color\_isolines</a>: Color each isoline according to the colormap; otherwise, use the foreground color. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ac9afd2ad462e144ada1a2bcde60ef0a0">visualize\_isochrone\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a1fcf7ebbdee8d71a6ded7d06113c894f">visualize\_isochrone\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ac9afd2ad462e144ada1a2bcde60ef0a0">visualize\_isochrone\_true</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a1be64b641b1965cec3851e603c405969">visualize\_isochrone\_add\_labels</a>: If set to <a href="/content/api/cpp/namespacegpudb#ac9afd2ad462e144ada1a2bcde60ef0a0">true</a>, add labels to the isolines. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ac9afd2ad462e144ada1a2bcde60ef0a0">visualize\_isochrone\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a1fcf7ebbdee8d71a6ded7d06113c894f">visualize\_isochrone\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a1fcf7ebbdee8d71a6ded7d06113c894f">visualize\_isochrone\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a1bd360eb2f37aeefaf2367d44029fe53">visualize\_isochrone\_labels\_font\_size</a>: When <a href="/content/api/cpp/namespacegpudb#a1be64b641b1965cec3851e603c405969">add\_labels</a> is set to <a href="/content/api/cpp/namespacegpudb#ac9afd2ad462e144ada1a2bcde60ef0a0">true</a>, size of the font (in pixels) to use for labels. The default value is '12'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a299e212bebdb027701fd328d0a69c539">visualize\_isochrone\_labels\_font\_family</a>: When <a href="/content/api/cpp/namespacegpudb#a1be64b641b1965cec3851e603c405969">add\_labels</a> is set to <a href="/content/api/cpp/namespacegpudb#ac9afd2ad462e144ada1a2bcde60ef0a0">true</a>, font name to be used when adding labels. The default value is 'arial'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a5adaa2beae23f9628eeec00633e415a4">visualize\_isochrone\_labels\_search\_window</a>: When <a href="/content/api/cpp/namespacegpudb#a1be64b641b1965cec3851e603c405969">add\_labels</a> is set to <a href="/content/api/cpp/namespacegpudb#ac9afd2ad462e144ada1a2bcde60ef0a0">true</a>, a search window is used to rate the local quality of each isoline. Smooth, continuous, long stretches with relatively flat angles are favored. The provided value is multiplied by the <a href="/content/api/cpp/namespacegpudb#a1bd360eb2f37aeefaf2367d44029fe53">labels\_font\_size</a> to calculate the final window size. The default value is '4'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a8b0b65774fb9554dd6c9df3194d2f489">visualize\_isochrone\_labels\_intralevel\_separation</a>: When <a href="/content/api/cpp/namespacegpudb#a1be64b641b1965cec3851e603c405969">add\_labels</a> is set to <a href="/content/api/cpp/namespacegpudb#ac9afd2ad462e144ada1a2bcde60ef0a0">true</a>, this value determines the distance (in multiples of the <a href="/content/api/cpp/namespacegpudb#a1bd360eb2f37aeefaf2367d44029fe53">labels\_font\_size</a>) to use when separating labels of different values. The default value is '4'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ace9e610e473ef0fdc1312b231f14e014">visualize\_isochrone\_labels\_interlevel\_separation</a>: When <a href="/content/api/cpp/namespacegpudb#a1be64b641b1965cec3851e603c405969">add\_labels</a> is set to <a href="/content/api/cpp/namespacegpudb#ac9afd2ad462e144ada1a2bcde60ef0a0">true</a>, this value determines the distance (in percent of the total window size) to use when separating labels of the same value. The default value is '20'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a26499d4826e70a500e1c2cc127ecd8e4">visualize\_isochrone\_labels\_max\_angle</a>: When <a href="/content/api/cpp/namespacegpudb#a1be64b641b1965cec3851e603c405969">add\_labels</a> is set to <a href="/content/api/cpp/namespacegpudb#ac9afd2ad462e144ada1a2bcde60ef0a0">true</a>, maximum angle (in degrees) from the vertical to use when adding labels. The default value is '60'. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Additional parameters.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a0c3a1331151edbea8282ee334eefecc7">visualize\_isochrone\_solve\_table</a>: Name of the table to host intermediate solve results, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a> and meeting <a href="/content/concepts/tables/#table-naming-criteria">table naming criteria</a>. This table will contain the position and cost for each vertex in the graph. If the default value is used, a temporary table is created and deleted once the solution is calculated. The default value is ''. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ae564a6b2e068d464d9aee6a840650cd3">visualize\_isochrone\_is\_replicated</a>: If set to <a href="/content/api/cpp/namespacegpudb#ac9afd2ad462e144ada1a2bcde60ef0a0">true</a>, replicate the <a href="/content/api/cpp/namespacegpudb#a0c3a1331151edbea8282ee334eefecc7">solve\_table</a>. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ac9afd2ad462e144ada1a2bcde60ef0a0">visualize\_isochrone\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a1fcf7ebbdee8d71a6ded7d06113c894f">visualize\_isochrone\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ac9afd2ad462e144ada1a2bcde60ef0a0">visualize\_isochrone\_true</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a887c43e0c560a7821b9d16e040966b17">visualize\_isochrone\_data\_min\_x</a>: Lower bound for the x values. If not provided, it will be computed from the bounds of the input data. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a3bf28f9984af4bee28465c49df4745fe">visualize\_isochrone\_data\_max\_x</a>: Upper bound for the x values. If not provided, it will be computed from the bounds of the input data. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a0d535972e2625430510f338c33e1795e">visualize\_isochrone\_data\_min\_y</a>: Lower bound for the y values. If not provided, it will be computed from the bounds of the input data. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aba0a0dfdc62d2c5a7bd474651d8bc426">visualize\_isochrone\_data\_max\_y</a>: Upper bound for the y values. If not provided, it will be computed from the bounds of the input data. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a758bcdc9e7b93ea554834b9bd155ddad">visualize\_isochrone\_concavity\_level</a>: Factor to qualify the concavity of the isochrone curves. The lower the value, the more convex (with '0' being completely convex and '1' being the most concave). The default value is '0.5'. The minimum allowed value is '0'. The maximum allowed value is '1'. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a47f849e7545c84befa010279eb4bcc96">visualize\_isochrone\_use\_priority\_queue\_solvers</a>: Sets the solver methods explicitly if true. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ac9afd2ad462e144ada1a2bcde60ef0a0">visualize\_isochrone\_true</a>: Uses the solvers scheduled for 'shortest\_path' and 'inverse\_shortest\_path' based on <a href="/content/api/cpp/namespacegpudb#af2e95597b4516659fd1efacd2147f5b9">solve\_direction</a>. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a1fcf7ebbdee8d71a6ded7d06113c894f">visualize\_isochrone\_false</a>: Uses the solvers 'priority\_queue' and 'inverse\_priority\_queue' based on <a href="/content/api/cpp/namespacegpudb#af2e95597b4516659fd1efacd2147f5b9">solve\_direction</a>. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a1fcf7ebbdee8d71a6ded7d06113c894f">visualize\_isochrone\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#af2e95597b4516659fd1efacd2147f5b9">visualize\_isochrone\_solve\_direction</a>: Specify whether we are going to the source node, or starting from it. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a2ae81d9fe0ef6bb91c1bccd02f0492f7">visualize\_isochrone\_from\_source</a>: Shortest path to get to the source (inverse Dijkstra). </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ac6d559b19e604edbf9c57b059b458e85">visualize\_isochrone\_to\_source</a>: Shortest path to source (Dijkstra). </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a2ae81d9fe0ef6bb91c1bccd02f0492f7">visualize\_isochrone\_from\_source</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1VisualizeIsochroneResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#af3bd3855cefca33f965baebef3c366b1">◆ </a></span>visualizeIsochrone() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1VisualizeIsochroneResponse">VisualizeIsochroneResponse</a> & gpudb::GPUdb::visualizeIsochrone </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>graphName</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>sourceNode</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const double</td>
            <td><span><span>maxSolutionRadius</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< std::string > &</td>
            <td><span><span>weightsOnEdges</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< std::string > &</td>
            <td><span><span>restrictions</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const int32\_t</td>
            <td><span><span>numLevels</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const bool</td>
            <td><span><span>generateImage</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>levelsTable</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>styleOptions</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>solveOptions</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>contourOptions</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1VisualizeIsochroneResponse">VisualizeIsochroneResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Generate an image containing isolines for travel results using an existing graph. </p>
        <p>Isolines represent curves of equal cost, with cost typically referring to the time or distance assigned as the weights of the underlying graph. See <a href="/content/graph_solver/network_graph_solver/">Graphs and Solvers</a> for more information on graphs.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>graphName</td>
                <td>Name of the graph on which the isochrone is to be computed. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>sourceNode</td>
                <td>Starting vertex on the underlying graph from/to which the isochrones are created. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>maxSolutionRadius</td>
                <td>Extent of the search radius around <span>sourceNode</span>. Set to '-1.0' for unrestricted search radius. The default value is -1.0. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>weightsOnEdges</td>
                <td>Additional weights to apply to the edges of an existing graph. Weights must be specified using <a href="/content/graph_solver/network_graph_solver/#identifiers">identifiers</a>; identifiers are grouped as <a href="/content/graph_solver/network_graph_solver/#id-combos">combinations</a>. Identifiers can be used with existing column names, e.g., 'table.column AS WEIGHTS\_EDGE\_ID', or expressions, e.g., 'ST\_LENGTH(wkt) AS WEIGHTS\_VALUESPECIFIED'. Any provided weights will be added (in the case of 'WEIGHTS\_VALUESPECIFIED') to or multiplied with (in the case of 'WEIGHTS\_FACTORSPECIFIED') the existing weight(s). The default value is an empty vector. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>restrictions</td>
                <td>Additional restrictions to apply to the nodes/edges of an existing graph. Restrictions must be specified using <a href="/content/graph_solver/network_graph_solver/#identifiers">identifiers</a>; identifiers are grouped as <a href="/content/graph_solver/network_graph_solver/#id-combos">combinations</a>. Identifiers can be used with existing column names, e.g., 'table.column AS RESTRICTIONS\_EDGE\_ID', or expressions, e.g., 'column/2 AS RESTRICTIONS\_VALUECOMPARED'. If <a href="/content/api/cpp/namespacegpudb#a3483d7b72a81b7938aab4c007a729fc4">remove\_previous\_restrictions</a> is set to <a href="/content/api/cpp/namespacegpudb#ac9afd2ad462e144ada1a2bcde60ef0a0">true</a>, any provided restrictions will replace the existing restrictions. If <a href="/content/api/cpp/namespacegpudb#a3483d7b72a81b7938aab4c007a729fc4">remove\_previous\_restrictions</a> is set to <a href="/content/api/cpp/namespacegpudb#a1fcf7ebbdee8d71a6ded7d06113c894f">false</a>, any provided restrictions will be added (in the case of 'RESTRICTIONS\_VALUECOMPARED') to or replaced (in the case of 'RESTRICTIONS\_ONOFFCOMPARED'). The default value is an empty vector. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>numLevels</td>
                <td>Number of equally-separated isochrones to compute. The default value is 1. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>generateImage</td>

                <td>
                  If set to <a href="/content/api/cpp/namespacegpudb#ac9afd2ad462e144ada1a2bcde60ef0a0">true</a>, generates a PNG image of the isochrones in the response. Supported values:

                  <ul>
                    <li> true </li>
                    <li> false </li>
                  </ul>

                  The default value is true.
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>levelsTable</td>
                <td>Name of the table to output the isochrones to, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a> and meeting <a href="/content/concepts/tables/#table-naming-criteria">table naming criteria</a>. The table will contain levels and their corresponding WKT geometry. If no value is provided, the table is not generated. The default value is ''. </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>styleOptions</td>

                <td>
                  Various style related options of the isochrone image.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#afba8922f9412e3a149a8bb86dcc6d481">visualize\_isochrone\_line\_size</a>: The width of the contour lines in pixels. The default value is '3'. The minimum allowed value is '0'. The maximum allowed value is '20'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a042e5c8a04147b11daca2bde422a5e79">visualize\_isochrone\_color</a>: Color of generated isolines. All color values must be in the format RRGGBB or AARRGGBB (to specify the alpha value). If alpha is specified and flooded contours are enabled, it will be used for as the transparency of the latter. The default value is 'FF696969'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a94e193f2df29c3ddc10e5c867a69885a">visualize\_isochrone\_bg\_color</a>: When <span>generateImage</span> is set to <a href="/content/api/cpp/namespacegpudb#ac9afd2ad462e144ada1a2bcde60ef0a0">true</a>, background color of the generated image. All color values must be in the format RRGGBB or AARRGGBB (to specify the alpha value). The default value is '00000000'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a0505bf03c94c5e3a95c5a842362823f4">visualize\_isochrone\_text\_color</a>: When <a href="/content/api/cpp/namespacegpudb#a1be64b641b1965cec3851e603c405969">add\_labels</a> is set to <a href="/content/api/cpp/namespacegpudb#ac9afd2ad462e144ada1a2bcde60ef0a0">true</a>, color for the labels. All color values must be in the format RRGGBB or AARRGGBB (to specify the alpha value). The default value is 'FF000000'. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#acf0c726aff9c173eedc89f3ac923802b">visualize\_isochrone\_colormap</a>: Colormap for contours or fill-in regions when applicable. All color values must be in the format RRGGBB or AARRGGBB (to specify the alpha value). Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#af450f9ad252f5818f3faab770ec106fc">visualize\_isochrone\_jet</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a99518c55542c8d9c2767485ee06a457e">visualize\_isochrone\_accent</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aa2bc2c4a241eafb02a58ce6b0b56c4b6">visualize\_isochrone\_afmhot</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aea824d5c0e7efbfb4e8badf5afd6df8c">visualize\_isochrone\_autumn</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ae8afd1b8d033702e462f57a415eb449d">visualize\_isochrone\_binary</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#afdbbfb51f966dc6f769731497c29e2b0">visualize\_isochrone\_blues</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ab929fe079d960a14c0b3fb037acc6bfb">visualize\_isochrone\_bone</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a67784484d92e5c101aa96fe7d831bc2e">visualize\_isochrone\_brbg</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a9cdde45604c3a17d813a4c40e6eec83e">visualize\_isochrone\_brg</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a4c90d1708113a08a2df0028964c2861f">visualize\_isochrone\_bugn</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#adb23b122f5823bf26e89ae8156216c9a">visualize\_isochrone\_bupu</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a464e29d8288c820afac375f3676ea89a">visualize\_isochrone\_bwr</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ab017001b7a6025c13ffbbb55cef91fdf">visualize\_isochrone\_cmrmap</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aa723a1e350313a41a7760797e7167e72">visualize\_isochrone\_cool</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a67a269abcb2bc611bd7ded0ddc8b28f8">visualize\_isochrone\_coolwarm</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad7af98a1fbdb1741c79f77a8653a2d0e">visualize\_isochrone\_copper</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a25f592f808668f9ed3a74ee635f8ba47">visualize\_isochrone\_cubehelix</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a51304143d51c801aad399c2b51f3d148">visualize\_isochrone\_dark2</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a90f563854f7619f4208227c0de8ab16c">visualize\_isochrone\_flag</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a5b68ce98315d306c7e10c8d1d32ee1f7">visualize\_isochrone\_gist\_earth</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a53ca6af17e479f0ed3f809f88ad358ca">visualize\_isochrone\_gist\_gray</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a1d2352415c00c99b51b4b33c74dd6482">visualize\_isochrone\_gist\_heat</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a95618e1f50e078e0a1f2b33bfdf0bdd9">visualize\_isochrone\_gist\_ncar</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a1f12588665bf696bd13997d197daaabf">visualize\_isochrone\_gist\_rainbow</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a3886364f91d3f47416959ac7dac6b10f">visualize\_isochrone\_gist\_stern</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a2210090347a492bc575b4e130d5afeb9">visualize\_isochrone\_gist\_yarg</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aab9e1d08cf585fd4925955ec01654824">visualize\_isochrone\_gnbu</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a214f24bbd99cee8f1e96d4f11ec30d2d">visualize\_isochrone\_gnuplot2</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a9f0c58fb21b526597cd0ea59fe70c32c">visualize\_isochrone\_gnuplot</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a66d3659d233c817b9f3d25a52b17a97b">visualize\_isochrone\_gray</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a71ff947e932fb62351b82b49f286660a">visualize\_isochrone\_greens</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a898a92b52338668859c8fff5acedbeec">visualize\_isochrone\_greys</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a808427b57ae3eb05ae99d95ec09ad78f">visualize\_isochrone\_hot</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a4454d6455eb3661f1ff136f2b260ecf5">visualize\_isochrone\_hsv</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aac7ad6ae51438533e09823c5dc15181e">visualize\_isochrone\_inferno</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a35658ca974a14109c0b6d3aa12e5d070">visualize\_isochrone\_magma</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a36a9b3d763bac0f0bac6e59ffcedc190">visualize\_isochrone\_nipy\_spectral</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aa83517de13641533a92d22c2312a7540">visualize\_isochrone\_ocean</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a64bd356e937a3727080c1833ce2d0147">visualize\_isochrone\_oranges</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a6f7f4d05c464b7313069055705766170">visualize\_isochrone\_orrd</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a9ed6b15c10668d65a60119199c8ad50c">visualize\_isochrone\_paired</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a6a04a95b1913d754efb1da9abf977e09">visualize\_isochrone\_pastel1</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a2d69995d60aae35a6b3aeefe628b4e59">visualize\_isochrone\_pastel2</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a92c8e683641cfa9edb2871af88a1915c">visualize\_isochrone\_pink</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a5f041ef70452316bdd14ec7cc1cb631e">visualize\_isochrone\_piyg</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a450f314335de50e1f5d62e7e56d351de">visualize\_isochrone\_plasma</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ac3b93d7d122559918f0263e0520c3d33">visualize\_isochrone\_prgn</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#afaf940acc2f967a60a07cc0d7a171fda">visualize\_isochrone\_prism</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#af80e969b7dbfb2b8067d91a5fce7f693">visualize\_isochrone\_pubu</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a94b1903be04e04b173df4d8c6b57735f">visualize\_isochrone\_pubugn</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ab9760130bbd7458b5194ad7af2cb4ed9">visualize\_isochrone\_puor</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ac91c64dd0cb58aa121680d88a647d66a">visualize\_isochrone\_purd</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aef3a2cf6da1de27c1a8a589a818fedc0">visualize\_isochrone\_purples</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a04effe6bdfa8136ca474659ae5d023e0">visualize\_isochrone\_rainbow</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a98efa0fc0f0f485205388ea6bdf61e5e">visualize\_isochrone\_rdbu</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a734b3e30ce17b06252bb88b5fd225c04">visualize\_isochrone\_rdgy</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a40bb979922dbce13438862de1c20ea6f">visualize\_isochrone\_rdpu</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a0fd88b59fa60690529b8fb71cb4b46f8">visualize\_isochrone\_rdylbu</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ab228af3a08797803fae534c862bebf1f">visualize\_isochrone\_rdylgn</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad9e50d3187e16ab49f7f21eec64fa3a8">visualize\_isochrone\_reds</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a93886894e86282a3cf7c75e8c53c39ae">visualize\_isochrone\_seismic</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aca8e6ad12ed9920ac31c535d778a934f">visualize\_isochrone\_set1</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a94d1a397d69c60ef9f025f74e32e788d">visualize\_isochrone\_set2</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a141f8cc236e2d71da4d50c7c0568a466">visualize\_isochrone\_set3</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ae2f82a5f727664a81821e2c9daaa2e00">visualize\_isochrone\_spectral</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aa275df8af449954767204c293922fca0">visualize\_isochrone\_spring</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a46ef253b3a6cb1aec8c599cc583be9e5">visualize\_isochrone\_summer</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a77ca451bc67ea20f28b4e4489f1e008d">visualize\_isochrone\_terrain</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#af619e26140518cbf50ad3a20dea200b7">visualize\_isochrone\_viridis</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#afd2eb18c9fab60db99bab8fe1f7cab43">visualize\_isochrone\_winter</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a4d9fd202f936b9601aaac5c313e9258f">visualize\_isochrone\_wistia</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a1cd296889da7b5a34b81f8a723cec611">visualize\_isochrone\_ylgn</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a517e8f3064cdc1ca71e0e38de8bd4ea4">visualize\_isochrone\_ylgnbu</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ac461d6a9eb1a40c0f739e7aad43f2bc2">visualize\_isochrone\_ylorbr</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#aa7a2140c4798cc9b8f244868417f85e7">visualize\_isochrone\_ylorrd</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#af450f9ad252f5818f3faab770ec106fc">visualize\_isochrone\_jet</a>.
                    </li>
                  </ul>
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>solveOptions</td>

                <td>
                  Solver specific parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a3483d7b72a81b7938aab4c007a729fc4">visualize\_isochrone\_remove\_previous\_restrictions</a>: Ignore the restrictions applied to the graph during the creation stage and only use the restrictions specified in this request if set to <a href="/content/api/cpp/namespacegpudb#ac9afd2ad462e144ada1a2bcde60ef0a0">true</a>. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ac9afd2ad462e144ada1a2bcde60ef0a0">visualize\_isochrone\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a1fcf7ebbdee8d71a6ded7d06113c894f">visualize\_isochrone\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a1fcf7ebbdee8d71a6ded7d06113c894f">visualize\_isochrone\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#ae6b56cae6b95bd6ec87d53f60be804a7">visualize\_isochrone\_restriction\_threshold\_value</a>: Value-based restriction comparison. Any node or edge with a 'RESTRICTIONS\_VALUECOMPARED' value greater than the <a href="/content/api/cpp/namespacegpudb#ae6b56cae6b95bd6ec87d53f60be804a7">restriction\_threshold\_value</a> will not be included in the solution. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a4dc28af7e326ce19fcf79d375a5fba78">visualize\_isochrone\_uniform\_weights</a>: When specified, assigns the given value to all the edges in the graph. Note that weights provided in <span>weightsOnEdges</span> will override this value. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>contourOptions</td>

                <td>
                  Contour specific parameters.

                  <ul>
                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a34c329f05f7179ea53f65c86c425d97f">visualize\_isochrone\_projection</a>: Spatial Reference System (i.e. EPSG Code). Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a10d74aebab8814a599ccbc5763f672fb">visualize\_isochrone\_3857</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ad34828659d612628017bc2525bfb179a">visualize\_isochrone\_102100</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a324450ab53e47cd5d1b04fcb7ec83710">visualize\_isochrone\_900913</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ae93881b1c178dd582bf84f1b70169fcf">visualize\_isochrone\_EPSG\_4326</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a832462f7aa56859ffc3f65078354ccd0">visualize\_isochrone\_PLATE\_CARREE</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ac04816967d903f682fa6b033fea50e83">visualize\_isochrone\_EPSG\_900913</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ab208354411b31a8dbebcfd34245311bc">visualize\_isochrone\_EPSG\_102100</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a8925fca8e23cd9d0622ba6067f3ce1f1">visualize\_isochrone\_EPSG\_3857</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ae90833bee6d47168dfde507358c59268">visualize\_isochrone\_WEB\_MERCATOR</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a832462f7aa56859ffc3f65078354ccd0">visualize\_isochrone\_PLATE\_CARREE</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a9d22b3c5b54739e6fb5b4c24a99945f7">visualize\_isochrone\_width</a>: When <span>generateImage</span> is set to <a href="/content/api/cpp/namespacegpudb#ac9afd2ad462e144ada1a2bcde60ef0a0">true</a>, width of the generated image. The default value is '512'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a6fffbbfe7224587808e17635fbe3e68a">visualize\_isochrone\_height</a>: When <span>generateImage</span> is set to <a href="/content/api/cpp/namespacegpudb#ac9afd2ad462e144ada1a2bcde60ef0a0">true</a>, height of the generated image. If the default value is used, the <a href="/content/api/cpp/namespacegpudb#a6fffbbfe7224587808e17635fbe3e68a">height</a> is set to the value resulting from multiplying the aspect ratio by the <a href="/content/api/cpp/namespacegpudb#a9d22b3c5b54739e6fb5b4c24a99945f7">width</a>. The default value is '-1'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a5bbdef878b1eb27ec03008f0986074ad">visualize\_isochrone\_search\_radius</a>: When interpolating the graph solution to generate the isochrone, neighborhood of influence of sample data (in percent of the image/grid). The default value is '20'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ae81a20d2d6572efd5457eb1459760459">visualize\_isochrone\_grid\_size</a>: When interpolating the graph solution to generate the isochrone, number of subdivisions along the x axis when building the grid (the y is computed using the aspect ratio of the output image). The default value is '100'. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#afc0852bb81429c3014ca5957e8a31d6d">visualize\_isochrone\_color\_isolines</a>: Color each isoline according to the colormap; otherwise, use the foreground color. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ac9afd2ad462e144ada1a2bcde60ef0a0">visualize\_isochrone\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a1fcf7ebbdee8d71a6ded7d06113c894f">visualize\_isochrone\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ac9afd2ad462e144ada1a2bcde60ef0a0">visualize\_isochrone\_true</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a1be64b641b1965cec3851e603c405969">visualize\_isochrone\_add\_labels</a>: If set to <a href="/content/api/cpp/namespacegpudb#ac9afd2ad462e144ada1a2bcde60ef0a0">true</a>, add labels to the isolines. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ac9afd2ad462e144ada1a2bcde60ef0a0">visualize\_isochrone\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a1fcf7ebbdee8d71a6ded7d06113c894f">visualize\_isochrone\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a1fcf7ebbdee8d71a6ded7d06113c894f">visualize\_isochrone\_false</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a1bd360eb2f37aeefaf2367d44029fe53">visualize\_isochrone\_labels\_font\_size</a>: When <a href="/content/api/cpp/namespacegpudb#a1be64b641b1965cec3851e603c405969">add\_labels</a> is set to <a href="/content/api/cpp/namespacegpudb#ac9afd2ad462e144ada1a2bcde60ef0a0">true</a>, size of the font (in pixels) to use for labels. The default value is '12'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a299e212bebdb027701fd328d0a69c539">visualize\_isochrone\_labels\_font\_family</a>: When <a href="/content/api/cpp/namespacegpudb#a1be64b641b1965cec3851e603c405969">add\_labels</a> is set to <a href="/content/api/cpp/namespacegpudb#ac9afd2ad462e144ada1a2bcde60ef0a0">true</a>, font name to be used when adding labels. The default value is 'arial'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a5adaa2beae23f9628eeec00633e415a4">visualize\_isochrone\_labels\_search\_window</a>: When <a href="/content/api/cpp/namespacegpudb#a1be64b641b1965cec3851e603c405969">add\_labels</a> is set to <a href="/content/api/cpp/namespacegpudb#ac9afd2ad462e144ada1a2bcde60ef0a0">true</a>, a search window is used to rate the local quality of each isoline. Smooth, continuous, long stretches with relatively flat angles are favored. The provided value is multiplied by the <a href="/content/api/cpp/namespacegpudb#a1bd360eb2f37aeefaf2367d44029fe53">labels\_font\_size</a> to calculate the final window size. The default value is '4'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a8b0b65774fb9554dd6c9df3194d2f489">visualize\_isochrone\_labels\_intralevel\_separation</a>: When <a href="/content/api/cpp/namespacegpudb#a1be64b641b1965cec3851e603c405969">add\_labels</a> is set to <a href="/content/api/cpp/namespacegpudb#ac9afd2ad462e144ada1a2bcde60ef0a0">true</a>, this value determines the distance (in multiples of the <a href="/content/api/cpp/namespacegpudb#a1bd360eb2f37aeefaf2367d44029fe53">labels\_font\_size</a>) to use when separating labels of different values. The default value is '4'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#ace9e610e473ef0fdc1312b231f14e014">visualize\_isochrone\_labels\_interlevel\_separation</a>: When <a href="/content/api/cpp/namespacegpudb#a1be64b641b1965cec3851e603c405969">add\_labels</a> is set to <a href="/content/api/cpp/namespacegpudb#ac9afd2ad462e144ada1a2bcde60ef0a0">true</a>, this value determines the distance (in percent of the total window size) to use when separating labels of the same value. The default value is '20'. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a26499d4826e70a500e1c2cc127ecd8e4">visualize\_isochrone\_labels\_max\_angle</a>: When <a href="/content/api/cpp/namespacegpudb#a1be64b641b1965cec3851e603c405969">add\_labels</a> is set to <a href="/content/api/cpp/namespacegpudb#ac9afd2ad462e144ada1a2bcde60ef0a0">true</a>, maximum angle (in degrees) from the vertical to use when adding labels. The default value is '60'. </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>options</td>

                <td>
                  Additional parameters.

                  <ul>
                    <li> <a href="/content/api/cpp/namespacegpudb#a0c3a1331151edbea8282ee334eefecc7">visualize\_isochrone\_solve\_table</a>: Name of the table to host intermediate solve results, in \[schema\_name.]table\_name format, using standard <a href="/content/concepts/tables/#table-name-resolution">name resolution rules</a> and meeting <a href="/content/concepts/tables/#table-naming-criteria">table naming criteria</a>. This table will contain the position and cost for each vertex in the graph. If the default value is used, a temporary table is created and deleted once the solution is calculated. The default value is ''. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#ae564a6b2e068d464d9aee6a840650cd3">visualize\_isochrone\_is\_replicated</a>: If set to <a href="/content/api/cpp/namespacegpudb#ac9afd2ad462e144ada1a2bcde60ef0a0">true</a>, replicate the <a href="/content/api/cpp/namespacegpudb#a0c3a1331151edbea8282ee334eefecc7">solve\_table</a>. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ac9afd2ad462e144ada1a2bcde60ef0a0">visualize\_isochrone\_true</a> </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a1fcf7ebbdee8d71a6ded7d06113c894f">visualize\_isochrone\_false</a> </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#ac9afd2ad462e144ada1a2bcde60ef0a0">visualize\_isochrone\_true</a>.
                    </li>

                    <li> <a href="/content/api/cpp/namespacegpudb#a887c43e0c560a7821b9d16e040966b17">visualize\_isochrone\_data\_min\_x</a>: Lower bound for the x values. If not provided, it will be computed from the bounds of the input data. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a3bf28f9984af4bee28465c49df4745fe">visualize\_isochrone\_data\_max\_x</a>: Upper bound for the x values. If not provided, it will be computed from the bounds of the input data. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a0d535972e2625430510f338c33e1795e">visualize\_isochrone\_data\_min\_y</a>: Lower bound for the y values. If not provided, it will be computed from the bounds of the input data. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#aba0a0dfdc62d2c5a7bd474651d8bc426">visualize\_isochrone\_data\_max\_y</a>: Upper bound for the y values. If not provided, it will be computed from the bounds of the input data. </li>
                    <li> <a href="/content/api/cpp/namespacegpudb#a758bcdc9e7b93ea554834b9bd155ddad">visualize\_isochrone\_concavity\_level</a>: Factor to qualify the concavity of the isochrone curves. The lower the value, the more convex (with '0' being completely convex and '1' being the most concave). The default value is '0.5'. The minimum allowed value is '0'. The maximum allowed value is '1'. </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#a47f849e7545c84befa010279eb4bcc96">visualize\_isochrone\_use\_priority\_queue\_solvers</a>: Sets the solver methods explicitly if true. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#ac9afd2ad462e144ada1a2bcde60ef0a0">visualize\_isochrone\_true</a>: Uses the solvers scheduled for 'shortest\_path' and 'inverse\_shortest\_path' based on <a href="/content/api/cpp/namespacegpudb#af2e95597b4516659fd1efacd2147f5b9">solve\_direction</a>. </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#a1fcf7ebbdee8d71a6ded7d06113c894f">visualize\_isochrone\_false</a>: Uses the solvers 'priority\_queue' and 'inverse\_priority\_queue' based on <a href="/content/api/cpp/namespacegpudb#af2e95597b4516659fd1efacd2147f5b9">solve\_direction</a>. </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a1fcf7ebbdee8d71a6ded7d06113c894f">visualize\_isochrone\_false</a>.
                    </li>

                    <li>
                      <a href="/content/api/cpp/namespacegpudb#af2e95597b4516659fd1efacd2147f5b9">visualize\_isochrone\_solve\_direction</a>: Specify whether we are going to the source node, or starting from it. Supported values:

                      <ul>
                        <li> <a href="/content/api/cpp/namespacegpudb#a2ae81d9fe0ef6bb91c1bccd02f0492f7">visualize\_isochrone\_from\_source</a>: Shortest path to get to the source (inverse Dijkstra). </li>
                        <li> <a href="/content/api/cpp/namespacegpudb#ac6d559b19e604edbf9c57b059b458e85">visualize\_isochrone\_to\_source</a>: Shortest path to source (Dijkstra). </li>
                      </ul>

                      The default value is <a href="/content/api/cpp/namespacegpudb#a2ae81d9fe0ef6bb91c1bccd02f0492f7">visualize\_isochrone\_from\_source</a>.
                    </li>
                  </ul>

                  The default value is an empty map.
                </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1VisualizeIsochroneResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1VisualizeIsochroneResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ac318fcde27f507588dfb91ad77308c5f">◆ </a></span>visualizeIsochrone() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1VisualizeIsochroneResponse">VisualizeIsochroneResponse</a> gpudb::GPUdb::visualizeIsochrone </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1VisualizeIsochroneRequest">VisualizeIsochroneRequest</a> &</td>
            <td><span><span>request\_</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Generate an image containing isolines for travel results using an existing graph. </p>
        <p>Isolines represent curves of equal cost, with cost typically referring to the time or distance assigned as the weights of the underlying graph. See <a href="/content/graph_solver/network_graph_solver/">Graphs and Solvers</a> for more information on graphs.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1VisualizeIsochroneRequest">Request</a> object containing the parameters for the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1VisualizeIsochroneResponse">Response</a> object containing the result of the operation. </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a58538642cadb57489acbe03ce689d962">◆ </a></span>visualizeIsochrone() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/structgpudb_1_1VisualizeIsochroneResponse">VisualizeIsochroneResponse</a> & gpudb::GPUdb::visualizeIsochrone </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/structgpudb_1_1VisualizeIsochroneRequest">VisualizeIsochroneRequest</a> &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td><a href="/content/api/cpp/structgpudb_1_1VisualizeIsochroneResponse">VisualizeIsochroneResponse</a> &</td>
            <td><span><span>response\_</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Generate an image containing isolines for travel results using an existing graph. </p>
        <p>Isolines represent curves of equal cost, with cost typically referring to the time or distance assigned as the weights of the underlying graph. See <a href="/content/graph_solver/network_graph_solver/">Graphs and Solvers</a> for more information on graphs.</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>request\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1VisualizeIsochroneRequest">Request</a> object containing the parameters for the operation. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>response\_</td>
                <td><a href="/content/api/cpp/structgpudb_1_1VisualizeIsochroneResponse">Response</a> object containing the results of the operation.</td>
              </tr>
            </table>
          </div>
        </div>

        <div>
          <div>Returns</div>
          <div><a href="/content/api/cpp/structgpudb_1_1VisualizeIsochroneResponse">Response</a> object containing the result of the operation (initially passed in by reference). </div>
        </div>
      </div>
    </div>

    <h2>Friends And Related Symbol Documentation</h2>
    <h2><span><a href="#af978370cd5d6f902b6e48caad00d1a30">◆ </a></span>FailbackPollerService</h2>

    <div>
      <div>
        <table>
          <tr>
            <td>
              <table>
                <tr>
                  <td>friend class <a href="/content/api/cpp/classgpudb_1_1FailbackPollerService">FailbackPollerService</a></td>
                </tr>
              </table>
            </td>

            <td> <span><span>friend</span></span> </td>
          </tr>
        </table>
      </div>

      <div>
        <p>Definition at line <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp#L613">613</a> of file <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">GPUdb.hpp</a>.</p>
      </div>
    </div>

    <h2>Member Data Documentation</h2>
    <h2><span><a href="#ac1195274295b2f4afb72b6ddeca3cd47">◆ </a></span>DB\_CONNECTION\_REFUSED\_ERROR\_MESSAGE</h2>

    <div>
      <div>
        <table>
          <tr>
            <td>
              <table>
                <tr>
                  <td>const std::string gpudb::GPUdb::DB\_CONNECTION\_REFUSED\_ERROR\_MESSAGE</td>
                </tr>
              </table>
            </td>

            <td> <span><span>static</span></span> </td>
          </tr>
        </table>
      </div>

      <div>
        <p>Definition at line <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp#L170">170</a> of file <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">GPUdb.hpp</a>.</p>
      </div>
    </div>

    <h2><span><a href="#abb07a4cacb0463c2ed1c90cfc55babe0">◆ </a></span>DB\_CONNECTION\_RESET\_ERROR\_MESSAGE</h2>

    <div>
      <div>
        <table>
          <tr>
            <td>
              <table>
                <tr>
                  <td>const std::string gpudb::GPUdb::DB\_CONNECTION\_RESET\_ERROR\_MESSAGE</td>
                </tr>
              </table>
            </td>

            <td> <span><span>static</span></span> </td>
          </tr>
        </table>
      </div>

      <div>
        <p>Special error messages indicating that a connection failure happened (generally should trigger a high-availability failover if applicable) </p>
        <p>Definition at line <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp#L169">169</a> of file <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">GPUdb.hpp</a>.</p>
      </div>
    </div>

    <h2><span><a href="#aad94aa5b2c6962807f9f798a9121e85d">◆ </a></span>DB\_DRAINING\_HA\_QUEUE\_ERROR\_MESSAGE</h2>

    <div>
      <div>
        <table>
          <tr>
            <td>
              <table>
                <tr>
                  <td>const std::string gpudb::GPUdb::DB\_DRAINING\_HA\_QUEUE\_ERROR\_MESSAGE</td>
                </tr>
              </table>
            </td>

            <td> <span><span>static</span></span> </td>
          </tr>
        </table>
      </div>

      <div>
        <p>Definition at line <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp#L175">175</a> of file <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">GPUdb.hpp</a>.</p>
      </div>
    </div>

    <h2><span><a href="#a9aac43bdb59a1b520df4b93b45d6e5f6">◆ </a></span>DB\_EXITING\_ERROR\_MESSAGE</h2>

    <div>
      <div>
        <table>
          <tr>
            <td>
              <table>
                <tr>
                  <td>const std::string gpudb::GPUdb::DB\_EXITING\_ERROR\_MESSAGE</td>
                </tr>
              </table>
            </td>

            <td> <span><span>static</span></span> </td>
          </tr>
        </table>
      </div>

      <div>
        <p>Definition at line <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp#L171">171</a> of file <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">GPUdb.hpp</a>.</p>
      </div>
    </div>

    <h2><span><a href="#a0fdffb69f3b093816535e116a873c2fc">◆ </a></span>DB\_HM\_OFFLINE\_ERROR\_MESSAGE</h2>

    <div>
      <div>
        <table>
          <tr>
            <td>
              <table>
                <tr>
                  <td>const std::string gpudb::GPUdb::DB\_HM\_OFFLINE\_ERROR\_MESSAGE</td>
                </tr>
              </table>
            </td>

            <td> <span><span>static</span></span> </td>
          </tr>
        </table>
      </div>

      <div>
        <p>Definition at line <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp#L174">174</a> of file <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">GPUdb.hpp</a>.</p>
      </div>
    </div>

    <h2><span><a href="#a4adf3bf6a65b64377e0dd74c2bde116c">◆ </a></span>DB\_OFFLINE\_ERROR\_MESSAGE</h2>

    <div>
      <div>
        <table>
          <tr>
            <td>
              <table>
                <tr>
                  <td>const std::string gpudb::GPUdb::DB\_OFFLINE\_ERROR\_MESSAGE</td>
                </tr>
              </table>
            </td>

            <td> <span><span>static</span></span> </td>
          </tr>
        </table>
      </div>

      <div>
        <p>Definition at line <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp#L172">172</a> of file <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">GPUdb.hpp</a>.</p>
      </div>
    </div>

    <h2><span><a href="#a6735918a5c9686b6961baa89f35d49ce">◆ </a></span>DB\_QUERY\_PLANNER\_ERROR\_MESSAGE</h2>

    <div>
      <div>
        <table>
          <tr>
            <td>
              <table>
                <tr>
                  <td>const std::string gpudb::GPUdb::DB\_QUERY\_PLANNER\_ERROR\_MESSAGE</td>
                </tr>
              </table>
            </td>

            <td> <span><span>static</span></span> </td>
          </tr>
        </table>
      </div>

      <div>
        <p>Definition at line <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp#L177">177</a> of file <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">GPUdb.hpp</a>.</p>
      </div>
    </div>

    <h2><span><a href="#a9a2b0a48fee2096d6104a276c818a946">◆ </a></span>DB\_SHUTTING\_DOWN\_ERROR\_MESSAGE</h2>

    <div>
      <div>
        <table>
          <tr>
            <td>
              <table>
                <tr>
                  <td>const std::string gpudb::GPUdb::DB\_SHUTTING\_DOWN\_ERROR\_MESSAGE</td>
                </tr>
              </table>
            </td>

            <td> <span><span>static</span></span> </td>
          </tr>
        </table>
      </div>

      <div>
        <p>Definition at line <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp#L176">176</a> of file <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">GPUdb.hpp</a>.</p>
      </div>
    </div>

    <h2><span><a href="#a7ec05fd685e80f87bca35fdc805dea9a">◆ </a></span>DB\_SYSTEM\_LIMITED\_ERROR\_MESSAGE</h2>

    <div>
      <div>
        <table>
          <tr>
            <td>
              <table>
                <tr>
                  <td>const std::string gpudb::GPUdb::DB\_SYSTEM\_LIMITED\_ERROR\_MESSAGE</td>
                </tr>
              </table>
            </td>

            <td> <span><span>static</span></span> </td>
          </tr>
        </table>
      </div>

      <div>
        <p>Definition at line <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp#L173">173</a> of file <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">GPUdb.hpp</a>.</p>
      </div>
    </div>

    <h2><span><a href="#a17cf9ebfe00819bb097974e7e489ed4c">◆ </a></span>END\_OF\_SET</h2>

    <div>
      <div>
        <table>
          <tr>
            <td>
              <table>
                <tr>
                  <td>const int64\_t gpudb::GPUdb::END\_OF\_SET = -9999</td>
                </tr>
              </table>
            </td>

            <td> <span><span>static</span></span> </td>
          </tr>
        </table>
      </div>

      <div>
        <p>Definition at line <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp#L165">165</a> of file <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">GPUdb.hpp</a>.</p>
      </div>
    </div>

    <h2><span><a href="#a3d5f074e0926e6aee5e749b54ed0c651">◆ </a></span>HEADER\_AUTHORIZATION</h2>

    <div>
      <div>
        <table>
          <tr>
            <td>
              <table>
                <tr>
                  <td>const std::string gpudb::GPUdb::HEADER\_AUTHORIZATION</td>
                </tr>
              </table>
            </td>

            <td> <span><span>static</span></span> </td>
          </tr>
        </table>
      </div>

      <div>
        <p>Headers used internally; MUST add each of them to PROTECTED\_HEADERS in the .cpp file. </p>
        <p>Definition at line <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp#L181">181</a> of file <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">GPUdb.hpp</a>.</p>
      </div>
    </div>

    <h2><span><a href="#ac440e0e4cdde8ba0be2b595270a6ea38">◆ </a></span>HEADER\_CONTENT\_LENGTH</h2>

    <div>
      <div>
        <table>
          <tr>
            <td>
              <table>
                <tr>
                  <td>const std::string gpudb::GPUdb::HEADER\_CONTENT\_LENGTH</td>
                </tr>
              </table>
            </td>

            <td> <span><span>static</span></span> </td>
          </tr>
        </table>
      </div>

      <div>
        <p>Definition at line <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp#L183">183</a> of file <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">GPUdb.hpp</a>.</p>
      </div>
    </div>

    <h2><span><a href="#a43a98d96248d5565df04e2d99cce0efb">◆ </a></span>HEADER\_CONTENT\_TYPE</h2>

    <div>
      <div>
        <table>
          <tr>
            <td>
              <table>
                <tr>
                  <td>const std::string gpudb::GPUdb::HEADER\_CONTENT\_TYPE</td>
                </tr>
              </table>
            </td>

            <td> <span><span>static</span></span> </td>
          </tr>
        </table>
      </div>

      <div>
        <p>Definition at line <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp#L182">182</a> of file <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">GPUdb.hpp</a>.</p>
      </div>
    </div>

    <h2><span><a href="#a73c703169b362238b268caefcb381743">◆ </a></span>HEADER\_HA\_SYNC\_MODE</h2>

    <div>
      <div>
        <table>
          <tr>
            <td>
              <table>
                <tr>
                  <td>const std::string gpudb::GPUdb::HEADER\_HA\_SYNC\_MODE</td>
                </tr>
              </table>
            </td>

            <td> <span><span>static</span></span> </td>
          </tr>
        </table>
      </div>

      <div>
        <p>Definition at line <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp#L184">184</a> of file <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">GPUdb.hpp</a>.</p>
      </div>
    </div>

    <h2><span><a href="#afe0a7acb915810dfb74a31e4c786dcb4">◆ </a></span>HEADER\_USER\_AGENT</h2>

    <div>
      <div>
        <table>
          <tr>
            <td>
              <table>
                <tr>
                  <td>const std::string gpudb::GPUdb::HEADER\_USER\_AGENT</td>
                </tr>
              </table>
            </td>

            <td> <span><span>static</span></span> </td>
          </tr>
        </table>
      </div>

      <div>
        <p>Definition at line <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp#L185">185</a> of file <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">GPUdb.hpp</a>.</p>
      </div>
    </div>

    <hr />

    The documentation for this class was generated from the following files:

    <ul>
      <li>gpudb/<a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">GPUdb.hpp</a></li>
      <li>gpudb/<a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdbTemplates.hpp">GPUdbTemplates.hpp</a></li>
    </ul>
  </div>
</div>


# gpudb::GPUdbException
Source: https://docs.kinetica.com/content/api/cpp/classgpudb_1_1GPUdbException

gpudb::GPUdbException — Kinetica C++ API

<div>
  <div>
    <p><code>#include \<<a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdbException.hpp">gpudb/GPUdbException.hpp</a>></code></p>

    <table>
      <tr>
        <td>
          <h2> Public Member Functions</h2>
        </td>
      </tr>

      <tr>
        <td> </td>
        <td><a href="#a0447915d6b0f64ff56b3eda95da20274">GPUdbException</a> (const std::string \&messageParam)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>virtual const char \* </td>
        <td><a href="#a4cef6346f0006ae281c79673b5111029">what</a> () const throw ()</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td> </td>
        <td><a href="#acbcf261d2b250c57227d6c69228d969b">\~GPUdbException</a> () throw ()</td>
      </tr>

      <tr>
        <td> </td>
      </tr>
    </table>

    <table>
      <tr>
        <td>
          <h2> Protected Attributes</h2>
        </td>
      </tr>

      <tr>
        <td>std::string </td>
        <td><a href="#aa67f34470b4c25da205658eb53bd9295">message</a></td>
      </tr>

      <tr>
        <td> </td>
      </tr>
    </table>

    <h2>Detailed Description</h2>

    <div>
      <p>Definition at line <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdbException.hpp#L17">17</a> of file <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdbException.hpp">GPUdbException.hpp</a>.</p>
    </div>

    <h2>Constructor & Destructor Documentation</h2>
    <h2><span><a href="#a0447915d6b0f64ff56b3eda95da20274">◆ </a></span>GPUdbException()</h2>

    <div>
      <div>
        <table>
          <tr>
            <td>
              <table>
                <tr>
                  <td>gpudb::GPUdbException::GPUdbException </td>
                  <td>(</td>
                  <td>const std::string &</td>
                  <td><span><span>messageParam</span></span></td>
                  <td>)</td>

                  <td />
                </tr>
              </table>
            </td>

            <td> <span><span>inline</span></span> </td>
          </tr>
        </table>
      </div>

      <div>
        <p>Definition at line <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdbException.hpp#L20">20</a> of file <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdbException.hpp">GPUdbException.hpp</a>.</p>
      </div>
    </div>

    <h2><span><a href="#acbcf261d2b250c57227d6c69228d969b">◆ </a></span>\~GPUdbException()</h2>

    <div>
      <div>
        <table>
          <tr>
            <td>
              <table>
                <tr>
                  <td>gpudb::GPUdbException::\~GPUdbException </td>
                  <td>(</td>

                  <td>
                    <span>
                      <span />
                    </span>
                  </td>

                  <td>)</td>

                  <td />
                </tr>

                <tr>
                  <td>throw </td>
                  <td>(</td>
                  <td> )</td>

                  <td />

                  <td />

                  <td />
                </tr>
              </table>
            </td>

            <td> <span><span>inline</span></span> </td>
          </tr>
        </table>
      </div>

      <div>
        <p>Definition at line <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdbException.hpp#L24">24</a> of file <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdbException.hpp">GPUdbException.hpp</a>.</p>
      </div>
    </div>

    <h2>Member Function Documentation</h2>
    <h2><span><a href="#a4cef6346f0006ae281c79673b5111029">◆ </a></span>what()</h2>

    <div>
      <div>
        <table>
          <tr>
            <td>
              <table>
                <tr>
                  <td>virtual const char \* gpudb::GPUdbException::what </td>
                  <td>(</td>

                  <td>
                    <span>
                      <span />
                    </span>
                  </td>

                  <td>)</td>
                  <td> const</td>
                </tr>

                <tr>
                  <td>throw </td>
                  <td>(</td>
                  <td> )</td>

                  <td />

                  <td />

                  <td />
                </tr>
              </table>
            </td>

            <td> <span><span>inline</span><span>virtual</span></span> </td>
          </tr>
        </table>
      </div>

      <div>
        <p>Reimplemented in <a href="/content/api/cpp/classgpudb_1_1GPUdbExitException#aaa419de7a8e9510098606aeb2b08f538">gpudb::GPUdbExitException</a>, <a href="/content/api/cpp/classgpudb_1_1GPUdbHAUnavailableException#a015ea39668da2dfe121fd1bd5bc838d7">gpudb::GPUdbHAUnavailableException</a>, <a href="/content/api/cpp/classgpudb_1_1GPUdbInsertionException#ae0d64df3bc540838a2b52c01771a4b8a">gpudb::GPUdbInsertionException</a>, and <a href="/content/api/cpp/classgpudb_1_1GPUdbSubmitException#a1941413869972ca26d948662322a42d2">gpudb::GPUdbSubmitException</a>.</p>
        <p>Definition at line <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdbException.hpp#L22">22</a> of file <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdbException.hpp">GPUdbException.hpp</a>.</p>
      </div>
    </div>

    <h2>Member Data Documentation</h2>
    <h2><span><a href="#aa67f34470b4c25da205658eb53bd9295">◆ </a></span>message</h2>

    <div>
      <div>
        <table>
          <tr>
            <td>
              <table>
                <tr>
                  <td>std::string gpudb::GPUdbException::message</td>
                </tr>
              </table>
            </td>

            <td> <span><span>protected</span></span> </td>
          </tr>
        </table>
      </div>

      <div>
        <p>Definition at line <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdbException.hpp#L27">27</a> of file <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdbException.hpp">GPUdbException.hpp</a>.</p>
      </div>
    </div>

    <hr />

    The documentation for this class was generated from the following file:

    <ul>
      <li>gpudb/<a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdbException.hpp">GPUdbException.hpp</a></li>
    </ul>
  </div>
</div>


# gpudb::GPUdbExitException
Source: https://docs.kinetica.com/content/api/cpp/classgpudb_1_1GPUdbExitException

gpudb::GPUdbExitException — Kinetica C++ API

<div>
  <div>
    <p><code>#include \<<a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdbException.hpp">gpudb/GPUdbException.hpp</a>></code></p>

    <table>
      <tr>
        <td>
          <h2> Public Member Functions</h2>
        </td>
      </tr>

      <tr>
        <td> </td>
        <td><a href="#a0ad5a76f230cff64812161e3212eaba8">GPUdbExitException</a> (const std::string \&messageParam)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>virtual const char \* </td>
        <td><a href="#aaa419de7a8e9510098606aeb2b08f538">what</a> () const throw ()</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td> </td>
        <td><a href="#a3211c7801bc8cd02121550b84065c63c">\~GPUdbExitException</a> () throw ()</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td> Public Member Functions inherited from <a href="/content/api/cpp/classgpudb_1_1GPUdbException">gpudb::GPUdbException</a></td>
      </tr>

      <tr>
        <td> </td>
        <td><a href="/content/api/cpp/classgpudb_1_1GPUdbException#a0447915d6b0f64ff56b3eda95da20274">GPUdbException</a> (const std::string \&messageParam)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td> </td>
        <td><a href="/content/api/cpp/classgpudb_1_1GPUdbException#acbcf261d2b250c57227d6c69228d969b">\~GPUdbException</a> () throw ()</td>
      </tr>

      <tr>
        <td> </td>
      </tr>
    </table>

    <table>
      <tr>
        <td>
          <h2> Additional Inherited Members</h2>
        </td>
      </tr>

      <tr>
        <td> Protected Attributes inherited from <a href="/content/api/cpp/classgpudb_1_1GPUdbException">gpudb::GPUdbException</a></td>
      </tr>

      <tr>
        <td>std::string </td>
        <td><a href="/content/api/cpp/classgpudb_1_1GPUdbException#aa67f34470b4c25da205658eb53bd9295">message</a></td>
      </tr>

      <tr>
        <td> </td>
      </tr>
    </table>

    <h2>Detailed Description</h2>

    <div>
      <p>Definition at line <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdbException.hpp#L57">57</a> of file <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdbException.hpp">GPUdbException.hpp</a>.</p>
    </div>

    <h2>Constructor & Destructor Documentation</h2>
    <h2><span><a href="#a0ad5a76f230cff64812161e3212eaba8">◆ </a></span>GPUdbExitException()</h2>

    <div>
      <div>
        <table>
          <tr>
            <td>
              <table>
                <tr>
                  <td>gpudb::GPUdbExitException::GPUdbExitException </td>
                  <td>(</td>
                  <td>const std::string &</td>
                  <td><span><span>messageParam</span></span></td>
                  <td>)</td>

                  <td />
                </tr>
              </table>
            </td>

            <td> <span><span>inline</span></span> </td>
          </tr>
        </table>
      </div>

      <div>
        <p>Definition at line <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdbException.hpp#L60">60</a> of file <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdbException.hpp">GPUdbException.hpp</a>.</p>
      </div>
    </div>

    <h2><span><a href="#a3211c7801bc8cd02121550b84065c63c">◆ </a></span>\~GPUdbExitException()</h2>

    <div>
      <div>
        <table>
          <tr>
            <td>
              <table>
                <tr>
                  <td>gpudb::GPUdbExitException::\~GPUdbExitException </td>
                  <td>(</td>

                  <td>
                    <span>
                      <span />
                    </span>
                  </td>

                  <td>)</td>

                  <td />
                </tr>

                <tr>
                  <td>throw </td>
                  <td>(</td>
                  <td> )</td>

                  <td />

                  <td />

                  <td />
                </tr>
              </table>
            </td>

            <td> <span><span>inline</span></span> </td>
          </tr>
        </table>
      </div>

      <div>
        <p>Definition at line <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdbException.hpp#L64">64</a> of file <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdbException.hpp">GPUdbException.hpp</a>.</p>
      </div>
    </div>

    <h2>Member Function Documentation</h2>
    <h2><span><a href="#aaa419de7a8e9510098606aeb2b08f538">◆ </a></span>what()</h2>

    <div>
      <div>
        <table>
          <tr>
            <td>
              <table>
                <tr>
                  <td>virtual const char \* gpudb::GPUdbExitException::what </td>
                  <td>(</td>

                  <td>
                    <span>
                      <span />
                    </span>
                  </td>

                  <td>)</td>
                  <td> const</td>
                </tr>

                <tr>
                  <td>throw </td>
                  <td>(</td>
                  <td> )</td>

                  <td />

                  <td />

                  <td />
                </tr>
              </table>
            </td>

            <td> <span><span>inline</span><span>virtual</span></span> </td>
          </tr>
        </table>
      </div>

      <div>
        <p>Reimplemented from <a href="/content/api/cpp/classgpudb_1_1GPUdbException#a4cef6346f0006ae281c79673b5111029">gpudb::GPUdbException</a>.</p>
        <p>Definition at line <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdbException.hpp#L62">62</a> of file <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdbException.hpp">GPUdbException.hpp</a>.</p>
      </div>
    </div>

    <hr />

    The documentation for this class was generated from the following file:

    <ul>
      <li>gpudb/<a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdbException.hpp">GPUdbException.hpp</a></li>
    </ul>
  </div>
</div>


# gpudb::GPUdbHAUnavailableException
Source: https://docs.kinetica.com/content/api/cpp/classgpudb_1_1GPUdbHAUnavailableException

gpudb::GPUdbHAUnavailableException — Kinetica C++ API

<div>
  <div>
    <p><code>#include \<<a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdbException.hpp">gpudb/GPUdbException.hpp</a>></code></p>

    <table>
      <tr>
        <td>
          <h2> Public Member Functions</h2>
        </td>
      </tr>

      <tr>
        <td> </td>
        <td><a href="#abe029797e5b36a0f1edee84798a8c560">GPUdbHAUnavailableException</a> (const std::string \&messageParam)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td> </td>
        <td><a href="#a0cc7ef52d67e89927e971d4c3cf46aa6">GPUdbHAUnavailableException</a> (const std::string \&message\_, const std::vector\< <a href="/content/api/cpp/classgpudb_1_1HttpUrl">HttpUrl</a> > \&urls\_)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>virtual const char \* </td>
        <td><a href="#a015ea39668da2dfe121fd1bd5bc838d7">what</a> () const throw ()</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td> </td>
        <td><a href="#a7fc57c1135f30f3908f1b04f5320ac9e">\~GPUdbHAUnavailableException</a> () throw ()</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td> Public Member Functions inherited from <a href="/content/api/cpp/classgpudb_1_1GPUdbException">gpudb::GPUdbException</a></td>
      </tr>

      <tr>
        <td> </td>
        <td><a href="/content/api/cpp/classgpudb_1_1GPUdbException#a0447915d6b0f64ff56b3eda95da20274">GPUdbException</a> (const std::string \&messageParam)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td> </td>
        <td><a href="/content/api/cpp/classgpudb_1_1GPUdbException#acbcf261d2b250c57227d6c69228d969b">\~GPUdbException</a> () throw ()</td>
      </tr>

      <tr>
        <td> </td>
      </tr>
    </table>

    <table>
      <tr>
        <td>
          <h2> Additional Inherited Members</h2>
        </td>
      </tr>

      <tr>
        <td> Protected Attributes inherited from <a href="/content/api/cpp/classgpudb_1_1GPUdbException">gpudb::GPUdbException</a></td>
      </tr>

      <tr>
        <td>std::string </td>
        <td><a href="/content/api/cpp/classgpudb_1_1GPUdbException#aa67f34470b4c25da205658eb53bd9295">message</a></td>
      </tr>

      <tr>
        <td> </td>
      </tr>
    </table>

    <h2>Detailed Description</h2>

    <div>
      <p>Definition at line <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdbException.hpp#L68">68</a> of file <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdbException.hpp">GPUdbException.hpp</a>.</p>
    </div>

    <h2>Constructor & Destructor Documentation</h2>
    <h2><span><a href="#abe029797e5b36a0f1edee84798a8c560">◆ </a></span>GPUdbHAUnavailableException() <span>\[1/2]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>
              <table>
                <tr>
                  <td>gpudb::GPUdbHAUnavailableException::GPUdbHAUnavailableException </td>
                  <td>(</td>
                  <td>const std::string &</td>
                  <td><span><span>messageParam</span></span></td>
                  <td>)</td>

                  <td />
                </tr>
              </table>
            </td>

            <td> <span><span>inline</span></span> </td>
          </tr>
        </table>
      </div>

      <div>
        <p>Definition at line <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdbException.hpp#L71">71</a> of file <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdbException.hpp">GPUdbException.hpp</a>.</p>
      </div>
    </div>

    <h2><span><a href="#a0cc7ef52d67e89927e971d4c3cf46aa6">◆ </a></span>GPUdbHAUnavailableException() <span>\[2/2]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>gpudb::GPUdbHAUnavailableException::GPUdbHAUnavailableException </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>message\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< <a href="/content/api/cpp/classgpudb_1_1HttpUrl">HttpUrl</a> > &</td>
            <td><span><span>urls\_</span></span> )</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#a7fc57c1135f30f3908f1b04f5320ac9e">◆ </a></span>\~GPUdbHAUnavailableException()</h2>

    <div>
      <div>
        <table>
          <tr>
            <td>
              <table>
                <tr>
                  <td>gpudb::GPUdbHAUnavailableException::\~GPUdbHAUnavailableException </td>
                  <td>(</td>

                  <td>
                    <span>
                      <span />
                    </span>
                  </td>

                  <td>)</td>

                  <td />
                </tr>

                <tr>
                  <td>throw </td>
                  <td>(</td>
                  <td> )</td>

                  <td />

                  <td />

                  <td />
                </tr>
              </table>
            </td>

            <td> <span><span>inline</span></span> </td>
          </tr>
        </table>
      </div>

      <div>
        <p>Definition at line <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdbException.hpp#L78">78</a> of file <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdbException.hpp">GPUdbException.hpp</a>.</p>
      </div>
    </div>

    <h2>Member Function Documentation</h2>
    <h2><span><a href="#a015ea39668da2dfe121fd1bd5bc838d7">◆ </a></span>what()</h2>

    <div>
      <div>
        <table>
          <tr>
            <td>
              <table>
                <tr>
                  <td>virtual const char \* gpudb::GPUdbHAUnavailableException::what </td>
                  <td>(</td>

                  <td>
                    <span>
                      <span />
                    </span>
                  </td>

                  <td>)</td>
                  <td> const</td>
                </tr>

                <tr>
                  <td>throw </td>
                  <td>(</td>
                  <td> )</td>

                  <td />

                  <td />

                  <td />
                </tr>
              </table>
            </td>

            <td> <span><span>inline</span><span>virtual</span></span> </td>
          </tr>
        </table>
      </div>

      <div>
        <p>Reimplemented from <a href="/content/api/cpp/classgpudb_1_1GPUdbException#a4cef6346f0006ae281c79673b5111029">gpudb::GPUdbException</a>.</p>
        <p>Definition at line <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdbException.hpp#L76">76</a> of file <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdbException.hpp">GPUdbException.hpp</a>.</p>
      </div>
    </div>

    <hr />

    The documentation for this class was generated from the following file:

    <ul>
      <li>gpudb/<a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdbException.hpp">GPUdbException.hpp</a></li>
    </ul>
  </div>
</div>


# gpudb::GPUdbIngestor
Source: https://docs.kinetica.com/content/api/cpp/classgpudb_1_1GPUdbIngestor

gpudb::GPUdbIngestor — Kinetica C++ API

<div>
  <div>
    <p><code>#include \<<a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdbIngestor.hpp">gpudb/GPUdbIngestor.hpp</a>></code></p>
    <p>Inherits boost::noncopyable.</p>

    <table>
      <tr>
        <td>
          <h2> Public Member Functions</h2>
        </td>
      </tr>

      <tr>
        <td> </td>
        <td><a href="#a6f2f834a617b47a523183524aa496266">GPUdbIngestor</a> (const <a href="/content/api/cpp/classgpudb_1_1GPUdb">gpudb::GPUdb</a> \&db, const <a href="/content/api/cpp/classgpudb_1_1Type">gpudb::Type</a> \&record\_type, const std::string \&table\_name, const <a href="/content/api/cpp/classgpudb_1_1WorkerList">WorkerList</a> \&worker\_list, const std::map\< std::string, std::string > \&insert\_options, size\_t batch\_size)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td> </td>
        <td><a href="#a6447879fc0a551d71ac880a2ba13fd6f">GPUdbIngestor</a> (const <a href="/content/api/cpp/classgpudb_1_1GPUdb">gpudb::GPUdb</a> \&db, const <a href="/content/api/cpp/classgpudb_1_1Type">gpudb::Type</a> \&record\_type, const std::string \&table\_name, const <a href="/content/api/cpp/classgpudb_1_1WorkerList">WorkerList</a> \&worker\_list, size\_t batch\_size)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td> </td>
        <td><a href="#a5ffb11576aa3c50d505ccd11e094d55f">GPUdbIngestor</a> (const <a href="/content/api/cpp/classgpudb_1_1GPUdb">gpudb::GPUdb</a> \&db, const <a href="/content/api/cpp/classgpudb_1_1Type">gpudb::Type</a> \&record\_type, const std::string \&table\_name, const std::map\< std::string, std::string > \&insert\_options, size\_t batch\_size)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td> </td>
        <td><a href="#aa288afe85fe2b49a3848c3581d869a33">GPUdbIngestor</a> (const <a href="/content/api/cpp/classgpudb_1_1GPUdb">gpudb::GPUdb</a> \&db, const <a href="/content/api/cpp/classgpudb_1_1Type">gpudb::Type</a> \&record\_type, const std::string \&table\_name, size\_t batch\_size)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td> </td>
        <td><a href="#afe6f44767a46cf7a4f29bfbd91020920">\~GPUdbIngestor</a> ()</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>const std::string & </td>
        <td><a href="#afa4c701fcea30064daf742ae18f8c60b">getTableName</a> () const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Returns the name of the table on which this class operates. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>const <a href="/content/api/cpp/classgpudb_1_1GPUdb">gpudb::GPUdb</a> & </td>
        <td><a href="#a3a91ea8cc2865f8d7530b0eec2f75bdd">getGPUdb</a> () const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Returns the <a href="/content/api/cpp/classgpudb_1_1GPUdb">GPUdb</a> client handle that this class uses internally. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>const std::map\< std::string, std::string > & </td>
        <td><a href="#a1b25d43c9433a653fd418d46ce9851d5">getOptions</a> () const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Returns the insertion options the ingestor uses. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>size\_t </td>
        <td><a href="#a370a08d4a8f39869367c7cebbc0f075b">getCountInserted</a> () const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Returns the count of records inserted so far through this ingestor instance; An atomic operation. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>size\_t </td>
        <td><a href="#a91fcc89d4ae20c3da2c0ee0f26a1042f">getCountUpdated</a> () const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Returns the count of records updated so far through this ingestor instance; An atomic operation. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>std::vector\< <a href="/content/api/cpp/classgpudb_1_1GPUdbInsertionException">GPUdbInsertionException</a> > </td>
        <td><a href="#a26ec47ad5a83dbd4e885a4c670122fba">getErrors</a> ()</td>
      </tr>

      <tr>
        <td> </td>
        <td>Returns the list of errors received since the last call to <a href="#a26ec47ad5a83dbd4e885a4c670122fba" title="Returns the list of errors received since the last call to getErrors(), and clears the list.">getErrors()</a>, and clears the list. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>std::vector\< <a href="/content/api/cpp/classgpudb_1_1GPUdbInsertionException">GPUdbInsertionException</a> > </td>
        <td><a href="#aecff11bac1f1a19f5ee3e35a19220ce9">getWarnings</a> ()</td>
      </tr>

      <tr>
        <td> </td>
        <td>Returns the list of warnings received since the last call to <a href="#aecff11bac1f1a19f5ee3e35a19220ce9" title="Returns the list of warnings received since the last call to getWarnings(), and clears the list.">getWarnings()</a>, and clears the list. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>void </td>
        <td><a href="#ad1f6cebaf77d3673a1fe75e2bf9cac00">flush</a> ()</td>
      </tr>

      <tr>
        <td> </td>
        <td>Ensures that all queued records are inserted into the database. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>void </td>
        <td><a href="#a4d74afe2ab47ae2b18a27a2d58d8f611">insert</a> (<a href="/content/api/cpp/classgpudb_1_1GenericRecord">gpudb::GenericRecord</a> record)</td>
      </tr>

      <tr>
        <td> </td>
        <td>Queues a record for insertion into <a href="/content/api/cpp/classgpudb_1_1GPUdb">GPUdb</a>. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>void </td>
        <td><a href="#a4c3e0625dfa8e8cb47a1e1b2001b4358">insert</a> (std::vector\< <a href="/content/api/cpp/classgpudb_1_1GenericRecord">gpudb::GenericRecord</a> > records)</td>
      </tr>

      <tr>
        <td> </td>
        <td>Queues a list of records for insertion into Kientica. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>
    </table>

    <h2>Detailed Description</h2>

    <div>
      <p>Definition at line <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdbIngestor.hpp#L33">33</a> of file <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdbIngestor.hpp">GPUdbIngestor.hpp</a>.</p>
    </div>

    <h2>Constructor & Destructor Documentation</h2>
    <h2><span><a href="#a6f2f834a617b47a523183524aa496266">◆ </a></span>GPUdbIngestor() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>gpudb::GPUdbIngestor::GPUdbIngestor </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/classgpudb_1_1GPUdb">gpudb::GPUdb</a> &</td>
            <td><span><span>db</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const <a href="/content/api/cpp/classgpudb_1_1Type">gpudb::Type</a> &</td>
            <td><span><span>record\_type</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>table\_name</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const <a href="/content/api/cpp/classgpudb_1_1WorkerList">WorkerList</a> &</td>
            <td><span><span>worker\_list</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>insert\_options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>size\_t</td>
            <td><span><span>batch\_size</span></span> )</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#a6447879fc0a551d71ac880a2ba13fd6f">◆ </a></span>GPUdbIngestor() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>gpudb::GPUdbIngestor::GPUdbIngestor </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/classgpudb_1_1GPUdb">gpudb::GPUdb</a> &</td>
            <td><span><span>db</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const <a href="/content/api/cpp/classgpudb_1_1Type">gpudb::Type</a> &</td>
            <td><span><span>record\_type</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>table\_name</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const <a href="/content/api/cpp/classgpudb_1_1WorkerList">WorkerList</a> &</td>
            <td><span><span>worker\_list</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>size\_t</td>
            <td><span><span>batch\_size</span></span> )</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#a5ffb11576aa3c50d505ccd11e094d55f">◆ </a></span>GPUdbIngestor() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>gpudb::GPUdbIngestor::GPUdbIngestor </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/classgpudb_1_1GPUdb">gpudb::GPUdb</a> &</td>
            <td><span><span>db</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const <a href="/content/api/cpp/classgpudb_1_1Type">gpudb::Type</a> &</td>
            <td><span><span>record\_type</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>table\_name</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>insert\_options</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>size\_t</td>
            <td><span><span>batch\_size</span></span> )</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#aa288afe85fe2b49a3848c3581d869a33">◆ </a></span>GPUdbIngestor() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>gpudb::GPUdbIngestor::GPUdbIngestor </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/classgpudb_1_1GPUdb">gpudb::GPUdb</a> &</td>
            <td><span><span>db</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const <a href="/content/api/cpp/classgpudb_1_1Type">gpudb::Type</a> &</td>
            <td><span><span>record\_type</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>table\_name</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>size\_t</td>
            <td><span><span>batch\_size</span></span> )</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#afe6f44767a46cf7a4f29bfbd91020920">◆ </a></span>\~GPUdbIngestor()</h2>

    <div>
      <div>
        <table>
          <tr>
            <td>gpudb::GPUdbIngestor::\~GPUdbIngestor </td>
            <td>(</td>

            <td>
              <span>
                <span />
              </span>
            </td>

            <td>)</td>

            <td />
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2>Member Function Documentation</h2>
    <h2><span><a href="#ad1f6cebaf77d3673a1fe75e2bf9cac00">◆ </a></span>flush()</h2>

    <div>
      <div>
        <table>
          <tr>
            <td>void gpudb::GPUdbIngestor::flush </td>
            <td>(</td>

            <td>
              <span>
                <span />
              </span>
            </td>

            <td>)</td>

            <td />
          </tr>
        </table>
      </div>

      <div>
        <p>Ensures that all queued records are inserted into the database. </p>
        <p>If an error occurs while inserting the records from any queue, the recoreds will no longer be in that queue nor in the database; catch GPUdbInsertException\<T> to get the list of records that were being inserted if needed (for example, to retry). Other queues may also still contain unflushed records if this occurs. </p>
      </div>
    </div>

    <h2><span><a href="#a370a08d4a8f39869367c7cebbc0f075b">◆ </a></span>getCountInserted()</h2>

    <div>
      <div>
        <table>
          <tr>
            <td>
              <table>
                <tr>
                  <td>size\_t gpudb::GPUdbIngestor::getCountInserted </td>
                  <td>(</td>

                  <td>
                    <span>
                      <span />
                    </span>
                  </td>

                  <td>)</td>
                  <td> const</td>
                </tr>
              </table>
            </td>

            <td> <span><span>inline</span></span> </td>
          </tr>
        </table>
      </div>

      <div>
        <p>Returns the count of records inserted so far through this ingestor instance; An atomic operation. </p>
        <p>Definition at line <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdbIngestor.hpp#L79">79</a> of file <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdbIngestor.hpp">GPUdbIngestor.hpp</a>.</p>
      </div>
    </div>

    <h2><span><a href="#a91fcc89d4ae20c3da2c0ee0f26a1042f">◆ </a></span>getCountUpdated()</h2>

    <div>
      <div>
        <table>
          <tr>
            <td>
              <table>
                <tr>
                  <td>size\_t gpudb::GPUdbIngestor::getCountUpdated </td>
                  <td>(</td>

                  <td>
                    <span>
                      <span />
                    </span>
                  </td>

                  <td>)</td>
                  <td> const</td>
                </tr>
              </table>
            </td>

            <td> <span><span>inline</span></span> </td>
          </tr>
        </table>
      </div>

      <div>
        <p>Returns the count of records updated so far through this ingestor instance; An atomic operation. </p>
        <p>Definition at line <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdbIngestor.hpp#L85">85</a> of file <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdbIngestor.hpp">GPUdbIngestor.hpp</a>.</p>
      </div>
    </div>

    <h2><span><a href="#a26ec47ad5a83dbd4e885a4c670122fba">◆ </a></span>getErrors()</h2>

    <div>
      <div>
        <table>
          <tr>
            <td>std::vector\< <a href="/content/api/cpp/classgpudb_1_1GPUdbInsertionException">GPUdbInsertionException</a> > gpudb::GPUdbIngestor::getErrors </td>
            <td>(</td>

            <td>
              <span>
                <span />
              </span>
            </td>

            <td>)</td>

            <td />
          </tr>
        </table>
      </div>

      <div>
        <p>Returns the list of errors received since the last call to <a href="#a26ec47ad5a83dbd4e885a4c670122fba" title="Returns the list of errors received since the last call to getErrors(), and clears the list.">getErrors()</a>, and clears the list. </p>
      </div>
    </div>

    <h2><span><a href="#a3a91ea8cc2865f8d7530b0eec2f75bdd">◆ </a></span>getGPUdb()</h2>

    <div>
      <div>
        <table>
          <tr>
            <td>
              <table>
                <tr>
                  <td>const <a href="/content/api/cpp/classgpudb_1_1GPUdb">gpudb::GPUdb</a> & gpudb::GPUdbIngestor::getGPUdb </td>
                  <td>(</td>

                  <td>
                    <span>
                      <span />
                    </span>
                  </td>

                  <td>)</td>
                  <td> const</td>
                </tr>
              </table>
            </td>

            <td> <span><span>inline</span></span> </td>
          </tr>
        </table>
      </div>

      <div>
        <p>Returns the <a href="/content/api/cpp/classgpudb_1_1GPUdb">GPUdb</a> client handle that this class uses internally. </p>
        <p>Definition at line <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdbIngestor.hpp#L68">68</a> of file <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdbIngestor.hpp">GPUdbIngestor.hpp</a>.</p>
      </div>
    </div>

    <h2><span><a href="#a1b25d43c9433a653fd418d46ce9851d5">◆ </a></span>getOptions()</h2>

    <div>
      <div>
        <table>
          <tr>
            <td>
              <table>
                <tr>
                  <td>const std::map\< std::string, std::string > & gpudb::GPUdbIngestor::getOptions </td>
                  <td>(</td>

                  <td>
                    <span>
                      <span />
                    </span>
                  </td>

                  <td>)</td>
                  <td> const</td>
                </tr>
              </table>
            </td>

            <td> <span><span>inline</span></span> </td>
          </tr>
        </table>
      </div>

      <div>
        <p>Returns the insertion options the ingestor uses. </p>
        <p>Definition at line <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdbIngestor.hpp#L73">73</a> of file <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdbIngestor.hpp">GPUdbIngestor.hpp</a>.</p>
      </div>
    </div>

    <h2><span><a href="#afa4c701fcea30064daf742ae18f8c60b">◆ </a></span>getTableName()</h2>

    <div>
      <div>
        <table>
          <tr>
            <td>
              <table>
                <tr>
                  <td>const std::string & gpudb::GPUdbIngestor::getTableName </td>
                  <td>(</td>

                  <td>
                    <span>
                      <span />
                    </span>
                  </td>

                  <td>)</td>
                  <td> const</td>
                </tr>
              </table>
            </td>

            <td> <span><span>inline</span></span> </td>
          </tr>
        </table>
      </div>

      <div>
        <p>Returns the name of the table on which this class operates. </p>
        <p>Definition at line <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdbIngestor.hpp#L63">63</a> of file <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdbIngestor.hpp">GPUdbIngestor.hpp</a>.</p>
      </div>
    </div>

    <h2><span><a href="#aecff11bac1f1a19f5ee3e35a19220ce9">◆ </a></span>getWarnings()</h2>

    <div>
      <div>
        <table>
          <tr>
            <td>std::vector\< <a href="/content/api/cpp/classgpudb_1_1GPUdbInsertionException">GPUdbInsertionException</a> > gpudb::GPUdbIngestor::getWarnings </td>
            <td>(</td>

            <td>
              <span>
                <span />
              </span>
            </td>

            <td>)</td>

            <td />
          </tr>
        </table>
      </div>

      <div>
        <p>Returns the list of warnings received since the last call to <a href="#aecff11bac1f1a19f5ee3e35a19220ce9" title="Returns the list of warnings received since the last call to getWarnings(), and clears the list.">getWarnings()</a>, and clears the list. </p>
      </div>
    </div>

    <h2><span><a href="#a4d74afe2ab47ae2b18a27a2d58d8f611">◆ </a></span>insert() <span>\[1/2]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>void gpudb::GPUdbIngestor::insert </td>
            <td>(</td>
            <td><a href="/content/api/cpp/classgpudb_1_1GenericRecord">gpudb::GenericRecord</a></td>
            <td><span><span>record</span></span></td>
            <td>)</td>

            <td />
          </tr>
        </table>
      </div>

      <div>
        <p>Queues a record for insertion into <a href="/content/api/cpp/classgpudb_1_1GPUdb">GPUdb</a>. </p>
        <p>If the queue reaches the configured batch size, all records in the queue will be inserted into Kinetica before the method returns. If an error occurs while inserting the records, the records will no longer be in the queue nor in Kinetica; catch InsertException\<T> to get the list of records that were being inserted if needed (for example, to retry).</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>record</td>
                <td>The record to insert.</td>
              </tr>
            </table>
          </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#a4c3e0625dfa8e8cb47a1e1b2001b4358">◆ </a></span>insert() <span>\[2/2]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>void gpudb::GPUdbIngestor::insert </td>
            <td>(</td>
            <td>std::vector\< <a href="/content/api/cpp/classgpudb_1_1GenericRecord">gpudb::GenericRecord</a> ></td>
            <td><span><span>records</span></span></td>
            <td>)</td>

            <td />
          </tr>
        </table>
      </div>

      <div>
        <p>Queues a list of records for insertion into Kientica. </p>
        <p>If any queue reaches the configured batch size, all records in the queue will be inserted into Kinetica before the method returns. If an error occurs while inserting the records, the records will no longer be in the queue nor in Kinetica; catch InsertException\<T> to get the list of records that were being inserted if needed (for example, to retry).</p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>records</td>
                <td>The records to insert.</td>
              </tr>
            </table>
          </div>
        </div>
      </div>
    </div>

    <hr />

    The documentation for this class was generated from the following file:

    <ul>
      <li>gpudb/<a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdbIngestor.hpp">GPUdbIngestor.hpp</a></li>
    </ul>
  </div>
</div>


# gpudb::GPUdbInsertionException
Source: https://docs.kinetica.com/content/api/cpp/classgpudb_1_1GPUdbInsertionException

gpudb::GPUdbInsertionException — Kinetica C++ API

<div>
  <div>
    <p><code>#include \<<a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdbException.hpp">gpudb/GPUdbException.hpp</a>></code></p>

    <table>
      <tr>
        <td>
          <h2> Public Member Functions</h2>
        </td>
      </tr>

      <tr>
        <td> </td>
        <td><a href="#a74766798789d470205b62b5262aa5680">GPUdbInsertionException</a> (const std::string \&messageParam)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td> </td>
        <td><a href="#a2881061e5eb24030de850abc722cc5ea">GPUdbInsertionException</a> (const std::string \&url\_, const std::vector\< <a href="/content/api/cpp/classgpudb_1_1GenericRecord">gpudb::GenericRecord</a> > \&records\_, const std::string \&message\_)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>virtual const char \* </td>
        <td><a href="#ae0d64df3bc540838a2b52c01771a4b8a">what</a> () const throw ()</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td> </td>
        <td><a href="#ae212190d7cdab49ac3e76b11c2483546">\~GPUdbInsertionException</a> () throw ()</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>void </td>
        <td><a href="#adeb2ed10f12fe4ca3eb40e609dc080df">append\_records</a> (std::vector\< <a href="/content/api/cpp/classgpudb_1_1GenericRecord">gpudb::GenericRecord</a> >::iterator begin, std::vector\< <a href="/content/api/cpp/classgpudb_1_1GenericRecord">gpudb::GenericRecord</a> >::iterator end)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>std::vector\< <a href="/content/api/cpp/classgpudb_1_1GenericRecord">gpudb::GenericRecord</a> > </td>
        <td><a href="#a0721793ca34d2389ca60c27be03b3ded">getRecords</a> () const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td> Public Member Functions inherited from <a href="/content/api/cpp/classgpudb_1_1GPUdbException">gpudb::GPUdbException</a></td>
      </tr>

      <tr>
        <td> </td>
        <td><a href="/content/api/cpp/classgpudb_1_1GPUdbException#a0447915d6b0f64ff56b3eda95da20274">GPUdbException</a> (const std::string \&messageParam)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td> </td>
        <td><a href="/content/api/cpp/classgpudb_1_1GPUdbException#acbcf261d2b250c57227d6c69228d969b">\~GPUdbException</a> () throw ()</td>
      </tr>

      <tr>
        <td> </td>
      </tr>
    </table>

    <table>
      <tr>
        <td>
          <h2> Additional Inherited Members</h2>
        </td>
      </tr>

      <tr>
        <td> Protected Attributes inherited from <a href="/content/api/cpp/classgpudb_1_1GPUdbException">gpudb::GPUdbException</a></td>
      </tr>

      <tr>
        <td>std::string </td>
        <td><a href="/content/api/cpp/classgpudb_1_1GPUdbException#aa67f34470b4c25da205658eb53bd9295">message</a></td>
      </tr>

      <tr>
        <td> </td>
      </tr>
    </table>

    <h2>Detailed Description</h2>

    <div>
      <p>Definition at line <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdbException.hpp#L32">32</a> of file <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdbException.hpp">GPUdbException.hpp</a>.</p>
    </div>

    <h2>Constructor & Destructor Documentation</h2>
    <h2><span><a href="#a74766798789d470205b62b5262aa5680">◆ </a></span>GPUdbInsertionException() <span>\[1/2]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>
              <table>
                <tr>
                  <td>gpudb::GPUdbInsertionException::GPUdbInsertionException </td>
                  <td>(</td>
                  <td>const std::string &</td>
                  <td><span><span>messageParam</span></span></td>
                  <td>)</td>

                  <td />
                </tr>
              </table>
            </td>

            <td> <span><span>inline</span></span> </td>
          </tr>
        </table>
      </div>

      <div>
        <p>Definition at line <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdbException.hpp#L35">35</a> of file <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdbException.hpp">GPUdbException.hpp</a>.</p>
      </div>
    </div>

    <h2><span><a href="#a2881061e5eb24030de850abc722cc5ea">◆ </a></span>GPUdbInsertionException() <span>\[2/2]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>gpudb::GPUdbInsertionException::GPUdbInsertionException </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>url\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< <a href="/content/api/cpp/classgpudb_1_1GenericRecord">gpudb::GenericRecord</a> > &</td>
            <td><span><span>records\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>message\_</span></span> )</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#ae212190d7cdab49ac3e76b11c2483546">◆ </a></span>\~GPUdbInsertionException()</h2>

    <div>
      <div>
        <table>
          <tr>
            <td>
              <table>
                <tr>
                  <td>gpudb::GPUdbInsertionException::\~GPUdbInsertionException </td>
                  <td>(</td>

                  <td>
                    <span>
                      <span />
                    </span>
                  </td>

                  <td>)</td>

                  <td />
                </tr>

                <tr>
                  <td>throw </td>
                  <td>(</td>
                  <td> )</td>

                  <td />

                  <td />

                  <td />
                </tr>
              </table>
            </td>

            <td> <span><span>inline</span></span> </td>
          </tr>
        </table>
      </div>

      <div>
        <p>Definition at line <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdbException.hpp#L43">43</a> of file <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdbException.hpp">GPUdbException.hpp</a>.</p>
      </div>
    </div>

    <h2>Member Function Documentation</h2>
    <h2><span><a href="#adeb2ed10f12fe4ca3eb40e609dc080df">◆ </a></span>append\_records()</h2>

    <div>
      <div>
        <table>
          <tr>
            <td>void gpudb::GPUdbInsertionException::append\_records </td>
            <td>(</td>
            <td>std::vector\< <a href="/content/api/cpp/classgpudb_1_1GenericRecord">gpudb::GenericRecord</a> >::iterator</td>
            <td><span><span>begin</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>std::vector\< <a href="/content/api/cpp/classgpudb_1_1GenericRecord">gpudb::GenericRecord</a> >::iterator</td>
            <td><span><span>end</span></span> )</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#a0721793ca34d2389ca60c27be03b3ded">◆ </a></span>getRecords()</h2>

    <div>
      <div>
        <table>
          <tr>
            <td>
              <table>
                <tr>
                  <td>std::vector\< <a href="/content/api/cpp/classgpudb_1_1GenericRecord">gpudb::GenericRecord</a> > gpudb::GPUdbInsertionException::getRecords </td>
                  <td>(</td>

                  <td>
                    <span>
                      <span />
                    </span>
                  </td>

                  <td>)</td>
                  <td> const</td>
                </tr>
              </table>
            </td>

            <td> <span><span>inline</span></span> </td>
          </tr>
        </table>
      </div>

      <div>
        <p>Definition at line <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdbException.hpp#L49">49</a> of file <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdbException.hpp">GPUdbException.hpp</a>.</p>
      </div>
    </div>

    <h2><span><a href="#ae0d64df3bc540838a2b52c01771a4b8a">◆ </a></span>what()</h2>

    <div>
      <div>
        <table>
          <tr>
            <td>
              <table>
                <tr>
                  <td>virtual const char \* gpudb::GPUdbInsertionException::what </td>
                  <td>(</td>

                  <td>
                    <span>
                      <span />
                    </span>
                  </td>

                  <td>)</td>
                  <td> const</td>
                </tr>

                <tr>
                  <td>throw </td>
                  <td>(</td>
                  <td> )</td>

                  <td />

                  <td />

                  <td />
                </tr>
              </table>
            </td>

            <td> <span><span>inline</span><span>virtual</span></span> </td>
          </tr>
        </table>
      </div>

      <div>
        <p>Reimplemented from <a href="/content/api/cpp/classgpudb_1_1GPUdbException#a4cef6346f0006ae281c79673b5111029">gpudb::GPUdbException</a>.</p>
        <p>Definition at line <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdbException.hpp#L41">41</a> of file <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdbException.hpp">GPUdbException.hpp</a>.</p>
      </div>
    </div>

    <hr />

    The documentation for this class was generated from the following file:

    <ul>
      <li>gpudb/<a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdbException.hpp">GPUdbException.hpp</a></li>
    </ul>
  </div>
</div>


# gpudb::GPUdbSubmitException
Source: https://docs.kinetica.com/content/api/cpp/classgpudb_1_1GPUdbSubmitException

gpudb::GPUdbSubmitException — Kinetica C++ API

<div>
  <div>
    <p><code>#include \<<a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdbException.hpp">gpudb/GPUdbException.hpp</a>></code></p>

    <table>
      <tr>
        <td>
          <h2> Public Member Functions</h2>
        </td>
      </tr>

      <tr>
        <td> </td>
        <td><a href="#a7b70a97cc8a335866b121a8e2bf8a7e0">GPUdbSubmitException</a> (const std::string \&messageParam)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td> </td>
        <td><a href="#afcc2e59c457a31cfc9a26812d1e84d45">GPUdbSubmitException</a> (<a href="/content/api/cpp/classgpudb_1_1HttpUrl">HttpUrl</a> url\_, const std::vector\< uint8\_t > \&request\_, const std::string \&message\_)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>virtual const char \* </td>
        <td><a href="#a1941413869972ca26d948662322a42d2">what</a> () const throw ()</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td> </td>
        <td><a href="#ab1538a3c920d98081d2c41a5e12113c3">\~GPUdbSubmitException</a> () throw ()</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td> Public Member Functions inherited from <a href="/content/api/cpp/classgpudb_1_1GPUdbException">gpudb::GPUdbException</a></td>
      </tr>

      <tr>
        <td> </td>
        <td><a href="/content/api/cpp/classgpudb_1_1GPUdbException#a0447915d6b0f64ff56b3eda95da20274">GPUdbException</a> (const std::string \&messageParam)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td> </td>
        <td><a href="/content/api/cpp/classgpudb_1_1GPUdbException#acbcf261d2b250c57227d6c69228d969b">\~GPUdbException</a> () throw ()</td>
      </tr>

      <tr>
        <td> </td>
      </tr>
    </table>

    <table>
      <tr>
        <td>
          <h2> Additional Inherited Members</h2>
        </td>
      </tr>

      <tr>
        <td> Protected Attributes inherited from <a href="/content/api/cpp/classgpudb_1_1GPUdbException">gpudb::GPUdbException</a></td>
      </tr>

      <tr>
        <td>std::string </td>
        <td><a href="/content/api/cpp/classgpudb_1_1GPUdbException#aa67f34470b4c25da205658eb53bd9295">message</a></td>
      </tr>

      <tr>
        <td> </td>
      </tr>
    </table>

    <h2>Detailed Description</h2>

    <div>
      <p>Definition at line <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdbException.hpp#L86">86</a> of file <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdbException.hpp">GPUdbException.hpp</a>.</p>
    </div>

    <h2>Constructor & Destructor Documentation</h2>
    <h2><span><a href="#a7b70a97cc8a335866b121a8e2bf8a7e0">◆ </a></span>GPUdbSubmitException() <span>\[1/2]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>
              <table>
                <tr>
                  <td>gpudb::GPUdbSubmitException::GPUdbSubmitException </td>
                  <td>(</td>
                  <td>const std::string &</td>
                  <td><span><span>messageParam</span></span></td>
                  <td>)</td>

                  <td />
                </tr>
              </table>
            </td>

            <td> <span><span>inline</span></span> </td>
          </tr>
        </table>
      </div>

      <div>
        <p>Definition at line <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdbException.hpp#L89">89</a> of file <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdbException.hpp">GPUdbException.hpp</a>.</p>
      </div>
    </div>

    <h2><span><a href="#afcc2e59c457a31cfc9a26812d1e84d45">◆ </a></span>GPUdbSubmitException() <span>\[2/2]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>gpudb::GPUdbSubmitException::GPUdbSubmitException </td>
            <td>(</td>
            <td><a href="/content/api/cpp/classgpudb_1_1HttpUrl">HttpUrl</a></td>
            <td><span><span>url\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< uint8\_t > &</td>
            <td><span><span>request\_</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>message\_</span></span> )</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#ab1538a3c920d98081d2c41a5e12113c3">◆ </a></span>\~GPUdbSubmitException()</h2>

    <div>
      <div>
        <table>
          <tr>
            <td>
              <table>
                <tr>
                  <td>gpudb::GPUdbSubmitException::\~GPUdbSubmitException </td>
                  <td>(</td>

                  <td>
                    <span>
                      <span />
                    </span>
                  </td>

                  <td>)</td>

                  <td />
                </tr>

                <tr>
                  <td>throw </td>
                  <td>(</td>
                  <td> )</td>

                  <td />

                  <td />

                  <td />
                </tr>
              </table>
            </td>

            <td> <span><span>inline</span></span> </td>
          </tr>
        </table>
      </div>

      <div>
        <p>Definition at line <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdbException.hpp#L96">96</a> of file <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdbException.hpp">GPUdbException.hpp</a>.</p>
      </div>
    </div>

    <h2>Member Function Documentation</h2>
    <h2><span><a href="#a1941413869972ca26d948662322a42d2">◆ </a></span>what()</h2>

    <div>
      <div>
        <table>
          <tr>
            <td>
              <table>
                <tr>
                  <td>virtual const char \* gpudb::GPUdbSubmitException::what </td>
                  <td>(</td>

                  <td>
                    <span>
                      <span />
                    </span>
                  </td>

                  <td>)</td>
                  <td> const</td>
                </tr>

                <tr>
                  <td>throw </td>
                  <td>(</td>
                  <td> )</td>

                  <td />

                  <td />

                  <td />
                </tr>
              </table>
            </td>

            <td> <span><span>inline</span><span>virtual</span></span> </td>
          </tr>
        </table>
      </div>

      <div>
        <p>Reimplemented from <a href="/content/api/cpp/classgpudb_1_1GPUdbException#a4cef6346f0006ae281c79673b5111029">gpudb::GPUdbException</a>.</p>
        <p>Definition at line <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdbException.hpp#L94">94</a> of file <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdbException.hpp">GPUdbException.hpp</a>.</p>
      </div>
    </div>

    <hr />

    The documentation for this class was generated from the following file:

    <ul>
      <li>gpudb/<a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdbException.hpp">GPUdbException.hpp</a></li>
    </ul>
  </div>
</div>


# gpudb::GPUdb::Options
Source: https://docs.kinetica.com/content/api/cpp/classgpudb_1_1GPUdb_1_1Options

gpudb::GPUdb::Options — Kinetica C++ API

<div>
  <div>
    <p><code>#include \<<a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">gpudb/GPUdb.hpp</a>></code></p>

    <table>
      <tr>
        <td>
          <h2> Public Member Functions</h2>
        </td>
      </tr>

      <tr>
        <td> </td>
        <td><a href="#aec7da43bf463ee00421a68badbac8509">Options</a> ()</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>boost::asio::ssl::context \* </td>
        <td><a href="#aa43b81f5e747c44adb8f47d3a9736591">getSslContext</a> () const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>bool </td>
        <td><a href="#ada9454873ed3c34f9c2f880bab6a2e15">getBypassSslCertCheck</a> () const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>std::string </td>
        <td><a href="#acdca8d26a2c2f848f66e9879f0e17e1f">getUsername</a> () const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>std::string </td>
        <td><a href="#a4a5eca2e06db7996a244703ab598c703">getPassword</a> () const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>std::string </td>
        <td><a href="#a73e693397b80118116ed823f37afde85">getOauthToken</a> () const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>std::string </td>
        <td><a href="#a97c433b3de823ee62e0c461cf305ecab">getPrimaryUrl</a> () const</td>
      </tr>

      <tr>
        <td> </td>
        <td>Return the URL of the primary cluster, if any (empty string delineates that none was set) <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>bool </td>
        <td><a href="#a60fdda993b39ccc85da0cd3496b345a0">getUseSnappy</a> () const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>size\_t </td>
        <td><a href="#ae944ae4bf635491851416e71a0981ec8">getThreadCount</a> () const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>avro::ExecutorPtr </td>
        <td><a href="#ab1da78028d115f9fd201f51afb5bb82e">getExecutor</a> () const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>std::map\< std::string, std::string > & </td>
        <td><a href="#afb80d4e637b554e634b67c66c6087d27">getHttpHeaders</a> ()</td>
      </tr>

      <tr>
        <td> </td>
        <td>Get the HTTP headers (will include the high-availability synchronicity override header) <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>const std::map\< std::string, std::string > & </td>
        <td><a href="#a8c3f3141497c4c7ee0dcb6d288bca16d">getHttpHeaders</a> () const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>size\_t </td>
        <td><a href="#a7a9f043ba3b45d862c2e03467b98f630">getTimeout</a> () const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>uint16\_t </td>
        <td><a href="#a2fa6a188ad0c2a38faf3fd3732f1cf96">getHostManagerPort</a> () const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>bool </td>
        <td><a href="#a84026c883c3486316db3062e9d9ec99e">getDisableFailover</a> () const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>bool </td>
        <td><a href="#af865dc3e04c12f92cf6bdaba1c109aac">getDisableAutoDiscovery</a> () const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>std::string </td>
        <td><a href="#a8c0ab7d6bbc64f089a0bd6bf69bb149b">getClientName</a> () const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>std::string </td>
        <td><a href="#ade5ef9730091477d18f4437e3663f89c">getClientVersion</a> () const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/classgpudb_1_1GPUdb_1_1Options">Options</a> & </td>
        <td><a href="#a01fab9f4a265c405726f2bdc27bcea65">setSslContext</a> (boost::asio::ssl::context \*value)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/classgpudb_1_1GPUdb_1_1Options">Options</a> & </td>
        <td><a href="#ab6721b4ced53badddf9483ed87b2aa6e">setBypassSslCertCheck</a> (const bool value)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/classgpudb_1_1GPUdb_1_1Options">Options</a> & </td>
        <td><a href="#acef4845c6c22a6c53246bc9ba6d0b10a">setUsername</a> (const std::string \&value)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/classgpudb_1_1GPUdb_1_1Options">Options</a> & </td>
        <td><a href="#a800fa4ced0b78caa17031928ae052d7a">setPassword</a> (const std::string \&value)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/classgpudb_1_1GPUdb_1_1Options">Options</a> & </td>
        <td><a href="#ae77f7d8ff054819e0bd55724054f0059">setOauthToken</a> (const std::string \&value)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/classgpudb_1_1GPUdb_1_1Options">Options</a> & </td>
        <td><a href="#a61f9312df54967e551616d49f79b7b01">setPrimaryUrl</a> (const std::string \&value)</td>
      </tr>

      <tr>
        <td> </td>
        <td>Set the URL for the primary cluster. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/classgpudb_1_1GPUdb_1_1Options">Options</a> & </td>
        <td><a href="#a079edb0d6a475544502cc8adfd73eb00">setUseSnappy</a> (const bool value)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/classgpudb_1_1GPUdb_1_1Options">Options</a> & </td>
        <td><a href="#aa8a193c0d8beb355cb61f8389d4f6a93">setThreadCount</a> (const size\_t value)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/classgpudb_1_1GPUdb_1_1Options">Options</a> & </td>
        <td><a href="#a5b5788524562c3888fe269cc189e2849">setExecutor</a> (const avro::ExecutorPtr value)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/classgpudb_1_1GPUdb_1_1Options">Options</a> & </td>
        <td><a href="#a82712135c18d5d2b2cdc70f1d44f8c2f">setHttpHeaders</a> (const std::map\< std::string, std::string > \&value)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/classgpudb_1_1GPUdb_1_1Options">Options</a> & </td>
        <td><a href="#a2af323b0739b31c4440e86d6a91dc8e7">addHttpHeader</a> (const std::string \&header, const std::string \&value)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/classgpudb_1_1GPUdb_1_1Options">Options</a> & </td>
        <td><a href="#a8c29dc1411ca0864727ba8df8a827e99">setTimeout</a> (const size\_t value)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/classgpudb_1_1GPUdb_1_1Options">Options</a> & </td>
        <td><a href="#a49a1f61d2ac45a928d901022ce157b76">setHostManagerPort</a> (const uint16\_t value)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/classgpudb_1_1GPUdb_1_1Options">Options</a> & </td>
        <td><a href="#a75f730126bbb4c0900bfd7ffcb43a0c2">setDisableFailover</a> (const bool value)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/classgpudb_1_1GPUdb_1_1Options">Options</a> & </td>
        <td><a href="#a63e0b10ee7a0733396b30a5ad0031c46">setDisableAutoDiscovery</a> (const bool value)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/classgpudb_1_1GPUdb_1_1Options">Options</a> & </td>
        <td><a href="#ae7eb5bd67596118a3988cfbde432b9ed">setClientName</a> (const std::string \&value)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td><a href="/content/api/cpp/classgpudb_1_1GPUdb_1_1Options">Options</a> & </td>
        <td><a href="#a3d0533a9d68b9d69ba4c48211e8db98c">setClientVersion</a> (const std::string \&value)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>
    </table>

    <h2>Detailed Description</h2>

    <div>
      <p>Definition at line <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp#L63">63</a> of file <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">GPUdb.hpp</a>.</p>
    </div>

    <h2>Constructor & Destructor Documentation</h2>
    <h2><span><a href="#aec7da43bf463ee00421a68badbac8509">◆ </a></span>Options()</h2>

    <div>
      <div>
        <table>
          <tr>
            <td>gpudb::GPUdb::Options::Options </td>
            <td>(</td>

            <td>
              <span>
                <span />
              </span>
            </td>

            <td>)</td>

            <td />
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2>Member Function Documentation</h2>
    <h2><span><a href="#a2af323b0739b31c4440e86d6a91dc8e7">◆ </a></span>addHttpHeader()</h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/classgpudb_1_1GPUdb_1_1Options">Options</a> & gpudb::GPUdb::Options::addHttpHeader </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>header</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::string &</td>
            <td><span><span>value</span></span> )</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#ada9454873ed3c34f9c2f880bab6a2e15">◆ </a></span>getBypassSslCertCheck()</h2>

    <div>
      <div>
        <table>
          <tr>
            <td>bool gpudb::GPUdb::Options::getBypassSslCertCheck </td>
            <td>(</td>

            <td>
              <span>
                <span />
              </span>
            </td>

            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#a8c0ab7d6bbc64f089a0bd6bf69bb149b">◆ </a></span>getClientName()</h2>

    <div>
      <div>
        <table>
          <tr>
            <td>std::string gpudb::GPUdb::Options::getClientName </td>
            <td>(</td>

            <td>
              <span>
                <span />
              </span>
            </td>

            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#ade5ef9730091477d18f4437e3663f89c">◆ </a></span>getClientVersion()</h2>

    <div>
      <div>
        <table>
          <tr>
            <td>std::string gpudb::GPUdb::Options::getClientVersion </td>
            <td>(</td>

            <td>
              <span>
                <span />
              </span>
            </td>

            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#af865dc3e04c12f92cf6bdaba1c109aac">◆ </a></span>getDisableAutoDiscovery()</h2>

    <div>
      <div>
        <table>
          <tr>
            <td>bool gpudb::GPUdb::Options::getDisableAutoDiscovery </td>
            <td>(</td>

            <td>
              <span>
                <span />
              </span>
            </td>

            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#a84026c883c3486316db3062e9d9ec99e">◆ </a></span>getDisableFailover()</h2>

    <div>
      <div>
        <table>
          <tr>
            <td>bool gpudb::GPUdb::Options::getDisableFailover </td>
            <td>(</td>

            <td>
              <span>
                <span />
              </span>
            </td>

            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#ab1da78028d115f9fd201f51afb5bb82e">◆ </a></span>getExecutor()</h2>

    <div>
      <div>
        <table>
          <tr>
            <td>avro::ExecutorPtr gpudb::GPUdb::Options::getExecutor </td>
            <td>(</td>

            <td>
              <span>
                <span />
              </span>
            </td>

            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#a2fa6a188ad0c2a38faf3fd3732f1cf96">◆ </a></span>getHostManagerPort()</h2>

    <div>
      <div>
        <table>
          <tr>
            <td>uint16\_t gpudb::GPUdb::Options::getHostManagerPort </td>
            <td>(</td>

            <td>
              <span>
                <span />
              </span>
            </td>

            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#afb80d4e637b554e634b67c66c6087d27">◆ </a></span>getHttpHeaders() <span>\[1/2]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>std::map\< std::string, std::string > & gpudb::GPUdb::Options::getHttpHeaders </td>
            <td>(</td>

            <td>
              <span>
                <span />
              </span>
            </td>

            <td>)</td>

            <td />
          </tr>
        </table>
      </div>

      <div>
        <p>Get the HTTP headers (will include the high-availability synchronicity override header) </p>
      </div>
    </div>

    <h2><span><a href="#a8c3f3141497c4c7ee0dcb6d288bca16d">◆ </a></span>getHttpHeaders() <span>\[2/2]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>const std::map\< std::string, std::string > & gpudb::GPUdb::Options::getHttpHeaders </td>
            <td>(</td>

            <td>
              <span>
                <span />
              </span>
            </td>

            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#a73e693397b80118116ed823f37afde85">◆ </a></span>getOauthToken()</h2>

    <div>
      <div>
        <table>
          <tr>
            <td>std::string gpudb::GPUdb::Options::getOauthToken </td>
            <td>(</td>

            <td>
              <span>
                <span />
              </span>
            </td>

            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#a4a5eca2e06db7996a244703ab598c703">◆ </a></span>getPassword()</h2>

    <div>
      <div>
        <table>
          <tr>
            <td>std::string gpudb::GPUdb::Options::getPassword </td>
            <td>(</td>

            <td>
              <span>
                <span />
              </span>
            </td>

            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#a97c433b3de823ee62e0c461cf305ecab">◆ </a></span>getPrimaryUrl()</h2>

    <div>
      <div>
        <table>
          <tr>
            <td>std::string gpudb::GPUdb::Options::getPrimaryUrl </td>
            <td>(</td>

            <td>
              <span>
                <span />
              </span>
            </td>

            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div>
        <p>Return the URL of the primary cluster, if any (empty string delineates that none was set) </p>
      </div>
    </div>

    <h2><span><a href="#aa43b81f5e747c44adb8f47d3a9736591">◆ </a></span>getSslContext()</h2>

    <div>
      <div>
        <table>
          <tr>
            <td>boost::asio::ssl::context \* gpudb::GPUdb::Options::getSslContext </td>
            <td>(</td>

            <td>
              <span>
                <span />
              </span>
            </td>

            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#ae944ae4bf635491851416e71a0981ec8">◆ </a></span>getThreadCount()</h2>

    <div>
      <div>
        <table>
          <tr>
            <td>size\_t gpudb::GPUdb::Options::getThreadCount </td>
            <td>(</td>

            <td>
              <span>
                <span />
              </span>
            </td>

            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#a7a9f043ba3b45d862c2e03467b98f630">◆ </a></span>getTimeout()</h2>

    <div>
      <div>
        <table>
          <tr>
            <td>size\_t gpudb::GPUdb::Options::getTimeout </td>
            <td>(</td>

            <td>
              <span>
                <span />
              </span>
            </td>

            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#acdca8d26a2c2f848f66e9879f0e17e1f">◆ </a></span>getUsername()</h2>

    <div>
      <div>
        <table>
          <tr>
            <td>std::string gpudb::GPUdb::Options::getUsername </td>
            <td>(</td>

            <td>
              <span>
                <span />
              </span>
            </td>

            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#a60fdda993b39ccc85da0cd3496b345a0">◆ </a></span>getUseSnappy()</h2>

    <div>
      <div>
        <table>
          <tr>
            <td>bool gpudb::GPUdb::Options::getUseSnappy </td>
            <td>(</td>

            <td>
              <span>
                <span />
              </span>
            </td>

            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#ab6721b4ced53badddf9483ed87b2aa6e">◆ </a></span>setBypassSslCertCheck()</h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/classgpudb_1_1GPUdb_1_1Options">Options</a> & gpudb::GPUdb::Options::setBypassSslCertCheck </td>
            <td>(</td>
            <td>const bool</td>
            <td><span><span>value</span></span></td>
            <td>)</td>

            <td />
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#ae7eb5bd67596118a3988cfbde432b9ed">◆ </a></span>setClientName()</h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/classgpudb_1_1GPUdb_1_1Options">Options</a> & gpudb::GPUdb::Options::setClientName </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>value</span></span></td>
            <td>)</td>

            <td />
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#a3d0533a9d68b9d69ba4c48211e8db98c">◆ </a></span>setClientVersion()</h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/classgpudb_1_1GPUdb_1_1Options">Options</a> & gpudb::GPUdb::Options::setClientVersion </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>value</span></span></td>
            <td>)</td>

            <td />
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#a63e0b10ee7a0733396b30a5ad0031c46">◆ </a></span>setDisableAutoDiscovery()</h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/classgpudb_1_1GPUdb_1_1Options">Options</a> & gpudb::GPUdb::Options::setDisableAutoDiscovery </td>
            <td>(</td>
            <td>const bool</td>
            <td><span><span>value</span></span></td>
            <td>)</td>

            <td />
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#a75f730126bbb4c0900bfd7ffcb43a0c2">◆ </a></span>setDisableFailover()</h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/classgpudb_1_1GPUdb_1_1Options">Options</a> & gpudb::GPUdb::Options::setDisableFailover </td>
            <td>(</td>
            <td>const bool</td>
            <td><span><span>value</span></span></td>
            <td>)</td>

            <td />
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#a5b5788524562c3888fe269cc189e2849">◆ </a></span>setExecutor()</h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/classgpudb_1_1GPUdb_1_1Options">Options</a> & gpudb::GPUdb::Options::setExecutor </td>
            <td>(</td>
            <td>const avro::ExecutorPtr</td>
            <td><span><span>value</span></span></td>
            <td>)</td>

            <td />
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#a49a1f61d2ac45a928d901022ce157b76">◆ </a></span>setHostManagerPort()</h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/classgpudb_1_1GPUdb_1_1Options">Options</a> & gpudb::GPUdb::Options::setHostManagerPort </td>
            <td>(</td>
            <td>const uint16\_t</td>
            <td><span><span>value</span></span></td>
            <td>)</td>

            <td />
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#a82712135c18d5d2b2cdc70f1d44f8c2f">◆ </a></span>setHttpHeaders()</h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/classgpudb_1_1GPUdb_1_1Options">Options</a> & gpudb::GPUdb::Options::setHttpHeaders </td>
            <td>(</td>
            <td>const std::map\< std::string, std::string > &</td>
            <td><span><span>value</span></span></td>
            <td>)</td>

            <td />
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#ae77f7d8ff054819e0bd55724054f0059">◆ </a></span>setOauthToken()</h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/classgpudb_1_1GPUdb_1_1Options">Options</a> & gpudb::GPUdb::Options::setOauthToken </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>value</span></span></td>
            <td>)</td>

            <td />
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#a800fa4ced0b78caa17031928ae052d7a">◆ </a></span>setPassword()</h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/classgpudb_1_1GPUdb_1_1Options">Options</a> & gpudb::GPUdb::Options::setPassword </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>value</span></span></td>
            <td>)</td>

            <td />
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#a61f9312df54967e551616d49f79b7b01">◆ </a></span>setPrimaryUrl()</h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/classgpudb_1_1GPUdb_1_1Options">Options</a> & gpudb::GPUdb::Options::setPrimaryUrl </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>value</span></span></td>
            <td>)</td>

            <td />
          </tr>
        </table>
      </div>

      <div>
        <p>Set the URL for the primary cluster. </p>
      </div>
    </div>

    <h2><span><a href="#a01fab9f4a265c405726f2bdc27bcea65">◆ </a></span>setSslContext()</h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/classgpudb_1_1GPUdb_1_1Options">Options</a> & gpudb::GPUdb::Options::setSslContext </td>
            <td>(</td>
            <td>boost::asio::ssl::context \*</td>
            <td><span><span>value</span></span></td>
            <td>)</td>

            <td />
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#aa8a193c0d8beb355cb61f8389d4f6a93">◆ </a></span>setThreadCount()</h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/classgpudb_1_1GPUdb_1_1Options">Options</a> & gpudb::GPUdb::Options::setThreadCount </td>
            <td>(</td>
            <td>const size\_t</td>
            <td><span><span>value</span></span></td>
            <td>)</td>

            <td />
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#a8c29dc1411ca0864727ba8df8a827e99">◆ </a></span>setTimeout()</h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/classgpudb_1_1GPUdb_1_1Options">Options</a> & gpudb::GPUdb::Options::setTimeout </td>
            <td>(</td>
            <td>const size\_t</td>
            <td><span><span>value</span></span></td>
            <td>)</td>

            <td />
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#acef4845c6c22a6c53246bc9ba6d0b10a">◆ </a></span>setUsername()</h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/classgpudb_1_1GPUdb_1_1Options">Options</a> & gpudb::GPUdb::Options::setUsername </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>value</span></span></td>
            <td>)</td>

            <td />
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#a079edb0d6a475544502cc8adfd73eb00">◆ </a></span>setUseSnappy()</h2>

    <div>
      <div>
        <table>
          <tr>
            <td><a href="/content/api/cpp/classgpudb_1_1GPUdb_1_1Options">Options</a> & gpudb::GPUdb::Options::setUseSnappy </td>
            <td>(</td>
            <td>const bool</td>
            <td><span><span>value</span></span></td>
            <td>)</td>

            <td />
          </tr>
        </table>
      </div>

      <div />
    </div>

    <hr />

    The documentation for this class was generated from the following file:

    <ul>
      <li>gpudb/<a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GPUdb.hpp">GPUdb.hpp</a></li>
    </ul>
  </div>
</div>


# gpudb::GenericRecord
Source: https://docs.kinetica.com/content/api/cpp/classgpudb_1_1GenericRecord

gpudb::GenericRecord — Kinetica C++ API

<div>
  <div>
    <p><code>#include \<<a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GenericRecord.hpp">gpudb/GenericRecord.hpp</a>></code></p>

    <table>
      <tr>
        <td>
          <h2> Public Member Functions</h2>
        </td>
      </tr>

      <tr>
        <td> </td>
        <td><a href="#aba7a34ed176e1e44753d1ba6300d380a">GenericRecord</a> (const <a href="/content/api/cpp/classgpudb_1_1Type">Type</a> \&type)</td>
      </tr>

      <tr>
        <td> </td>
        <td>Create a blank <a href="/content/api/cpp/classgpudb_1_1GenericRecord">GenericRecord</a> object from a given type. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>const <a href="/content/api/cpp/classgpudb_1_1Type">Type</a> & </td>
        <td><a href="#aec41b4752c5ba5e6e02e5691e1837e0a">getType</a> () const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>const ::avro::ValidSchema & </td>
        <td><a href="#adce9556b5a5576879bd339187aeaea3a">getSchema</a> () const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>template\<typename T> </td>
      </tr>

      <tr>
        <td>T & </td>
        <td><a href="#af327b966fe270856dd21f416c6517e9c">value</a> (const size\_t index)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>template\<typename T> </td>
      </tr>

      <tr>
        <td>const T & </td>
        <td><a href="#a2f3a17536dca9cb73e2c35c3f846da09">value</a> (const size\_t index) const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>template\<typename T> </td>
      </tr>

      <tr>
        <td>T & </td>
        <td><a href="#a4e9d4557e95771952701647acc5fb320">value</a> (const std::string \&name)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>template\<typename T> </td>
      </tr>

      <tr>
        <td>const T & </td>
        <td><a href="#ac0b50c938f91045061a5de498b013dfe">value</a> (const std::string \&name) const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>std::vector\< uint8\_t > & </td>
        <td><a href="#a8793cf5a869da8d9cd7e8488c962af24">bytesValue</a> (const size\_t index)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>const std::vector\< uint8\_t > & </td>
        <td><a href="#a86a192ad45564679c03d519f9ccf2f6b">bytesValue</a> (const size\_t index) const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>std::vector\< uint8\_t > & </td>
        <td><a href="#a39b079b3cabcf489f0951b0b411d6b20">bytesValue</a> (const std::string \&name)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>const std::vector\< uint8\_t > & </td>
        <td><a href="#a3d3c5cd2421d9b2036e48814d3830279">bytesValue</a> (const std::string \&name) const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>double & </td>
        <td><a href="#ace50f8aa1742e445f8b08da99aea008a">doubleValue</a> (const size\_t index)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>const double & </td>
        <td><a href="#a80849c9a2f9470cc947cca6b53a5c1eb">doubleValue</a> (const size\_t index) const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>double & </td>
        <td><a href="#acc420cebae248ed10341f8fb0abe57f5">doubleValue</a> (const std::string \&name)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>const double & </td>
        <td><a href="#a4a0b97a465628c04d4981a2a21b6400e">doubleValue</a> (const std::string \&name) const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>float & </td>
        <td><a href="#a33be82ed567e264b5270f0c4158014ca">floatValue</a> (const size\_t index)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>const float & </td>
        <td><a href="#a3f9ef75fb3b6d907a0c58f12b3fa04cc">floatValue</a> (const size\_t index) const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>float & </td>
        <td><a href="#aacb0fcfe4288634465915bca105559db">floatValue</a> (const std::string \&name)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>const float & </td>
        <td><a href="#a5ffa0c37aa6accb46daa8f3928362a5f">floatValue</a> (const std::string \&name) const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>int32\_t & </td>
        <td><a href="#a11c8bee4919309acf23d9a19a48eb99f">intValue</a> (const size\_t index)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>const int32\_t & </td>
        <td><a href="#ac9de0ecd2904c3744adfafef821e803f">intValue</a> (const size\_t index) const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>int32\_t & </td>
        <td><a href="#a67a133fb7aaa75c9d6e3c13252feba58">intValue</a> (const std::string \&name)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>const int32\_t & </td>
        <td><a href="#ae124e47a26482754370810e392d60f5b">intValue</a> (const std::string \&name) const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>int64\_t & </td>
        <td><a href="#a03d222dc54d17211d7832c5c89b1bd83">longValue</a> (const size\_t index)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>const int64\_t & </td>
        <td><a href="#abcae2aa336f9766ccea5a462b7bbf815">longValue</a> (const size\_t index) const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>int64\_t & </td>
        <td><a href="#a44ad483b91b2fe55d48b51c810f79dc7">longValue</a> (const std::string \&name)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>const int64\_t & </td>
        <td><a href="#ae32193e9780c38a6edad7321a4562abc">longValue</a> (const std::string \&name) const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>std::string & </td>
        <td><a href="#ac425240b0ff6375cbb2a9f4097110539">stringValue</a> (const size\_t index)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>const std::string & </td>
        <td><a href="#a277c4f8e0ed7b1ff7f0d6108e8a76ddb">stringValue</a> (const size\_t index) const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>std::string & </td>
        <td><a href="#ab41460383bba2df9b5699e116a31bc0e">stringValue</a> (const std::string \&name)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>const std::string & </td>
        <td><a href="#a514e02c60e4f4893fb9b147c393686c3">stringValue</a> (const std::string \&name) const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>boost::optional\< std::vector\< uint8\_t > > & </td>
        <td><a href="#adb27a93086d01604450eb592a99b5804">nullableBytesValue</a> (const size\_t index)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>const boost::optional\< std::vector\< uint8\_t > > & </td>
        <td><a href="#ae0b664ed8194bfc7fa1e5353dcc80abd">nullableBytesValue</a> (const size\_t index) const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>boost::optional\< std::vector\< uint8\_t > > & </td>
        <td><a href="#a23171a2f52d68d98007e66a4722027c4">nullableBytesValue</a> (const std::string \&name)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>const boost::optional\< std::vector\< uint8\_t > > & </td>
        <td><a href="#affb746b7f3a82e9b69adde60cbe4f219">nullableBytesValue</a> (const std::string \&name) const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>boost::optional\< double > & </td>
        <td><a href="#a4337018b441a5b47fac20603d8abcd27">nullableDoubleValue</a> (const size\_t index)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>const boost::optional\< double > & </td>
        <td><a href="#ab7c0e0bce24739d9276a56fb7df617fb">nullableDoubleValue</a> (const size\_t index) const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>boost::optional\< double > & </td>
        <td><a href="#a1fb7a1374c40b2863a0d434a3f3a6f82">nullableDoubleValue</a> (const std::string \&name)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>const boost::optional\< double > & </td>
        <td><a href="#ab6e4d101cdc99a511febce45572be969">nullableDoubleValue</a> (const std::string \&name) const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>boost::optional\< float > & </td>
        <td><a href="#a36806d807a4840ae1dae85f42f8ba36e">nullableFloatValue</a> (const size\_t index)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>const boost::optional\< float > & </td>
        <td><a href="#a3eba14fa191d810fdc2aaede7751c863">nullableFloatValue</a> (const size\_t index) const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>boost::optional\< float > & </td>
        <td><a href="#aaebfc65168cd2717cb9c1dc614fd291b">nullableFloatValue</a> (const std::string \&name)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>const boost::optional\< float > & </td>
        <td><a href="#abae90ccb557729607d534f1f8f47503c">nullableFloatValue</a> (const std::string \&name) const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>boost::optional\< int32\_t > & </td>
        <td><a href="#a4f4246219da4a89f5033d3ffdde03de7">nullableIntValue</a> (const size\_t index)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>const boost::optional\< int32\_t > & </td>
        <td><a href="#a91b6aa7056d1456ea590b4fd1d8a009d">nullableIntValue</a> (const size\_t index) const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>boost::optional\< int32\_t > & </td>
        <td><a href="#a37ee3e0d476fc866909170426ba9aebe">nullableIntValue</a> (const std::string \&name)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>const boost::optional\< int32\_t > & </td>
        <td><a href="#a5b15c2523e02678cffe2c9de176c1a76">nullableIntValue</a> (const std::string \&name) const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>boost::optional\< int64\_t > & </td>
        <td><a href="#aa0d3671b834e335c35e5610800401d86">nullableLongValue</a> (const size\_t index)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>const boost::optional\< int64\_t > & </td>
        <td><a href="#aec6e33d13b7811e27dd1c98eed27964b">nullableLongValue</a> (const size\_t index) const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>boost::optional\< int64\_t > & </td>
        <td><a href="#af8b47f9682c5b3469bf3b679aa0251e3">nullableLongValue</a> (const std::string \&name)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>const boost::optional\< int64\_t > & </td>
        <td><a href="#aea33b519e27cb049cc1643e37cb06470">nullableLongValue</a> (const std::string \&name) const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>boost::optional\< std::string > & </td>
        <td><a href="#acd6dc224addd0e38431a92e69d9a649d">nullableStringValue</a> (const size\_t index)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>const boost::optional\< std::string > & </td>
        <td><a href="#a531b2dbbefa0b6f44f6534fe4e691c7d">nullableStringValue</a> (const size\_t index) const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>boost::optional\< std::string > & </td>
        <td><a href="#a2c3e5ec0f49d1fd0ff52d2a6694bc37b">nullableStringValue</a> (const std::string \&name)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>const boost::optional\< std::string > & </td>
        <td><a href="#af1b3c87a4032fb73b45ef31eaa751596">nullableStringValue</a> (const std::string \&name) const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>bool </td>
        <td><a href="#a840f8d1b5e92886ff36ac2a80128cb29">isNull</a> (const size\_t index) const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>bool </td>
        <td><a href="#a32f0f7a4ad63ff21b8ee99b5c527cfd5">isNull</a> (const std::string \&name) const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>template\<typename T> </td>
      </tr>

      <tr>
        <td>void </td>
        <td><a href="#a5063f3aa9a481c3f7328e1bec4d57688">getAsArray</a> (const size\_t index, std::vector\< T > \&result) const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>template\<typename T> </td>
      </tr>

      <tr>
        <td>void </td>
        <td><a href="#a569084222b89af0caee7f7b8221340a4">getAsArray</a> (const std::string \&name, std::vector\< T > \&result) const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>template\<typename T> </td>
      </tr>

      <tr>
        <td>std::vector\< T > </td>
        <td><a href="#a23b4c9b9473bd3573fc0c9d17bcc9536">getAsArray</a> (const size\_t index) const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>template\<typename T> </td>
      </tr>

      <tr>
        <td>std::vector\< T > </td>
        <td><a href="#ae827bfcc1175c0508f864d3099f7d23d">getAsArray</a> (const std::string \&name) const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>void </td>
        <td><a href="#a8eb289649546b4ee2a39b2184accb268">getAsBytes</a> (const size\_t index, std::vector\< uint8\_t > \&result) const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>void </td>
        <td><a href="#a87c2e60116c02bdafffcd48783128819">getAsBytes</a> (const std::string \&name, std::vector\< uint8\_t > \&result) const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>std::vector\< uint8\_t > </td>
        <td><a href="#ab618725d20637721d3d6510d0a57c075">getAsBytes</a> (const size\_t index) const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>std::vector\< uint8\_t > </td>
        <td><a href="#a388b1eae496cbf3e63a6eaffd253355b">getAsBytes</a> (const std::string \&name) const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>void </td>
        <td><a href="#af161a290066db6ae2cf109b404870eed">getAsDouble</a> (const size\_t index, double \&result) const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>void </td>
        <td><a href="#a0ee3c71466804d1473112b7eaf782ba4">getAsDouble</a> (const std::string \&name, double \&result) const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>double </td>
        <td><a href="#a0bf13813f785dfb43687b8a57d1014d7">getAsDouble</a> (const size\_t index) const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>double </td>
        <td><a href="#a3ad1cc744e726dc93e4a7ed8e3da6fe5">getAsDouble</a> (const std::string \&name) const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>void </td>
        <td><a href="#a11932042649adaea15156dfd05219e58">getAsFloat</a> (const size\_t index, float \&result) const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>void </td>
        <td><a href="#a53b7ea1f51a681bb5f43ebad98508809">getAsFloat</a> (const std::string \&name, float \&result) const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>float </td>
        <td><a href="#a5c002d0db26bfa00a77ab51a9af11d95">getAsFloat</a> (const size\_t index) const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>float </td>
        <td><a href="#a1e5ce0971f7ace670e2c27b4e11ebcfd">getAsFloat</a> (const std::string \&name) const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>void </td>
        <td><a href="#ad8c4ffde85993e3d657a6f53aadbec5b">getAsInt</a> (const size\_t index, int32\_t \&result) const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>void </td>
        <td><a href="#ab678a7bbc10f68818d623ba6ca397cd4">getAsInt</a> (const std::string \&name, int32\_t \&result) const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>int32\_t </td>
        <td><a href="#a1fa1f35f79ec8508b433dcee7bd71dc8">getAsInt</a> (const size\_t index) const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>int32\_t </td>
        <td><a href="#ae4d522a121cb42876b8366356ce9f0c4">getAsInt</a> (const std::string \&name) const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>void </td>
        <td><a href="#a7665f7d300db16a87a161c3fdf531e89">getAsLong</a> (const size\_t index, int64\_t \&result) const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>void </td>
        <td><a href="#a433bc447a5d95b3346b821dd41b55241">getAsLong</a> (const std::string \&name, int64\_t \&result) const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>int64\_t </td>
        <td><a href="#a0bdafb112ec03d8c686c59e270c6b01e">getAsLong</a> (const size\_t index) const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>int64\_t </td>
        <td><a href="#acbc3c8a6a337b09df41f3f148c97b1ca">getAsLong</a> (const std::string \&name) const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>void </td>
        <td><a href="#a21c614b6cdad35fa77cc0a5e2ac69eb5">getAsString</a> (const size\_t index, std::string \&result) const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>void </td>
        <td><a href="#a9870ff86c35a2c196e4a974d20df72a3">getAsString</a> (const std::string \&name, std::string \&result) const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>std::string </td>
        <td><a href="#aaed9025b785de3abdeec847f6b9e2e17">getAsString</a> (const size\_t index) const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>std::string </td>
        <td><a href="#ae0ffc6a6a36f4a338ae83e3c6ca08742">getAsString</a> (const std::string \&name) const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>void </td>
        <td><a href="#ac84efaa73fd8a2b7256859565615224f">getAsVector</a> (const size\_t index, std::vector\< float > \&result) const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>void </td>
        <td><a href="#a0155f7a39668d2ab900e1311f9e71bcb">getAsVector</a> (const std::string \&name, std::vector\< float > \&result) const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>std::vector\< float > </td>
        <td><a href="#aaa0653050a576feef396570c7e03e593">getAsVector</a> (const size\_t index) const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>std::vector\< float > </td>
        <td><a href="#aedf5ba7899385675a8e9b5d2fdf02080">getAsVector</a> (const std::string \&name) const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>void </td>
        <td><a href="#a469c40a4913c79ee5fee1edeb0c04a0f">getAsNullableBytes</a> (const size\_t index, boost::optional\< std::vector\< uint8\_t > > \&result) const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>void </td>
        <td><a href="#a1f62aaa431ad03adbca7fc95f6fce82f">getAsNullableBytes</a> (const std::string \&name, boost::optional\< std::vector\< uint8\_t > > \&result) const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>boost::optional\< std::vector\< uint8\_t > > </td>
        <td><a href="#a3ff30cca76395448ccdc277bf31d26b6">getAsNullableBytes</a> (const size\_t index) const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>boost::optional\< std::vector\< uint8\_t > > </td>
        <td><a href="#a5f1860b7849db7df452107539292d039">getAsNullableBytes</a> (const std::string \&name) const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>void </td>
        <td><a href="#a5d9053728b461218b02cb949378d202a">getAsNullableDouble</a> (const size\_t index, boost::optional\< double > \&result) const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>void </td>
        <td><a href="#ae5f72dd5e7b512b805eaa6a2491fb574">getAsNullableDouble</a> (const std::string \&name, boost::optional\< double > \&result) const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>boost::optional\< double > </td>
        <td><a href="#a38c1e5148a388dda537dba5cdab9267c">getAsNullableDouble</a> (const size\_t index) const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>boost::optional\< double > </td>
        <td><a href="#a714078fb5dc23d30efae2d91571283d4">getAsNullableDouble</a> (const std::string \&name) const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>void </td>
        <td><a href="#a9f2c94f329c96d4e2c19575f46425024">getAsNullableFloat</a> (const size\_t index, boost::optional\< float > \&result) const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>void </td>
        <td><a href="#a17fe59298378ada8b50794290aac94de">getAsNullableFloat</a> (const std::string \&name, boost::optional\< float > \&result) const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>boost::optional\< float > </td>
        <td><a href="#af5bafda6802f364a31508c795d85b68e">getAsNullableFloat</a> (const size\_t index) const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>boost::optional\< float > </td>
        <td><a href="#af566421019cf59d363a711d5e418355a">getAsNullableFloat</a> (const std::string \&name) const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>void </td>
        <td><a href="#a9fc2664cbc45fc471aeb1a0f6be764f7">getAsNullableInt</a> (const size\_t index, boost::optional\< int32\_t > \&result) const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>void </td>
        <td><a href="#ac278a91367751ffdc986e531bb27d878">getAsNullableInt</a> (const std::string \&name, boost::optional\< int32\_t > \&result) const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>boost::optional\< int32\_t > </td>
        <td><a href="#a8522d2d1d8cbe7d12b029ca2e2a7adb8">getAsNullableInt</a> (const size\_t index) const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>boost::optional\< int32\_t > </td>
        <td><a href="#a33fd7ed08ac0048477f3314fa4393ea7">getAsNullableInt</a> (const std::string \&name) const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>void </td>
        <td><a href="#aaebd38abe0f723d28cf64ef4a935afe9">getAsNullableLong</a> (const size\_t index, boost::optional\< int64\_t > \&result) const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>void </td>
        <td><a href="#af2e89f4fb154bb7ce11aae122ddb173a">getAsNullableLong</a> (const std::string \&name, boost::optional\< int64\_t > \&result) const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>boost::optional\< int64\_t > </td>
        <td><a href="#a714515784949fe4f663528f13195a247">getAsNullableLong</a> (const size\_t index) const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>boost::optional\< int64\_t > </td>
        <td><a href="#a6cd177f67ffd566db6295e3f6cfe038b">getAsNullableLong</a> (const std::string \&name) const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>void </td>
        <td><a href="#a0f057d774e8143fe8b35409be83d4932">getAsNullableString</a> (const size\_t index, boost::optional\< std::string > \&result) const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>void </td>
        <td><a href="#a79b9fd77d016945cb28d6fd8dd55e31b">getAsNullableString</a> (const std::string \&name, boost::optional\< std::string > \&result) const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>boost::optional\< std::string > </td>
        <td><a href="#aef1e5c349cd23174f45548b38b080215">getAsNullableString</a> (const size\_t index) const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>boost::optional\< std::string > </td>
        <td><a href="#a530219dcef1f6ba1e0f903fc8e013d48">getAsNullableString</a> (const std::string \&name) const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>void </td>
        <td><a href="#ab91de1571915970989ce5f0ecf58290d">setNull</a> (const size\_t index)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>void </td>
        <td><a href="#a39672b7529b3d4e8fbfcc0649d42805d">setNull</a> (const std::string \&name)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>template\<typename T> </td>
      </tr>

      <tr>
        <td>void </td>
        <td><a href="#a4aca554d87dadd5c2fd4d1f452a21027">setAsArray</a> (const size\_t index, const std::vector\< T > \&newValue)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>template\<typename T> </td>
      </tr>

      <tr>
        <td>void </td>
        <td><a href="#a72560893fceca48654266624e89a4446">setAsArray</a> (const std::string \&name, const std::vector\< T > \&newValue)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>void </td>
        <td><a href="#a67f5bd5c291ae886ad11873589014425">setAsBytes</a> (const size\_t index, const std::vector\< uint8\_t > \&newValue)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>void </td>
        <td><a href="#a68d5e17d39e1e6b05fb7f1695a53a087">setAsBytes</a> (const std::string \&name, const std::vector\< uint8\_t > \&newValue)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>void </td>
        <td><a href="#a36ff41cd52ebe74666f8417d0c58ca23">setAsDouble</a> (const size\_t index, const double \&newValue)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>void </td>
        <td><a href="#a596693bc3ea9f14c5aea6907e3b66257">setAsDouble</a> (const std::string \&name, const double \&newValue)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>void </td>
        <td><a href="#a58576acc160dbfc02888d4de7d0f1987">setAsFloat</a> (const size\_t index, const float \&newValue)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>void </td>
        <td><a href="#a810f3e51808441470dcf0d152da0e71b">setAsFloat</a> (const std::string \&name, const float \&newValue)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>void </td>
        <td><a href="#af065d249d6c3402ddd902f37dabb37fa">setAsInt</a> (const size\_t index, const int32\_t \&newValue)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>void </td>
        <td><a href="#aed85392d6663faee64addae5dd5b72f5">setAsInt</a> (const std::string \&name, const int32\_t \&newValue)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>void </td>
        <td><a href="#ae089a6bfe4bcce28221cc27a90d4c47e">setAsLong</a> (const size\_t index, const int64\_t \&newValue)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>void </td>
        <td><a href="#a1db605f8b882b648c97a61cd5fcb00f7">setAsLong</a> (const std::string \&name, const int64\_t \&newValue)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>void </td>
        <td><a href="#a12a615708076683deaec27007f182e33">setAsString</a> (const size\_t index, const std::string \&newValue)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>void </td>
        <td><a href="#af2c1912e6b1d5caf77857ced19c8479c">setAsString</a> (const std::string \&name, const std::string \&newValue)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>void </td>
        <td><a href="#a096c80c2c6841c47c2b548de8b4b392f">setAsVector</a> (const size\_t index, const std::vector\< float > \&newValue)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>void </td>
        <td><a href="#a55f49e2f3ae4d7a952213c0138043de7">setAsVector</a> (const std::string \&name, const std::vector\< float > \&newValue)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>void </td>
        <td><a href="#a2e0a037de7a0c740fdd0a914fcace4e5">setAsNullableBytes</a> (const size\_t index, const boost::optional\< std::vector\< uint8\_t > > \&newValue)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>void </td>
        <td><a href="#ac186825dbeedd66bd40bb0b1488a2762">setAsNullableBytes</a> (const std::string \&name, const boost::optional\< std::vector\< uint8\_t > > \&newValue)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>void </td>
        <td><a href="#a75df6df375ac5826e038f8ced4ea4977">setAsNullableDouble</a> (const size\_t index, const boost::optional\< double > \&newValue)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>void </td>
        <td><a href="#ab266ead475b34b326e904462604bdbd8">setAsNullableDouble</a> (const std::string \&name, const boost::optional\< double > \&newValue)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>void </td>
        <td><a href="#a150c9331b20370f2167dc8de4f1ef50d">setAsNullableFloat</a> (const size\_t index, const boost::optional\< float > \&newValue)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>void </td>
        <td><a href="#a47468f32ece94b34f54cfaf7acb04ff7">setAsNullableFloat</a> (const std::string \&name, const boost::optional\< float > \&newValue)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>void </td>
        <td><a href="#a8e7e25d566c03cc444fedbeb54554566">setAsNullableInt</a> (const size\_t index, const boost::optional\< int32\_t > \&newValue)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>void </td>
        <td><a href="#ac6f2b0fa63c78790e0b68ba981fefc77">setAsNullableInt</a> (const std::string \&name, const boost::optional\< int32\_t > \&newValue)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>void </td>
        <td><a href="#ab266ce96d2c8de22f4486286fcc7cfa3">setAsNullableLong</a> (const size\_t index, const boost::optional\< int64\_t > \&newValue)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>void </td>
        <td><a href="#a0d0fa91ac39d9d7639a276aa55e3e96b">setAsNullableLong</a> (const std::string \&name, const boost::optional\< int64\_t > \&newValue)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>void </td>
        <td><a href="#a5495bb6191b21f4faac7652a4957d4a2">setAsNullableString</a> (const size\_t index, const boost::optional\< std::string > \&newValue)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>void </td>
        <td><a href="#a4cf9298115107954777374fed12947f6">setAsNullableString</a> (const std::string \&name, const boost::optional\< std::string > \&newValue)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>void </td>
        <td><a href="#a79ccb9099cca7daa4c8fc0c7925b1f74">toString</a> (const size\_t index, std::string \&result) const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>void </td>
        <td><a href="#aeec9b1f89169f531f2422af58ea0ba60">toString</a> (const std::string \&name, std::string \&result) const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>std::string </td>
        <td><a href="#a1533f28191edcb85b87575dfc52b758b">toString</a> (const size\_t index) const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>std::string </td>
        <td><a href="#ae39ad31300692d6ff31ee28d5e505bae">toString</a> (const std::string \&name) const</td>
      </tr>

      <tr>
        <td> </td>
      </tr>
    </table>

    <table>
      <tr>
        <td>
          <h2> Static Public Member Functions</h2>
        </td>
      </tr>

      <tr>
        <td>static void </td>
        <td><a href="#acb59bbd10a7df6eb14a11ce10a177e76">decode</a> (const std::string \&schemaString, const std::vector\< std::vector\< uint8\_t > > \&encodedData, std::vector\< <a href="/content/api/cpp/classgpudb_1_1GenericRecord">GenericRecord</a> > \&data)</td>
      </tr>

      <tr>
        <td> </td>
        <td>Decodes avro encoded data (given the schema string) into <a href="/content/api/cpp/classgpudb_1_1GenericRecord">GenericRecord</a> objects. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>static void </td>
        <td><a href="#aadc95bdabaedf7af9abdb69478303ee8">decode</a> (const std::string \&schemaString, const std::vector\< uint8\_t > \&encodedData, <a href="/content/api/cpp/classgpudb_1_1GenericRecord">GenericRecord</a> \&data)</td>
      </tr>

      <tr>
        <td> </td>
        <td>Decodes avro encoded data (given the schema string) into <a href="/content/api/cpp/classgpudb_1_1GenericRecord">GenericRecord</a> objects. <br /></td>
      </tr>

      <tr>
        <td> </td>
      </tr>
    </table>

    <table>
      <tr>
        <td>
          <h2> Friends</h2>
        </td>
      </tr>

      <tr>
        <td>class </td>
        <td><a href="#ab5eaf2f4b0ec3c37ab3bbae2b6b459fd">GPUdb</a></td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>std::ostream & </td>
        <td><a href="#a78da33f50faad969a69f27e5c5b1ff5d">operator\<\<</a> (std::ostream \&os, <a href="/content/api/cpp/classgpudb_1_1GenericRecord">GenericRecord</a> \&gr)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>

      <tr>
        <td>std::ostream & </td>
        <td><a href="#a83079f9bbcdfc4664be3ae0d8b5a1488">operator\<\<</a> (std::ostream \&os, const <a href="/content/api/cpp/classgpudb_1_1GenericRecord">GenericRecord</a> \&gr)</td>
      </tr>

      <tr>
        <td> </td>
      </tr>
    </table>

    <h2>Detailed Description</h2>

    <div>
      <p>Definition at line <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GenericRecord.hpp#L23">23</a> of file <a href="https://github.com/kineticadb/kinetica-api-cpp/blob/master/gpudb/GenericRecord.hpp">GenericRecord.hpp</a>.</p>
    </div>

    <h2>Constructor & Destructor Documentation</h2>
    <h2><span><a href="#aba7a34ed176e1e44753d1ba6300d380a">◆ </a></span>GenericRecord()</h2>

    <div>
      <div>
        <table>
          <tr>
            <td>gpudb::GenericRecord::GenericRecord </td>
            <td>(</td>
            <td>const <a href="/content/api/cpp/classgpudb_1_1Type">Type</a> &</td>
            <td><span><span>type</span></span></td>
            <td>)</td>

            <td />
          </tr>
        </table>
      </div>

      <div>
        <p>Create a blank <a href="/content/api/cpp/classgpudb_1_1GenericRecord">GenericRecord</a> object from a given type. </p>
      </div>
    </div>

    <h2>Member Function Documentation</h2>
    <h2><span><a href="#a8793cf5a869da8d9cd7e8488c962af24">◆ </a></span>bytesValue() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>std::vector\< uint8\_t > & gpudb::GenericRecord::bytesValue </td>
            <td>(</td>
            <td>const size\_t</td>
            <td><span><span>index</span></span></td>
            <td>)</td>

            <td />
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#a86a192ad45564679c03d519f9ccf2f6b">◆ </a></span>bytesValue() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>const std::vector\< uint8\_t > & gpudb::GenericRecord::bytesValue </td>
            <td>(</td>
            <td>const size\_t</td>
            <td><span><span>index</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#a39b079b3cabcf489f0951b0b411d6b20">◆ </a></span>bytesValue() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>std::vector\< uint8\_t > & gpudb::GenericRecord::bytesValue </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span></td>
            <td>)</td>

            <td />
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#a3d3c5cd2421d9b2036e48814d3830279">◆ </a></span>bytesValue() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>const std::vector\< uint8\_t > & gpudb::GenericRecord::bytesValue </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#acb59bbd10a7df6eb14a11ce10a177e76">◆ </a></span>decode() <span>\[1/2]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>
              <table>
                <tr>
                  <td>static void gpudb::GenericRecord::decode </td>
                  <td>(</td>
                  <td>const std::string &</td>
                  <td><span><span>schemaString</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const std::vector\< std::vector\< uint8\_t > > &</td>
                  <td><span><span>encodedData</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>std::vector\< <a href="/content/api/cpp/classgpudb_1_1GenericRecord">GenericRecord</a> > &</td>
                  <td><span><span>data</span></span> )</td>
                </tr>
              </table>
            </td>

            <td> <span><span>static</span></span> </td>
          </tr>
        </table>
      </div>

      <div>
        <p>Decodes avro encoded data (given the schema string) into <a href="/content/api/cpp/classgpudb_1_1GenericRecord">GenericRecord</a> objects. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>schemaString</td>
                <td>Avro schema string used for decoding the data </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>encodedData</td>
                <td>Avro encoded binary data containing multiple records. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>data</td>
                <td>Vector of decoded <a href="/content/api/cpp/classgpudb_1_1GenericRecord">GenericRecord</a> objects. The vector is cleared before operation begins. </td>
              </tr>
            </table>
          </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#aadc95bdabaedf7af9abdb69478303ee8">◆ </a></span>decode() <span>\[2/2]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>
              <table>
                <tr>
                  <td>static void gpudb::GenericRecord::decode </td>
                  <td>(</td>
                  <td>const std::string &</td>
                  <td><span><span>schemaString</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td>const std::vector\< uint8\_t > &</td>
                  <td><span><span>encodedData</span></span>, </td>
                </tr>

                <tr>
                  <td />

                  <td />

                  <td><a href="/content/api/cpp/classgpudb_1_1GenericRecord">GenericRecord</a> &</td>
                  <td><span><span>data</span></span> )</td>
                </tr>
              </table>
            </td>

            <td> <span><span>static</span></span> </td>
          </tr>
        </table>
      </div>

      <div>
        <p>Decodes avro encoded data (given the schema string) into <a href="/content/api/cpp/classgpudb_1_1GenericRecord">GenericRecord</a> objects. </p>

        <div>
          <div>Parameters</div>

          <div>
            <table>
              <tr>
                <td>\[in]</td>
                <td>schemaString</td>
                <td>Avro schema string used for decoding the data </td>
              </tr>

              <tr>
                <td>\[in]</td>
                <td>encodedData</td>
                <td>Avro encoded binary data containing a single record. </td>
              </tr>

              <tr>
                <td>\[out]</td>
                <td>data</td>
                <td>A decoded <a href="/content/api/cpp/classgpudb_1_1GenericRecord">GenericRecord</a> object </td>
              </tr>
            </table>
          </div>
        </div>
      </div>
    </div>

    <h2><span><a href="#ace50f8aa1742e445f8b08da99aea008a">◆ </a></span>doubleValue() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>double & gpudb::GenericRecord::doubleValue </td>
            <td>(</td>
            <td>const size\_t</td>
            <td><span><span>index</span></span></td>
            <td>)</td>

            <td />
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#a80849c9a2f9470cc947cca6b53a5c1eb">◆ </a></span>doubleValue() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>const double & gpudb::GenericRecord::doubleValue </td>
            <td>(</td>
            <td>const size\_t</td>
            <td><span><span>index</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#acc420cebae248ed10341f8fb0abe57f5">◆ </a></span>doubleValue() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>double & gpudb::GenericRecord::doubleValue </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span></td>
            <td>)</td>

            <td />
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#a4a0b97a465628c04d4981a2a21b6400e">◆ </a></span>doubleValue() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>const double & gpudb::GenericRecord::doubleValue </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#a33be82ed567e264b5270f0c4158014ca">◆ </a></span>floatValue() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>float & gpudb::GenericRecord::floatValue </td>
            <td>(</td>
            <td>const size\_t</td>
            <td><span><span>index</span></span></td>
            <td>)</td>

            <td />
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#a3f9ef75fb3b6d907a0c58f12b3fa04cc">◆ </a></span>floatValue() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>const float & gpudb::GenericRecord::floatValue </td>
            <td>(</td>
            <td>const size\_t</td>
            <td><span><span>index</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#aacb0fcfe4288634465915bca105559db">◆ </a></span>floatValue() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>float & gpudb::GenericRecord::floatValue </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span></td>
            <td>)</td>

            <td />
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#a5ffa0c37aa6accb46daa8f3928362a5f">◆ </a></span>floatValue() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>const float & gpudb::GenericRecord::floatValue </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#a23b4c9b9473bd3573fc0c9d17bcc9536">◆ </a></span>getAsArray() <span>\[1/4]</span></h2>

    <div>
      <div>
        <div> template\<typename T> </div>

        <table>
          <tr>
            <td>std::vector\< T > gpudb::GenericRecord::getAsArray </td>
            <td>(</td>
            <td>const size\_t</td>
            <td><span><span>index</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#a5063f3aa9a481c3f7328e1bec4d57688">◆ </a></span>getAsArray() <span>\[2/4]</span></h2>

    <div>
      <div>
        <div> template\<typename T> </div>

        <table>
          <tr>
            <td>void gpudb::GenericRecord::getAsArray </td>
            <td>(</td>
            <td>const size\_t</td>
            <td><span><span>index</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>std::vector\< T > &</td>
            <td><span><span>result</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#ae827bfcc1175c0508f864d3099f7d23d">◆ </a></span>getAsArray() <span>\[3/4]</span></h2>

    <div>
      <div>
        <div> template\<typename T> </div>

        <table>
          <tr>
            <td>std::vector\< T > gpudb::GenericRecord::getAsArray </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#a569084222b89af0caee7f7b8221340a4">◆ </a></span>getAsArray() <span>\[4/4]</span></h2>

    <div>
      <div>
        <div> template\<typename T> </div>

        <table>
          <tr>
            <td>void gpudb::GenericRecord::getAsArray </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>std::vector\< T > &</td>
            <td><span><span>result</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#ab618725d20637721d3d6510d0a57c075">◆ </a></span>getAsBytes() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>std::vector\< uint8\_t > gpudb::GenericRecord::getAsBytes </td>
            <td>(</td>
            <td>const size\_t</td>
            <td><span><span>index</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#a8eb289649546b4ee2a39b2184accb268">◆ </a></span>getAsBytes() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>void gpudb::GenericRecord::getAsBytes </td>
            <td>(</td>
            <td>const size\_t</td>
            <td><span><span>index</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>std::vector\< uint8\_t > &</td>
            <td><span><span>result</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#a388b1eae496cbf3e63a6eaffd253355b">◆ </a></span>getAsBytes() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>std::vector\< uint8\_t > gpudb::GenericRecord::getAsBytes </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#a87c2e60116c02bdafffcd48783128819">◆ </a></span>getAsBytes() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>void gpudb::GenericRecord::getAsBytes </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>std::vector\< uint8\_t > &</td>
            <td><span><span>result</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#a0bf13813f785dfb43687b8a57d1014d7">◆ </a></span>getAsDouble() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>double gpudb::GenericRecord::getAsDouble </td>
            <td>(</td>
            <td>const size\_t</td>
            <td><span><span>index</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#af161a290066db6ae2cf109b404870eed">◆ </a></span>getAsDouble() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>void gpudb::GenericRecord::getAsDouble </td>
            <td>(</td>
            <td>const size\_t</td>
            <td><span><span>index</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>double &</td>
            <td><span><span>result</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#a3ad1cc744e726dc93e4a7ed8e3da6fe5">◆ </a></span>getAsDouble() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>double gpudb::GenericRecord::getAsDouble </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#a0ee3c71466804d1473112b7eaf782ba4">◆ </a></span>getAsDouble() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>void gpudb::GenericRecord::getAsDouble </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>double &</td>
            <td><span><span>result</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#a5c002d0db26bfa00a77ab51a9af11d95">◆ </a></span>getAsFloat() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>float gpudb::GenericRecord::getAsFloat </td>
            <td>(</td>
            <td>const size\_t</td>
            <td><span><span>index</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#a11932042649adaea15156dfd05219e58">◆ </a></span>getAsFloat() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>void gpudb::GenericRecord::getAsFloat </td>
            <td>(</td>
            <td>const size\_t</td>
            <td><span><span>index</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>float &</td>
            <td><span><span>result</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#a1e5ce0971f7ace670e2c27b4e11ebcfd">◆ </a></span>getAsFloat() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>float gpudb::GenericRecord::getAsFloat </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#a53b7ea1f51a681bb5f43ebad98508809">◆ </a></span>getAsFloat() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>void gpudb::GenericRecord::getAsFloat </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>float &</td>
            <td><span><span>result</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#a1fa1f35f79ec8508b433dcee7bd71dc8">◆ </a></span>getAsInt() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>int32\_t gpudb::GenericRecord::getAsInt </td>
            <td>(</td>
            <td>const size\_t</td>
            <td><span><span>index</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#ad8c4ffde85993e3d657a6f53aadbec5b">◆ </a></span>getAsInt() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>void gpudb::GenericRecord::getAsInt </td>
            <td>(</td>
            <td>const size\_t</td>
            <td><span><span>index</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>int32\_t &</td>
            <td><span><span>result</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#ae4d522a121cb42876b8366356ce9f0c4">◆ </a></span>getAsInt() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>int32\_t gpudb::GenericRecord::getAsInt </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#ab678a7bbc10f68818d623ba6ca397cd4">◆ </a></span>getAsInt() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>void gpudb::GenericRecord::getAsInt </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>int32\_t &</td>
            <td><span><span>result</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#a0bdafb112ec03d8c686c59e270c6b01e">◆ </a></span>getAsLong() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>int64\_t gpudb::GenericRecord::getAsLong </td>
            <td>(</td>
            <td>const size\_t</td>
            <td><span><span>index</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#a7665f7d300db16a87a161c3fdf531e89">◆ </a></span>getAsLong() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>void gpudb::GenericRecord::getAsLong </td>
            <td>(</td>
            <td>const size\_t</td>
            <td><span><span>index</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>int64\_t &</td>
            <td><span><span>result</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#acbc3c8a6a337b09df41f3f148c97b1ca">◆ </a></span>getAsLong() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>int64\_t gpudb::GenericRecord::getAsLong </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#a433bc447a5d95b3346b821dd41b55241">◆ </a></span>getAsLong() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>void gpudb::GenericRecord::getAsLong </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>int64\_t &</td>
            <td><span><span>result</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#a3ff30cca76395448ccdc277bf31d26b6">◆ </a></span>getAsNullableBytes() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>boost::optional\< std::vector\< uint8\_t > > gpudb::GenericRecord::getAsNullableBytes </td>
            <td>(</td>
            <td>const size\_t</td>
            <td><span><span>index</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#a469c40a4913c79ee5fee1edeb0c04a0f">◆ </a></span>getAsNullableBytes() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>void gpudb::GenericRecord::getAsNullableBytes </td>
            <td>(</td>
            <td>const size\_t</td>
            <td><span><span>index</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>boost::optional\< std::vector\< uint8\_t > > &</td>
            <td><span><span>result</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#a5f1860b7849db7df452107539292d039">◆ </a></span>getAsNullableBytes() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>boost::optional\< std::vector\< uint8\_t > > gpudb::GenericRecord::getAsNullableBytes </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#a1f62aaa431ad03adbca7fc95f6fce82f">◆ </a></span>getAsNullableBytes() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>void gpudb::GenericRecord::getAsNullableBytes </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>boost::optional\< std::vector\< uint8\_t > > &</td>
            <td><span><span>result</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#a38c1e5148a388dda537dba5cdab9267c">◆ </a></span>getAsNullableDouble() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>boost::optional\< double > gpudb::GenericRecord::getAsNullableDouble </td>
            <td>(</td>
            <td>const size\_t</td>
            <td><span><span>index</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#a5d9053728b461218b02cb949378d202a">◆ </a></span>getAsNullableDouble() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>void gpudb::GenericRecord::getAsNullableDouble </td>
            <td>(</td>
            <td>const size\_t</td>
            <td><span><span>index</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>boost::optional\< double > &</td>
            <td><span><span>result</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#a714078fb5dc23d30efae2d91571283d4">◆ </a></span>getAsNullableDouble() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>boost::optional\< double > gpudb::GenericRecord::getAsNullableDouble </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#ae5f72dd5e7b512b805eaa6a2491fb574">◆ </a></span>getAsNullableDouble() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>void gpudb::GenericRecord::getAsNullableDouble </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>boost::optional\< double > &</td>
            <td><span><span>result</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#af5bafda6802f364a31508c795d85b68e">◆ </a></span>getAsNullableFloat() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>boost::optional\< float > gpudb::GenericRecord::getAsNullableFloat </td>
            <td>(</td>
            <td>const size\_t</td>
            <td><span><span>index</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#a9f2c94f329c96d4e2c19575f46425024">◆ </a></span>getAsNullableFloat() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>void gpudb::GenericRecord::getAsNullableFloat </td>
            <td>(</td>
            <td>const size\_t</td>
            <td><span><span>index</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>boost::optional\< float > &</td>
            <td><span><span>result</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#af566421019cf59d363a711d5e418355a">◆ </a></span>getAsNullableFloat() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>boost::optional\< float > gpudb::GenericRecord::getAsNullableFloat </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#a17fe59298378ada8b50794290aac94de">◆ </a></span>getAsNullableFloat() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>void gpudb::GenericRecord::getAsNullableFloat </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>boost::optional\< float > &</td>
            <td><span><span>result</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#a8522d2d1d8cbe7d12b029ca2e2a7adb8">◆ </a></span>getAsNullableInt() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>boost::optional\< int32\_t > gpudb::GenericRecord::getAsNullableInt </td>
            <td>(</td>
            <td>const size\_t</td>
            <td><span><span>index</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#a9fc2664cbc45fc471aeb1a0f6be764f7">◆ </a></span>getAsNullableInt() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>void gpudb::GenericRecord::getAsNullableInt </td>
            <td>(</td>
            <td>const size\_t</td>
            <td><span><span>index</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>boost::optional\< int32\_t > &</td>
            <td><span><span>result</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#a33fd7ed08ac0048477f3314fa4393ea7">◆ </a></span>getAsNullableInt() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>boost::optional\< int32\_t > gpudb::GenericRecord::getAsNullableInt </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#ac278a91367751ffdc986e531bb27d878">◆ </a></span>getAsNullableInt() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>void gpudb::GenericRecord::getAsNullableInt </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>boost::optional\< int32\_t > &</td>
            <td><span><span>result</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#a714515784949fe4f663528f13195a247">◆ </a></span>getAsNullableLong() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>boost::optional\< int64\_t > gpudb::GenericRecord::getAsNullableLong </td>
            <td>(</td>
            <td>const size\_t</td>
            <td><span><span>index</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#aaebd38abe0f723d28cf64ef4a935afe9">◆ </a></span>getAsNullableLong() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>void gpudb::GenericRecord::getAsNullableLong </td>
            <td>(</td>
            <td>const size\_t</td>
            <td><span><span>index</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>boost::optional\< int64\_t > &</td>
            <td><span><span>result</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#a6cd177f67ffd566db6295e3f6cfe038b">◆ </a></span>getAsNullableLong() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>boost::optional\< int64\_t > gpudb::GenericRecord::getAsNullableLong </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#af2e89f4fb154bb7ce11aae122ddb173a">◆ </a></span>getAsNullableLong() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>void gpudb::GenericRecord::getAsNullableLong </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>boost::optional\< int64\_t > &</td>
            <td><span><span>result</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#aef1e5c349cd23174f45548b38b080215">◆ </a></span>getAsNullableString() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>boost::optional\< std::string > gpudb::GenericRecord::getAsNullableString </td>
            <td>(</td>
            <td>const size\_t</td>
            <td><span><span>index</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#a0f057d774e8143fe8b35409be83d4932">◆ </a></span>getAsNullableString() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>void gpudb::GenericRecord::getAsNullableString </td>
            <td>(</td>
            <td>const size\_t</td>
            <td><span><span>index</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>boost::optional\< std::string > &</td>
            <td><span><span>result</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#a530219dcef1f6ba1e0f903fc8e013d48">◆ </a></span>getAsNullableString() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>boost::optional\< std::string > gpudb::GenericRecord::getAsNullableString </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#a79b9fd77d016945cb28d6fd8dd55e31b">◆ </a></span>getAsNullableString() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>void gpudb::GenericRecord::getAsNullableString </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>boost::optional\< std::string > &</td>
            <td><span><span>result</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#aaed9025b785de3abdeec847f6b9e2e17">◆ </a></span>getAsString() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>std::string gpudb::GenericRecord::getAsString </td>
            <td>(</td>
            <td>const size\_t</td>
            <td><span><span>index</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#a21c614b6cdad35fa77cc0a5e2ac69eb5">◆ </a></span>getAsString() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>void gpudb::GenericRecord::getAsString </td>
            <td>(</td>
            <td>const size\_t</td>
            <td><span><span>index</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>std::string &</td>
            <td><span><span>result</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#ae0ffc6a6a36f4a338ae83e3c6ca08742">◆ </a></span>getAsString() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>std::string gpudb::GenericRecord::getAsString </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#a9870ff86c35a2c196e4a974d20df72a3">◆ </a></span>getAsString() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>void gpudb::GenericRecord::getAsString </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>std::string &</td>
            <td><span><span>result</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#aaa0653050a576feef396570c7e03e593">◆ </a></span>getAsVector() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>std::vector\< float > gpudb::GenericRecord::getAsVector </td>
            <td>(</td>
            <td>const size\_t</td>
            <td><span><span>index</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#ac84efaa73fd8a2b7256859565615224f">◆ </a></span>getAsVector() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>void gpudb::GenericRecord::getAsVector </td>
            <td>(</td>
            <td>const size\_t</td>
            <td><span><span>index</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>std::vector\< float > &</td>
            <td><span><span>result</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#aedf5ba7899385675a8e9b5d2fdf02080">◆ </a></span>getAsVector() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>std::vector\< float > gpudb::GenericRecord::getAsVector </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#a0155f7a39668d2ab900e1311f9e71bcb">◆ </a></span>getAsVector() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>void gpudb::GenericRecord::getAsVector </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>std::vector\< float > &</td>
            <td><span><span>result</span></span> ) const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#adce9556b5a5576879bd339187aeaea3a">◆ </a></span>getSchema()</h2>

    <div>
      <div>
        <table>
          <tr>
            <td>const ::avro::ValidSchema & gpudb::GenericRecord::getSchema </td>
            <td>(</td>

            <td>
              <span>
                <span />
              </span>
            </td>

            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#aec41b4752c5ba5e6e02e5691e1837e0a">◆ </a></span>getType()</h2>

    <div>
      <div>
        <table>
          <tr>
            <td>const <a href="/content/api/cpp/classgpudb_1_1Type">Type</a> & gpudb::GenericRecord::getType </td>
            <td>(</td>

            <td>
              <span>
                <span />
              </span>
            </td>

            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#a11c8bee4919309acf23d9a19a48eb99f">◆ </a></span>intValue() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>int32\_t & gpudb::GenericRecord::intValue </td>
            <td>(</td>
            <td>const size\_t</td>
            <td><span><span>index</span></span></td>
            <td>)</td>

            <td />
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#ac9de0ecd2904c3744adfafef821e803f">◆ </a></span>intValue() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>const int32\_t & gpudb::GenericRecord::intValue </td>
            <td>(</td>
            <td>const size\_t</td>
            <td><span><span>index</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#a67a133fb7aaa75c9d6e3c13252feba58">◆ </a></span>intValue() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>int32\_t & gpudb::GenericRecord::intValue </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span></td>
            <td>)</td>

            <td />
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#ae124e47a26482754370810e392d60f5b">◆ </a></span>intValue() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>const int32\_t & gpudb::GenericRecord::intValue </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#a840f8d1b5e92886ff36ac2a80128cb29">◆ </a></span>isNull() <span>\[1/2]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>bool gpudb::GenericRecord::isNull </td>
            <td>(</td>
            <td>const size\_t</td>
            <td><span><span>index</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#a32f0f7a4ad63ff21b8ee99b5c527cfd5">◆ </a></span>isNull() <span>\[2/2]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>bool gpudb::GenericRecord::isNull </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#a03d222dc54d17211d7832c5c89b1bd83">◆ </a></span>longValue() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>int64\_t & gpudb::GenericRecord::longValue </td>
            <td>(</td>
            <td>const size\_t</td>
            <td><span><span>index</span></span></td>
            <td>)</td>

            <td />
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#abcae2aa336f9766ccea5a462b7bbf815">◆ </a></span>longValue() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>const int64\_t & gpudb::GenericRecord::longValue </td>
            <td>(</td>
            <td>const size\_t</td>
            <td><span><span>index</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#a44ad483b91b2fe55d48b51c810f79dc7">◆ </a></span>longValue() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>int64\_t & gpudb::GenericRecord::longValue </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span></td>
            <td>)</td>

            <td />
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#ae32193e9780c38a6edad7321a4562abc">◆ </a></span>longValue() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>const int64\_t & gpudb::GenericRecord::longValue </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#adb27a93086d01604450eb592a99b5804">◆ </a></span>nullableBytesValue() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>boost::optional\< std::vector\< uint8\_t > > & gpudb::GenericRecord::nullableBytesValue </td>
            <td>(</td>
            <td>const size\_t</td>
            <td><span><span>index</span></span></td>
            <td>)</td>

            <td />
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#ae0b664ed8194bfc7fa1e5353dcc80abd">◆ </a></span>nullableBytesValue() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>const boost::optional\< std::vector\< uint8\_t > > & gpudb::GenericRecord::nullableBytesValue </td>
            <td>(</td>
            <td>const size\_t</td>
            <td><span><span>index</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#a23171a2f52d68d98007e66a4722027c4">◆ </a></span>nullableBytesValue() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>boost::optional\< std::vector\< uint8\_t > > & gpudb::GenericRecord::nullableBytesValue </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span></td>
            <td>)</td>

            <td />
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#affb746b7f3a82e9b69adde60cbe4f219">◆ </a></span>nullableBytesValue() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>const boost::optional\< std::vector\< uint8\_t > > & gpudb::GenericRecord::nullableBytesValue </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#a4337018b441a5b47fac20603d8abcd27">◆ </a></span>nullableDoubleValue() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>boost::optional\< double > & gpudb::GenericRecord::nullableDoubleValue </td>
            <td>(</td>
            <td>const size\_t</td>
            <td><span><span>index</span></span></td>
            <td>)</td>

            <td />
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#ab7c0e0bce24739d9276a56fb7df617fb">◆ </a></span>nullableDoubleValue() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>const boost::optional\< double > & gpudb::GenericRecord::nullableDoubleValue </td>
            <td>(</td>
            <td>const size\_t</td>
            <td><span><span>index</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#a1fb7a1374c40b2863a0d434a3f3a6f82">◆ </a></span>nullableDoubleValue() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>boost::optional\< double > & gpudb::GenericRecord::nullableDoubleValue </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span></td>
            <td>)</td>

            <td />
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#ab6e4d101cdc99a511febce45572be969">◆ </a></span>nullableDoubleValue() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>const boost::optional\< double > & gpudb::GenericRecord::nullableDoubleValue </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#a36806d807a4840ae1dae85f42f8ba36e">◆ </a></span>nullableFloatValue() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>boost::optional\< float > & gpudb::GenericRecord::nullableFloatValue </td>
            <td>(</td>
            <td>const size\_t</td>
            <td><span><span>index</span></span></td>
            <td>)</td>

            <td />
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#a3eba14fa191d810fdc2aaede7751c863">◆ </a></span>nullableFloatValue() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>const boost::optional\< float > & gpudb::GenericRecord::nullableFloatValue </td>
            <td>(</td>
            <td>const size\_t</td>
            <td><span><span>index</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#aaebfc65168cd2717cb9c1dc614fd291b">◆ </a></span>nullableFloatValue() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>boost::optional\< float > & gpudb::GenericRecord::nullableFloatValue </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span></td>
            <td>)</td>

            <td />
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#abae90ccb557729607d534f1f8f47503c">◆ </a></span>nullableFloatValue() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>const boost::optional\< float > & gpudb::GenericRecord::nullableFloatValue </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#a4f4246219da4a89f5033d3ffdde03de7">◆ </a></span>nullableIntValue() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>boost::optional\< int32\_t > & gpudb::GenericRecord::nullableIntValue </td>
            <td>(</td>
            <td>const size\_t</td>
            <td><span><span>index</span></span></td>
            <td>)</td>

            <td />
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#a91b6aa7056d1456ea590b4fd1d8a009d">◆ </a></span>nullableIntValue() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>const boost::optional\< int32\_t > & gpudb::GenericRecord::nullableIntValue </td>
            <td>(</td>
            <td>const size\_t</td>
            <td><span><span>index</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#a37ee3e0d476fc866909170426ba9aebe">◆ </a></span>nullableIntValue() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>boost::optional\< int32\_t > & gpudb::GenericRecord::nullableIntValue </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span></td>
            <td>)</td>

            <td />
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#a5b15c2523e02678cffe2c9de176c1a76">◆ </a></span>nullableIntValue() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>const boost::optional\< int32\_t > & gpudb::GenericRecord::nullableIntValue </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#aa0d3671b834e335c35e5610800401d86">◆ </a></span>nullableLongValue() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>boost::optional\< int64\_t > & gpudb::GenericRecord::nullableLongValue </td>
            <td>(</td>
            <td>const size\_t</td>
            <td><span><span>index</span></span></td>
            <td>)</td>

            <td />
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#aec6e33d13b7811e27dd1c98eed27964b">◆ </a></span>nullableLongValue() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>const boost::optional\< int64\_t > & gpudb::GenericRecord::nullableLongValue </td>
            <td>(</td>
            <td>const size\_t</td>
            <td><span><span>index</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#af8b47f9682c5b3469bf3b679aa0251e3">◆ </a></span>nullableLongValue() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>boost::optional\< int64\_t > & gpudb::GenericRecord::nullableLongValue </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span></td>
            <td>)</td>

            <td />
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#aea33b519e27cb049cc1643e37cb06470">◆ </a></span>nullableLongValue() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>const boost::optional\< int64\_t > & gpudb::GenericRecord::nullableLongValue </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#acd6dc224addd0e38431a92e69d9a649d">◆ </a></span>nullableStringValue() <span>\[1/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>boost::optional\< std::string > & gpudb::GenericRecord::nullableStringValue </td>
            <td>(</td>
            <td>const size\_t</td>
            <td><span><span>index</span></span></td>
            <td>)</td>

            <td />
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#a531b2dbbefa0b6f44f6534fe4e691c7d">◆ </a></span>nullableStringValue() <span>\[2/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>const boost::optional\< std::string > & gpudb::GenericRecord::nullableStringValue </td>
            <td>(</td>
            <td>const size\_t</td>
            <td><span><span>index</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#a2c3e5ec0f49d1fd0ff52d2a6694bc37b">◆ </a></span>nullableStringValue() <span>\[3/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>boost::optional\< std::string > & gpudb::GenericRecord::nullableStringValue </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span></td>
            <td>)</td>

            <td />
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#af1b3c87a4032fb73b45ef31eaa751596">◆ </a></span>nullableStringValue() <span>\[4/4]</span></h2>

    <div>
      <div>
        <table>
          <tr>
            <td>const boost::optional\< std::string > & gpudb::GenericRecord::nullableStringValue </td>
            <td>(</td>
            <td>const std::string &</td>
            <td><span><span>name</span></span></td>
            <td>)</td>
            <td> const</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#a4aca554d87dadd5c2fd4d1f452a21027">◆ </a></span>setAsArray() <span>\[1/2]</span></h2>

    <div>
      <div>
        <div> template\<typename T> </div>

        <table>
          <tr>
            <td>void gpudb::GenericRecord::setAsArray </td>
            <td>(</td>
            <td>const size\_t</td>
            <td><span><span>index</span></span>, </td>
          </tr>

          <tr>
            <td />

            <td />

            <td>const std::vector\< T > &</td>
            <td><span><span>newValue</span></span> )</td>
          </tr>
        </table>
      </div>

      <div />
    </div>

    <h2><span><a href="#a72560893fceca48654266624e89a4446">◆ </a></span>setAsArray() <span>\[2/2]</span></h2>

    <div>
      <div>
        <div> template\<typenam