|VoltDB Operator 1.6.9|
|VoltDB Helm Chart 1.6.9|
July 7, 2022
This document provides information about known issues and limitations to the current release of VoltDB. If you encounter any problems not listed below, please be sure to report them to firstname.lastname@example.org. Thank you.
The process for upgrading from the recent versions of VoltDB is as follows:
Shutdown the database, creating a final snapshot (using voltadmin shutdown --save).
Upgrade the VoltDB software.
Restart the database (using voltdb start).
For Kubernetes, see the section on "Upgrading the VoltDB Software and Helm Charts" in the VoltDB Kubernetes Administrator's Guide. For DR clusters, see the section on "Upgrading VoltDB Software" in the VoltDB Administrator's Guide for special considerations related to DR upgrades. If you are upgrading from versions before V6.8, see the section on "Upgrading Older Versions of VoltDB Manually" in the same manual.
Users of previous versions of VoltDB should take note of the following changes that might impact their existing applications. See the VoltDB Operator Release Notes for changes specific to the use of VoltDB on the Kubernetes platform.
Additional statistics for tracking communication between XDCR clusters
Several additional columns have been added to the first results table for the @Statistics DRPRODUCER selector (and the corresponding Prometheus agent metrics) to help evaluate the time between when binary logs are ready for transmission and when acknowledgement is received from the consumer. The new columns are the following and are reported in milliseconds:
The corresponding metrics in the Prometheus agent are:
The following limitations in previous versions have been resolved:
The following limitations in previous versions have been resolved:
VoltDB Operator and Helm Charts updates
The VoltDB Operator and Helm charts for this release of Volt Active Data have been updated twice:
The following limitation in previous versions has been resolved:
The following limitation in previous versions has been resolved:
This release focuses on improving the management of resources associated with running VoltDB in production. In particular, several new features allow you to set a retention policy for logs, snapshots, and other files created by the database system. Several of these features have new default values to reduce the proliferation of unnecessary files, as well as options to adjust the policy to your business needs.
Retention policy for database log files
VoltDB writes informational, warning, and error messages to log files in a subfolder of the database root directory. By default, the log files "roll", creating a new file and renaming the old ones, on a daily basis. Previously, old log files were never deleted. Starting with this release, the default Log4J configuration file has been revised and now retains up to 30 log files. Older files are deleted. You can customize the configuration to change either or both the number of files retained or how frequently a new file is created. See the section on "Managing VoltDB Log Files" in the VoltDB Administrator's Guide for details.
Note that if you use a customized Log4J configuration, your customization will take precedence and override the new behavior.
Retention policy for snapshots during initiation
By default, snapshots created manually or through periodic snapshots are stored in the
snapshots folder in the database root directory. When you reinitialize the root
directory, using the
Snapshots can be quite large, since they save the entire contents of the database. And previously, VoltDB
saved and renamed all of the extant snapshot folders. To avoid consuming unnecessary disk space, the
voltadmin init --force command now only saves the two most recent snapshot folders by default.
You can specify a different retention value with the
Retention policy for final snapshots
When you shutdown the database with the voltadmin shutdown --save command, a final snapshot is created saving the database contents. Final snapshots are useful, particularly for saving and restoring the database when upgrading the VoltDB software. VoltDB does not delete the final snapshot after it is restored as a safety precaution, in case you decide the restored database has a problem or is not configured correctly. Saving the final snapshot gives you an opportunity to manually restore the database to another location in case of an emergency.
However, once the final snapshot is restored and operational, the snapshot is no longer needed. Consequently, VoltDB now deletes all but the last two final snapshots when you create a new snapshot with the voltadmin shutdown --save command. This is a fixed limit.
Retention policy for XDCR conflict logs
Cross datacenter replication (XDCR) records any conflicts that occur during active-active replication in the XDCR conflict logs. These logs give you the opportunity to review, analyze, and potentially correct any issues that arise from conflicting transactions. However, over time, subsequent transactions will make correcting old conflicts impractical.
How long you need to save the conflict logs is a business decision. Therefore, by default, VoltDB maintains
the old behavior of keeping all conflict logs. (Except in the case of Kubernetes, where a default of 30 days is
applied.) You can specify a retention policy in terms of how long to keep log files by adding the
<dr id="1" role="xdcr" conflictretention="14d" >
The retention period can be specified in seconds, minutes, hours, or days (using the signifier
s, m, h, or
d). Alternately, you can configure the VOLTDB_XDCR_CONFLICTS export connector, which
Retention policy for file export
Similarly to XDCR conflict logs, a retention policy can be applied to the output files of any file export
connector. By default, all output files are retained. However, you can use the
<export> <configuration enabled="true" target="log" type="file"> <property name="retention">14d</property> <property name="type">csv</property> <property name="nonce">MyLogs</property> </configuration> </export>
VoltDB now supports Kubernetes on OpenShift
The VoltDB Operator has added support for running VoltDB databases in Kubernetes on the OpenShift platform from Red Hat. This expands VoltDB's Kubernetes compatibility to three of the major cloud platforms: AWS, Google Cloud, and OpenShift. For those interested in using OpenShift, please be sure to read the operational note later in this document for specific instructions on handling Transparent Huge Pages (THP) on the OpenShift platform.
New Java client method for connecting to a list of potential hosts
The following limitations in previous versions have been resolved:
The following limitation in previous versions has been resolved:
New Java client API, Client2 (BETA)
VoltDB V11.1 includes the Beta release of a new Java client library. Client2 provides a modern, robust and extensible interface to VoltDB for client applications written in Java. For example, Client2 uses Completable Futures to return information from asynchronous procedure calls, providing a more structured way of handling both successful and unsuccessful calls. The new API will also be the main platform for new client development in the future, starting with the ability to assign a priority for individual requests. Client-side priority queuing is available in the beta release and allows the client to prioritize certain procedure calls over others. See the javadoc for details.
As with all beta releases, the new capabilities are believed to work as described. However, further testing and customer feedback is required before we can recommend its use for production. We encourage you to try the new client interface and provide feedback to email@example.com. Thank you.
New Helm plugin, voltadmin (BETA)
Helm and the VoltDB Operator make configuring and running VoltDB in Kubernetes easier. However, there are certain management operations that are awkward to perform using Helm properties alone. VoltDB provides a new Helm plugin, now in Beta release, to simplify these additional VoltDB management tasks.
The Helm voltadmin plugin provides commands, similar to regular voltadmin commands, to perform management activities on a running cluster. For its initial release the Helm voltadmin plugin supports the following commands:
Additional commands will be added in future releases. Once installed, you use the plugin on the Helm command
line by specifying the plugin name (voltadmin), the name of the Helm release with the
$ helm voltadmin --release=mydb dr reset --cluster=1
You can install the beta release of the voltadmin plugin with the following command:
$ helm plugin install https://storage.googleapis.com/voltdb-kubernetes-charts/voltadmin-1.4.0-beta.tgz
New --credentials argument added to Prometheus agent
The Prometheus agent for VoltDB has a new argument available when starting the agent from the shell command.
$ cat $HOME/mycreds.txt username: admin password: mySpecialPassword $ ./voltdb/tools/monitoring/prometheus/voltdb-prometheus \ --credentials $HOME/mycreds.txt
Support for reporting incremental statistics in Prometheus
By default, the VoltDB Prometheus agent reports statistics for all time — since the database started.
You can now tell the agent to report statistics in increments, so that each timestamp reports on activity since the
last data was reported. For example, if data is collected every 10 seconds, the statistics for transactions per
second is the average TPS over the last 10 seconds, rather than the average since the server started. To report
incremental statistics, set the Helm property
$ ./voltdb/tools/monitoring/prometheus/voltdb-prometheus --delta
Ability to set DSCP priority for DR network traffic
VoltDB now lets you set a DSCP priority level for network packets associated with database replication (DR) by defining the environment variable DD_SOCKET_TRAFFIC_CLASS to the DSCP value you wish to use prior to starting the VoltDB process. For example, The following commands start the VoltDB server with the DR network traffic DSCP priority set to 3:
$ export VOLTDB_OPTS="-DDR_SOCKET_TRAFFIC_CLASS=3" $ voltdb start -D ~/mydb
For Kubernetes, the value can be set using the helm property
Support for Kubernetes 1.21
The latest VoltDB Operator and Helm charts add support for Kubernetes up to version 1.21. The officially supported versions are Kubernetes 1.16.2 through 1.21.x.
The following limitations in previous versions have been resolved:
VoltDB 11 is a major release incorporating features from recent updates plus new capabilities. It includes the following major new features and improvements.
VoltDB Topics provide the intelligent streaming of VoltDB's existing import and export capabilities, but with the flexibility of Kafka-like streams. Topics allow for both inbound and outbound streaming to multiple client producers and consumers. They also use the existing Kafka interface to simplify integration into existing infrastructure. But most importantly, they allow for intelligent processing and manipulation of the data as it passes through the pipeline.
Support for Python 3.6
The VoltDB command line tools have been upgraded to use Python version 3. Python 3 is commonly available on modern operating systems and so simplifies the process of configuring platforms for VoltDB.
New Kubernetes capabilities
Upgrades to the VoltDB Operator for Kubernetes provide two important new features:
VoltDB Java Client improvements
The VoltDB Java client interface has been updated with the following improvements:
The VoltDB Management Center (VMC) web-based console for VoltDB has been updated to the latest versions of the jQuery libraries to address security vulnerabilities. The current library versions for VMC are JQuery v3.5.1 and jQuery-UI v1.12.1.
The following are known limitations to the current release of VoltDB. Workarounds are suggested where applicable. However, it is important to note that these limitations are considered temporary and are likely to be corrected in future releases of the product.
Do not use the subfolder name "segments" for the command log snapshot directory.
VoltDB reserves the subfolder "segments" under the command log directory for storing the actual command log files. Do not add, remove, or modify any files in this directory. In particular, do not set the command log snapshot directory to a subfolder "segments" of the command log directory, or else the server will hang on startup.
Some DR data may not be delivered if master database nodes fail and rejoin in rapid succession.
Because DR data is buffered on the master database and then delivered asynchronously to the replica, there is always the danger that data does not reach the replica if a master node stops. This situation is mitigated in a K-safe environment by all copies of a partition buffering on the master cluster. Then if a sending node goes down, another node on the master database can take over sending logs to the replica. However, if multiple nodes go down and rejoin in rapid succession, it is possible that some buffered DR data — from transactions when one or more nodes were down — could be lost when another node with the last copy of that buffer also goes down.
If this occurs and the replica recognizes that some binary logs are missing, DR stops and must be restarted.
To avoid this situation, especially when cycling through nodes for maintenance purposes, the key is to ensure that all buffered DR data is transmitted before stopping the next node in the cycle. You can do this using the @Statistics system procedure to make sure the last ACKed timestamp (using @Statistitcs DR on the master cluster) is later than the timestamp when the previous node completed its rejoin operation.
Avoid bulk data operations within a single transaction when using database replication
Bulk operations, such as large deletes, inserts, or updates are possible within a single stored procedure. However, if the binary logs generated for DR are larger than 45MB, the operation will fail. To avoid this situation, it is best to break up large bulk operations into multiple, smaller transactions. A general rule of thumb is to multiply the size of the table schema by the number of affected rows. For deletes and inserts, this value should be under 45MB to avoid exceeding the DR binary log size limit. For updates, this number should be under 22.5MB (because the binary log contains both the starting and ending row values for updates).
Database replication ignores resource limits
There are a number of VoltDB features that help manage the database by constraining memory size and resource utilization. These features are extremely useful in avoiding crashes as a result of unexpected or unconstrained growth. However, these features could interfere with the normal operation of DR when passing data from one cluster to another, especially if the two clusters are different sizes. Therefore, as a general rule of thumb, DR overrides these features in favor of maintaining synchronization between the two clusters.
Specifically, DR ignores any resource monitor limits defined in the deployment file when applying binary logs on the consumer cluster. This means, for example, if the replica database in passive DR has less memory or fewer unique partitions than the master, it is possible that applying binary logs of transactions that succeeded on the master could cause the replica to run out of memory. Note that these resource monitor limits are applied on any original transactions local to the cluster (for example, transactions on the master database in passive DR).
Different cluster sizes can require additional Java heap
Database Replication (DR) now supports replication across clusters of different sizes. However, if the replica cluster is smaller than the master cluster, it may require a significantly larger Java heap setting. Specifically, if the replica has fewer unique partitions than the master, each partition on the replica must manage the incoming binary logs from more partitions on the master, which places additional pressure on the Java heap.
A simple rule of thumb is that the worst case scenario could require an additional P * R * 20MB space in the Java heap , where P is the number of sites per host on the replica server and R is the ratio of unique partitions on the master to partitions on the replica. For example, if the master cluster is 5 nodes with 10 sites per host and a K factor of 1 (i.e. 25 unique partitions) and the replica cluster is 3 nodes with 8 sites per host and a K factor of 1 (12 unique partitions), the Java heap on the replica cluster may require approximately 320MB of additional space in the heap:
Sites-per-host * master/replace ratio * 20MB
An alternative is to reduce the size of the DR buffers on the master cluster by setting the DR_MEM_LIMIT Java property. For example, you can reduce the DR buffer size from the default 10MB to 5MB using the VOLTDB_OPTS environment variable before starting the master cluster.
$ export VOLTDB_OPTS="-DDR_MEM_LIMIT=5"
$ voltdb start
Changing the DR buffer limit on the master from 10MB to 5MB proportionally reduces the additional heap size needed. So in the previous example, the additional heap on the replica is reduced from 320MB to 160MB.
The voltadmin status --dr command does not work if clusters use different client ports
The voltadmin status --dr command provides real-time status on the state of database replication (DR). Normally, this includes the status of the current cluster as well as other clusters in the DR environment. (For example, both the master and replica in passive DR or all clusters in XDCR.) However, if the clusters are configured to use different port numbers for the client port, VoltDB cannot reach the other clusters and the command hangs until it times out waiting for a response from the other clusters.
Avoid replicating tables without a unique index.
Part of the replication process for XDCR is to verify that the record's starting and ending states match on both clusters, otherwise known as conflict resolution. To do that, XDCR must find the record first. Finding uniquely indexed records is efficient; finding non-unique records is not and can impact overall database performance.
To make you aware of possible performance impact, VoltDB issues a warning if you declare a table as a DR table and it does not have a unique index.
When starting XDCR for the first time, only one database can contain data.
You cannot start XDCR if both databases already have data in the DR tables. Only one of the two participating databases can have preexisting data when DR starts for the first time.
During the initial synchronization of existing data, the receiving database is paused.
When starting XDCR for the first time, where one database already contains data, a snapshot of that data is sent to the other database. While receiving and processing that snapshot, the receiving database is paused. That is, it is in read-only mode. Once the snapshot is completed and the two database are synchronized, the receiving database is automatically unpaused, resuming normal read/write operations.
A large number of multi-partition write transactions may interfere with the ability to restart XDCR after a cluster stops and recovers.
Normally, XDCR will automatically restart where it left off after one of the clusters stops and recovers from its command logs (using the voltdb recover command). However, if the workload is predominantly multi-partition write transactions, a failed cluster may not be able to restart XDCR after it recovers. In this case, XDCR must be restarted from scratch, using the content from one of the clusters as the source for synchronizing and recreating the other cluster (using the voltdb create --force command) without any content in the DR tables.
Avoid using TRUNCATE TABLE in XDCR environments.
TRUNCATE TABLE is optimized to delete all data from a table rather than deleting tuples row by row. This means that the binary log does not identify which rows are deleted. As a consequence, a TRUNCATE TABLE statement and a simultaneous write operation to the same table can produce a conflict that the XDCR clusters cannot detect or report in the conflict log.
Therefore, do not use TRUNCATE TABLE with XDCR. Instead, explicitly delete all rows with a DELETE statement
and a filter. For example,
Use of the VoltProcedure.getUniqueId method is unique to a cluster, not across clusters.
VoltDB provides a way to generate a deterministically unique ID within a stored procedure using the getUniqueId method. This method guarantees uniqueness within the current cluster. However, the method could generate the same ID on two distinct database clusters. Consequently, when using XDCR, you should combine the return values of VoltProcedure.getUniqueId with VoltProcedure.getClusterId, which returns the current cluster's unique DR ID, to generate IDs that are unique across all clusters in your environment.
Multi-cluster XDCR environments require command logging.
In an XDCR environment involving three or more clusters, command logging is used to ensure the durability of the XDCR "conversations" between clusters. If not, when a cluster stops, the remaining clusters can be at different stages of their conversation with the downed cluster, resulting in divergence.
For example, assume there are three clusters (A, B, and C) and cluster B is processing binary logs faster than cluster C. If cluster A stops, cluster B will have more binary logs from A than C has. You can think of B being "ahead" of C. With command logging enabled, when cluster A restarts, it will continue its XDCR conversations and cluster C will catch up with the missing binary logs. However, without command logging, when A stops, it must restart from scratch. There is no mechanism for resolving the difference in binary logs processed by clusters B and C before the failure.
This is why command logging is required to ensure the durability of XDCR conversations in a multi-cluster (that is , three or more) XDCR environment. The alternative, if not using command logging, is to restart all but one of the remaining clusters to ensure they are starting from the same base point.
Do not use voltadmin dr reset to remove an XDCR cluster that is still running
There are two ways to remove an cluster from an XDCR relationship: you can use voltadmin drop on a running cluster to remove it from the XDCR network, or you can use voltadmin dr reset from the remaining clusters to remove a cluster that is no longer available. But you should not use voltadmin dr reset to remove a cluster that is still running and connected to the network. Resetting a running cluster will break DR for that cluster, but will result in errors on the remaining clusters and leave their DR queues for the reset cluster in an ambiguous state. Ultimately, this can result in the removed cluster not being able to rejoin the XDCR network at a later time.
Use of TTL (time to live) with replicated tables and Database Replication (DR) can result in increased DR activity.
TTL, or time to live, is a feature that automatically deletes old records based on a timestamp or integer column. For replicated tables, the process of checking whether records need to be deleted is performed as a write transaction — even if no rows are deleted. As a consequence, any replicated DR table with TTL defined will generate frequent DR log entries, whether there are any changes or not, significantly increasing DR traffic.
Because of the possible performance impact this behavior can have on the database, use of TTL with replicated tables and DR is not recommended at this time.
Synchronous export in Kafka can use up all available file descriptors and crash the database.
A bug in the Apache Kafka client can result in file descriptors being allocated but not released if the producer.type attribute is set to "sync" (which is the default). The consequence is that the system eventually runs out of file descriptors and the VoltDB server process will crash.
Until this bug is fixed, use of synchronous Kafka export is not recommended. The workaround is to set the Kafka producer.type attribute to "async" using the VoltDB export properties.
Data may be lost if a Kafka broker stops during import.
If, while Kafka import is enabled, the Kafka broker that VoltDB is connected to stops (for example, if the server crashes or is taken down for maintenance), some messages may be lost between Kafka and VoltDB. To ensure no data is lost, we recommend you disable VoltDB import before taking down the associated Kafka broker. You can then re-enable import after the Kafka broker comes back online.
Kafka import can lose data if multiple nodes stop in succession.
There is an issue with the Kafka importer where, if multiple nodes in the cluster fail and restart, the importer can lose track of some of the data that was being processed when the nodes failed. Normally, these pending imports are replayed properly on restart. But if multiple nodes fail, it is possible for some in-flight imports to get lost. This issue will be addressed in an upcoming release.
Comments containing unmatched single quotes in multi-line statements can produce unexpected results.
When entering a multi-line statement at the sqlcmd prompt, if a line ends in a comment (indicated by two hyphens) and the comment contains an unmatched single quote character, the following lines of input are not interpreted correctly. Specifically, the comment is incorrectly interpreted as continuing until the next single quote character or a closing semi-colon is read. This is most likely to happen when reading in a schema file containing comments. This issue is specific to the sqlcmd utility.
A fix for this condition is planned for an upcoming point release
Do not use assertions in VoltDB stored procedures.
VoltDB currently intercepts assertions as part of its handling of stored procedures. Attempts to use assertions in stored procedures for debugging or to find programmatic errors will not work as expected.
The UPPER() and LOWER() functions currently convert ASCII characters only.
The UPPER() and LOWER() functions return a string converted to all uppercase or all lowercase letters, respectively. However, for the initial release, these functions only operate on characters in the ASCII character set. Other case-sensitive UTF-8 characters in the string are returned unchanged. Support for all case-sensitive UTF-8 characters will be included in a future release.
Avoid using decimal datatypes with the C++ client interface on 32-bit platforms.
There is a problem with how the math library used to build the C++ client library handles large decimal values on 32-bit operating systems. As a result, the C++ library cannot serialize and pass Decimal datatypes reliably on these systems.
Note that the C++ client interface can send and receive Decimal values properly on 64-bit platforms.
Enabling SNMP traps can slow down database startup.
Enabling SNMP can take up to 2 minutes to complete. This delay does not always occur and can vary in length. If SNMP is enabled when the database server starts, the delay occurs after the server logs the message "Initializing SNMP" and before it attempts to connect to the cluster. If you enable SNMP while the database is running, the delay can occur when you issue the voltadmin update command or modify the setting in the VoltDB Management Center Admin tab. This issue results from a Java constraint related to secure random numbers used by the SNMP library.
The VoltDB Management Center currently reports on only one DR connection.
With VoltDB V7.0, cross datacenter replication (XDCR) supports multiple clusters in an XDCR network. However, the VoltDB Management Center currently reports on only one such connection per cluster. In the future, the Management Center will provide monitoring and statistics for all connections to the current cluster.
Shutting down a VoltDB cluster by setting
Shutting down a VoltDB cluster by specifying a replica count of zero should shut down the cluster and remove the pods on which it ran. However, on very rare occasions Kubernetes does not delete the pods. As a result, the cluster cannot be restarted. This is an issue with Kubernetes. The workaround is to manually delete the pods before restarting the cluster.
Specifying invalid or misconfigured volumes in
Using binary data with the Helm --set-file argument can cause problems when later upgrading the cluster.
This is a known issue for Kubernetes and Helm. The workaround is either to explicitly include the
The following notes provide details concerning how certain VoltDB features operate. The behavior is not considered incorrect. However, this information can be important when using specific components of the VoltDB product.
Support for IPv6 addresses
VoltDB works in IPv4, IPv6, and mixed network environments. Although the examples in the documentation use IPv4 addresses, you can use IPv6 when configuring your database, making connections through applications, or using the VoltDB command line utilities, such as voltdb and voltadmin. When specifying IPv6 addresses on the command line or in the configuration file, be sure to enclose the address in square brackets. If you are specifying both an IPv6 address and port number, put the colon and port number after the square brackets. For example:
voltadmin status --host=[2001:db8:85a3::8a2e:370:7334]:21211
Schema updates clear the stored procedure data table in the Management Center Monitor section
Any time the database schema or stored procedures are changed, the data table showing stored procedure statistics at the bottom of the Monitor section of the VoltDB Management Center get reset. As soon as new invocations of the stored procedures occur, the statistics table will show new values based on performance after the schema update. Until invocations occur, the procedure table is blank.
You cannot partition a table on a column defined as ASSUMEUNIQUE.
The ASSUMEUNIQUE attribute is designed for identifying columns in partitioned tables where the column values are known to be unique but the table is not partitioned on that column, so VoltDB cannot verify complete uniqueness across the database. Using interactive DDL, you can create a table with a column marked as ASSUMEUNIQUE, but if you try to partition the table on the ASSUMEUNIQUE column, you receive an error. The solution is to drop and add the column using the UNIQUE attribute instead of ASSUMEUNIQUE.
Adding or dropping column constraints (UNIQUE or ASSUMEUNIQUE) is not supported by the ALTER TABLE ALTER COLUMN statement.
You cannot add or remove a column constraint such as UNIQUE or ASSUMEUNIQUE using the ALTER TABLE ALTER COLUMN statement. Instead to add or remove such constraints, you must first drop then add the modified column. For example:
ALTER TABLE employee DROP COLUMN empID; ALTER TABLE employee ADD COLUMN empID INTEGER UNIQUE;
Do not use UPDATE to change the value of a partitioning column
For partitioned tables, the value of the column used to partition the table determines what partition the row belongs to. If you use UPDATE to change this value and the new value belongs in a different partition, the UPDATE request will fail and the stored procedure will be rolled back.
Updating the partition column value may or may not cause the record to be repartitioned (depending on the old and new values). However, since you cannot determine if the update will succeed or fail, you should not use UPDATE to change the value of partitioning columns.
The workaround, if you must change the value of the partitioning column, is to use both a DELETE and an INSERT statement to explicitly remove and then re-insert the desired rows.
Ambiguous column references no longer allowed.
Starting with VoltDB 6.0, ambiguous column references are no longer allowed. For example, if both the Customer and Placedorder tables have a column named Address, the reference to Address in the following SELECT statement is ambiguous:
SELECT OrderNumber, Address FROM Customer, Placedorder . . .
Previously, VoltDB would select the column from the leftmost table (Customer, in this case). Ambiguous column references are no longer allowed and you must use table prefixes to disambiguate identical column names. For example, specifying the column in the preceding statement as Customer.Address.
A corollary to this change is that a column declared in a USING clause can now be referenced using a prefix. For example, the following statement uses the prefix Customer.Address to disambiguate the column selection from a possibly similarly named column belonging to the Supplier table:
SELECT OrderNumber, Vendor, Customer.Address FROM Customer, Placedorder Using (Address), Supplier . . .
File Descriptor Limits
VoltDB opens a file descriptor for every client connection to the database. In normal operation, this use of file descriptors is transparent to the user. However, if there are an inordinate number of concurrent client connections, or clients open and close many connections in rapid succession, it is possible for VoltDB to exceed the process limit on file descriptors. When this happens, new connections may be rejected or other disk-based activities (such as snapshotting) may be disrupted.
In environments where there are likely to be an extremely large number of connections, you should consider increasing the operating system's per-process limit on file descriptors.
Use of Resources in JAR Files
There are two ways to access additional resources in a VoltDB database. You can place the resources in the
LOAD CLASSES is used primarily to load classes associated with stored procedures and user-defined functions. However, it will also load any additional resource files included in subfolders of the JAR file. You can remove classes that are no longer needed using the REMOVE CLASSES directive. However, there is no explicit command for removing other resources.
Consequently, if you rename resources or move them to a different location and reload the JAR file, the database will end up having multiple copies. Over time, this could result in more and more unnecessary memory being used by the database. To remove obsolete resources, you must first reinitialize the database root directory, start a fresh database, reload the schema (including the new JAR files with only the needed resources) and then restore the data from a snapshot.
Servers with Multiple Network Interfaces
If a server has multiple network interfaces (and therefore multiple IP addresses) VoltDB will, by default, open ports on all available interfaces. You can limit the ports to an single interface in two ways:
Also, when using an IP address to reference a server with multiple interfaces in command line utilities (such as voltadmin stop node), use the @SystemInformation system procedure to determine which IP address VoltDB has selected to identify the server. Otherwise, if you choose the wrong IP address, the command might fail.
OpenShift and Transparent Huge Pages (THP)
For production, VoltDB requires that Transparent Huge Pages (THP) are disabled because they interfere with memory-intensive applications. However, THP may be enabled on OpenShift containers and the containers themselves not have permission to disable them. To overcome this situation, you must run the Helm chart for disabling THP from a privileged container:
$ helm -n kube-system install thp voltdb/transparent-hugepages \ --set thp.securityContext.privileged=true
The following table describes the compatibility matrix for versions of the VoltDB software, VoltDB Kubernetes Operator, and associated Helm Charts. The table identifies the versions of the Operator and Helm chart required and supported for running the specified version of the VoltDB server software. See the VoltDB Operator Release Notes for additional information about individual releases of the VoltDB Operator.
Table 1. Kubernetes Software Compatibility Chart