The VoltDB plugin for the New Relic monitoring application has been updated and enhanced. See the README in the tools/moniotring/newrelic folder where the VoltDB Enterprise Edition software is installed for details.

In VoltDB 8.4 and 8.4.1, a component of the Kubernetes support was missing from the kit. As a consequence, the readiness probe did not operate as expected. This issue has been resolved.

Support for running VoltDB in Kubernetes, and in particular resilience during cluster startup and XDCR durability, has been improved in several ways. These changes improve the reliability of XDCR in Kubernetes environments and especially environments using glusterfs. However, these changes are equally applicable to other environments where node stability is questionable during startup. Specific improvements include:

The following limitations in previous versions have been resolved:

A number of improvements have been made to export in VoltDB. In particular three areas have been addressed:

There is a new interactive command line utility, voltsql, for accessing VoltDB databases that performs the same functions as sqlcmd but adds command completion to simplify entry of SQL commands. As you type, voltsql lists possible keywords, validating the syntax and reducing the typing required. The new utility is a preview release and does require a few additional Python libraries. See the description of voltsql in the Using VoltDB manual for details.

The new ROW_NUMBER() window function provides the ordinal position of the current row in the group defined by the PARTITION BY clause. See the description of window functions for the SELECT statement in the Using VoltDB manual for details.

TRUNCATE TABLE is intended to efficiently delete all tuples in the specified database table. However, previously it was possible to execute a TRUNCATE TABLE statement in a single-partitioned procedure, resulting in only the tuples from that partition being deleted. To avoid this indeterminate behavior, TRUNCATE TABLE is no longer permitted in a single-partitioned stored procedure.

You no longer need to include COUNT(*) as an explicit column in a view of a single table. For example, if you want a view of the maximum population, by state, of the table City, the CREATE VIEW statement might look like this:

CREATE VIEW maxbystate (state, population)
   AS SELECT state, MAX(population) FROM city
      GROUP BY state;

The COUNT(*) column is still required for views that join multiple tables. See the description of CREATE VIEW in the Using VoltDB manual for details.

The USING TTL clause to the CREATE TABLE statement now supports two additional arguments: BATCH_SIZE and MAX_FREQUENCY. These arguments let you adjust how many records are deleted in each cycle and how frequently the process checks for outdated records. These values can be set per table. See the documentation of CREATE TABLE in the Using VoltDB manual for details.

The voltadmin stop command has been enhanced to perform an orderly stoppage of the specified node. Previously, the stop command simply stopped the server process on the node. Now, the command migrates all partition and export leadership before stopping the node. This avoids a number of problems:

You can still force the command to stop the node immediately if necessary by adding the --force argument. See the description of voltadmin in the Using VoltDB manual for details.

The VoltDB documentation now includes an online quick reference guide that lists the syntax for SQL statements, DDL, SQL functions, command line utilities and system procedures. Each item contains a link to its full documentation. Give it a try and tell us what you think.

VoltDB no longer supports use of Java 7 in client applications. The supported version of Java for VoltDB servers and clients is version 8.

VoltDB now supports Ubuntu 18.04 as a server operating system. Officially supported platforms for VoltDB servers currently are CentOS 6.6, CentOS 7.0, RHEL 6.6, RHEL 7.0, and Ubuntu 14.04, 16.04 and 18.04. See the section on in "Operating System and Software Requirements" the Using VoltDB manual for details.

The VoltDB Community Edition Jar file is now available for distribution through the Maven central repository.

The following change has been made to improve security and eliminate potential threats:

In addition to the new features and capabilities described above, the following limitations in previous versions have been resolved:

The scripts that support running VoltDB in a Kubernetes environment have been rewritten to use ConfigMaps for storing configuration, schema, and stored procedure classes, separating this information from the Docker image. It is now possible to reuse a single Docker image in multiple configurations. See the readme in the /tools/kubernetes directory where VoltDB is installed for details.

The following limitation in previous versions has been resolved:

A new command line option for the voltdb start command, --drpublic, lets you specify an alternate interface and (optionally) port, which the server then reports to database replication (DR) consumer clusters. This feature is helpful for cloud environments where the internal interfaces are not accessible from outside the hosted region, so the other DR clusters must use redirected interfaces and ports. Specify the public interface as an IP address or host name followed by an optional colon and port number. If you do not specify a port number, the publicly advertised port number is the same as the value for the internal --replication port. For example:

$ voltdb start --drpublic=some.external.addr

The following limitations in previous versions have been resolved:

The following limitations in previous versions have been resolved:

In a K-safe cluster, individual nodes are assigned as leaders for each unique partition and coordinate executing transactions for that partition on any copies within the cluster. If a node fails, leadership can be reassigned to one of the remaining nodes. If multiple nodes fail, this means leadership for all partitions could end up congregating on only a few nodes. Previously, leadership was not redistributed when nodes rejoined the cluster.

Now the cluster rebalances leadership of the partitions when the cluster returns to its full complement of nodes. That is, as soon as all of the failed nodes complete the rejoin process.

There is a new clause available for SQL statements such as SELECT. The STARTS WITH clause does text comparisons that are equivalent to LIKE with a text string ending in a percent sign (%). That is, it matches string values starting with the specified argument. STARTS WITH is beneficial in compiled statements (such as stored procedures) because the clause STARTS WITH ? can use indexes on the column being evaluated, whereas an equivalent LIKE ? clause cannot. See the description of the STARTS WITH clause in the SELECT statement in the Using VoltDB manual for details.

TIMESTAMP values are stored and expressed in Greenwich Mean Time (GMT). The new SQL function FORMAT_TIMESTAMP() lets you convert such values to a formatted text string in time zones other than GMT. See the description of FORMAT_TIMESTAMP() in the Using VoltDB manual for details.

The voltadmin restore command now supports the --tables and --skiptables arguments that let you either include or exclude data from specific tables when restoring a snapshot. Note that, for an empty database, all of the tables in the snapshot schema are created. The --tables and --skiptables arguments only control whether data is restored or not for the specified tables. See the description of the voltadmin utility in the Using VoltDB manual for details.

The DRPRODUCER selector for the @Statistics system procedure now has an additional field. The CONNECTION_STATUS column in the first VoltTable results tells you whether the connection to the consumer cluster is active ("UP") or the connection is broken ("DOWN"). See the description of the DRPRODUCER return values in the Using VoltDB manual for details.

Previously, the VoltDB callProcedure method accepted strings or byte arrays as input to VARBINARY columns. Now you can also use ByteBuffer as an input datatype.

The following change has been made to improve security and eliminate potential threats:

In addition to the new features and capabilities described above, the following limitations in previous versions have been resolved:

The following limitations in previous versions have been resolved:

The software kit now includes support for running VoltDB under Kubernetes and Docker. See the read me file in the tools/kubernetes/ folder where VoltDB is installed, or the documentation (available as HTML and PDF).

The following limitations in previous versions have been resolved:

A new feature, "time to live" (TTL), allows you to define an expiration timestamp for individual tables. Once the TTL value is exceeded, the records from that table are automatically deleted from the database. This makes the processing of streaming data easier by automating the deletion of old data.

You define the expiration timestamp with the new USING TTL {value} ON COLUMN {column-name} clause in the CREATE TABLE statement. You can also monitor the performance of TTL processing using the new TTL selector for the @Statistics system procedure. See the documentation of CREATE TABLE and @Statistics in the Using VoltDB manual for details.

When using scripts to manage a secure database, the command line utilities (such as sqlcmd and voltadmin) require a username and password. Previously, there was no easy way to do this without either using Kerberos or hardcoding the information into the script itself. Now you can save the username and password into a properties file — accessible only to the user running the script — and then reference that file in the script using the new --credentials argument. See the description of the command line utilities in the Using VoltDB manual for details.

The file export connector writes export data to files on each server in a cluster. By default, the files are unique per server, but not necessarily across the cluster as a whole. You can now set the property uniquenames to true in the export configuration to ensure that all files are unique cluster wide. See the description of the file export connector in the Using VoltDB manual for details.

Restoring the database from a snapshot can take time, particularly for large databases with many views. This release improves the performance of snapshots by storing the contents of certain views as part of the snapshot, eliminating the need to rebuild the views on the fly when restoring the snapshot. Note that not all views can be saved in the snapshot; views containing partitioned tables but no partitioning column in the GROUP BY clause must still be rebuilt. Also, snapshots created on earlier versions of VoltDB will still have their views rebuilt as part of the restoration process. But for new snapshots with views of replicated tables or partitioned tables with at least one partitioning column in the GROUP BY column, restoring the snapshots should be noticeably faster.

The sqlcmd utility now supports the DESCRIBE table-name directive. DESCRIBE lists the columns of the specified table, stream, or view and related information, such as datatype and size. See the description of sqlcmd in the Using VoltDB manual for details.

The following change has been made to improve security and eliminate potential threats:

In addition to the new features and capabilities described above, the following limitations in previous versions have been resolved:

The following limitation in V8.1 has been resolved:

The following limitation in V8.1 has been resolved:

VoltDB now does a better job of managing the interaction of export and ongoing schema changes. Previously, export associated with the original schema had to drain before export using the new schema could begin. Now export from before and after a schema change are managed independently and in parallel.

The storage of replicated tables has been reorganized in this release. Previously, each partition retained a copy of the replicated tables. Now, all of the partitions on a server share a single copy of the tables. Applications with sizeable replicated tables or a high sites-per-host count should notice a significant reduction in the amount of memory required by VoltDB after the upgrade.

The default process for bulk loading replicated tables — either through the loader utilities such as csvloader or through the bulkloader API — has been improved. When bulk loading data into a replicated table using the default load procedure and performing inserts (not upserts), the load process can be as much as three times faster, according to testing.

There is a limit (50 megabytes) to the amount of data any query can return. When reading large volumes of data from a VoltDB database, use of the LIMIT and OFFSET clauses to "page" though the data is recommended. However, as the OFFSET value increases significantly, each query can take incrementally longer to execute. This release introduces a new feature where, if there is an index on the appropriate columns of the table, the query is optimized eliminating the penalty associated with large offsets.

Ad hoc queries that perform read-only operations on replicated (non-partitioned) tables have traditionally been executed by a single partition within the database, assuming such queries are a small percentage of the overall workload. However, when they are not a small percentage, that one partition can get over extended, resulting in increased latency. This release changes the execution model to "round robin" read-only queries of replicated tables to more evenly distribute the workload.

A new procedure has been added to the list of supported system procedures for VoltDB, @Ping. It returns a value of zero (0) if the database is up and operational. The @Ping system procedure is a lightweight procedure and does not require any interaction between cluster nodes, which makes it a better choice than other system procedures (such as @Statistics) if all you need to do is check if the database is running. See the description of @Ping in the Using VoltDB manual for details.

In addition to the new features and capabilities described above, the following limitations in previous versions have been resolved:

VoltDB now supports encrypting communication on the internal port, the port used for communication between nodes in the cluster, using TLS/SSL encryption. Note that encrypting the internal port automatically adds latency to any operations that require inter-node communication, such as K-safety and multi-partition procedures. The actual impact depends on the configuration and application workload. It is strongly recommended you benchmark your application before enabling internal TLS/SSL on production systems. See the chapter on "Security" in the Using VoltDB manual for details.

Placement groups, or rack-aware provisioning, was introduced in VoltDB 5.5. Placement groups let you specify where each node is located, so in a virtualized K-safe environment multiple copies of a partition are distributed onto distinct hardware, racks, etc. However, changes in VoltDB 7.0 to optimize K-safe partitioning in all cases ended up superceding placement groups and invalidating the rack-aware positioning.

This unintentional side effect has been corrected and placement groups once again provide rack-aware provisioning. However, the algorithm for interpreting placement groups has changed. Where before you could use a hierarchical list of names separated by periods (such as rack1.switch3.server5) the new algorithm focuses on the first name only and subnames are largely ignored.

Use of simple (non-hierarchical) placement names is recommended. In addition, the following rules apply to the top-level names:

The default for the Kafka import connector and the kafkaloader command line utility has changed to support Kafka 0.10.2 and later, including the recent 1.0.0 release. Earlier versions of Kafka (0.8.2) are still supported through configuration options and an alternate kafkaloader8 utility.

VoltDB now supports common table expressions, including recursive common table expressions. See the description of the SELECT statement in the Using VoltDB manual for details.

The following features, that had previously been deprecated, have now been removed from the product as of VoltDB 8.0:

We are also deprecating the VoltDB Deployment Manager.

The VoltDB Deployment Manager was designed as a console for deploying VoltDB clusters. However, it has not met its goals for ease-of-use and flexibility. Therefore, we are deprecating it and it will be removed from the product in a future release. In its place we recommend using one of the existing frameworks for managing distributed systems such as (but not limited to) Chef, Puppet, Docker, and Kubernetes.

The following changes have been made to improve security and eliminate potential threats:

In addition to the new features and capabilities described above, the following limitations in previous versions have been resolved:

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.

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.

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).

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. DR also ignores any partition row limits defined in the database schema when applying binary logs. 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 and tables row limits are applied on any original transactions local to the cluster (for example, transactions on the master database in passive DR).

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:

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.

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.

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.

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.

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.

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.

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, DELETE * FROM table WHERE column=column ensures all deleted rows are identified in the binary log and any conflicts are accurately reported. Note that DELETE FROM table without a WHERE clause is not sufficient, since its execution plan is optimized to equate to TRUNCATE TABLE.

It is possible to place a limit on the number of rows that any partition can hold for a specific table using the LIMIT PARTITION ROWS clause of the CREATE TABLE statement. When close to the limit, transactions on either or both clusters can exceed the limit simultaneously, resulting in a potentially large number of delete operations that then generate conflicts when the the associated binary log reaches the other cluster.

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.

You cannot use cross datacenter replication (XDCR) with the deprecated export syntax, that is the EXPORT TABLE statement. To use XDCR with export, you must use the current CREATE STREAM syntax for declaring the source streams for export targets.

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.

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.

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.

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.

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

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 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.

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 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.

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.

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.

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.

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;

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.

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
    . . .

VoltDB uses the export overflow directory on disk to queue pending export data before it is sent and acknowledged by the export target. Some of this data is retained, even after the queue is flushed, to ensure durability across database sessions. Up to 64MB may be retained per stream, per partition for this purpose. You should take this disk space requirement into consideration when configuring a database with multiple export streams.

Note that because some data is retained for durability purposes after it is written, you cannot use disk usage of this directory as an indicator of whether export is drained or not. Use the @Statistics system procedure with the EXPORT selector to determine the current state of the export streams.

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.

There are two ways to access additional resources in a VoltDB database. You can place the resources in the /lib folder where VoltDB is installed on each server in the cluster or you can include the resource in a subfolder of a JAR file you add using the sqlcmd LOAD CLASSES directive. Adding resources via the /lib directory is useful for stable resources (such as third-party software libraries) that do not require updating. Including resources (such as XML files) in the JAR file is useful for resources that may need to be updated, as a single transaction, while the database is running.

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.

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.