Pivotal GemFire XD 1.0 Release Notes

Pivotal GemFire XD 1.0 | 14 APR 2014

Last Document Update: 14 MAY 2014

All GemFire XD Documentation

What's in the Release Notes

The release notes cover the following topics:

What's New in Pivotal GemFire XD 1.0

Pivotal GemFire XD is a memory-optimized, distributed data store that is designed for applications that have demanding scalability and availability requirements. With GemFire XD you can manage data entirely using in-memory tables, or you can persist very large tables to local disk store files or to a Hadoop Distributed File System (HDFS) for big data deployments.

GemFire XD is a new product that builds upon the previous Pivotal SQLFire product. GemFire XD shares many internal features with SQLFire, such as the SQL language extensions, query capabilities, system tables, local disk store persistence, programming APIs, and the gfxd command-line utility.

Note: This release of GemFire XD does not support Windows platforms or ADO.NET clients.

Pivotal GemFire XD 1.0 introduces these new features:

HDFS-Persistance

GemFire XD provides the capability to store partitioned table data in a Hadoop Distributed File System (HDFS). Using HDFS as a persistent store enables you to capture high rates of table updates in HDFS for later processing in Hadoop. Or, you can choose to manage very large tables in GemFire XD--tables much larger than can be managed in memory.

GemFire XD provides two models for persisting GemFire XD table data to HDFS. With HDFS write-only persistence all of the DML operations that are applied to a table are persisted to HDFS log files, with no compaction. HDFS write-only persistence enables applications to collect unbounded volumes of data in parallel for future processing using Hadoop tools such as MapReduce, or Hive. You can also use the GemFire XD PXF driver to access the persisted Hadoop data using HAWQ.

With HDFS read/write persistence, all of the DML operations that are applied to a table are persisted to HDFS log files. GemFire XD periodically compacts the log files into larger files in order to improve read performance. You can access table data in the HDFS log files either by using Hadoop tools or by using SQL queries from clients or peers in the GemFire XD distributed system. In order to preserve high performance for your GemFire XD clients, you define the operational data set that is maintained in memory and choose whether to limit queries to the in-memory data set or scan the persistent HDFS files as necessary.

See Persisting Table Data to Hadoop.

MapReduce API

GemFire XD extends the Hadoop MapReduce API to support MapReduce jobs that work with data stored in GemFire XD HDFS log files. A custom InputFormat implementation enables MapReduce jobs to access data in HDFS log files without having to start up or connect to a GemFire XD distributed system. Similarly, an OutputFormatter implementation simplifies the task of writing data back into a GemFire XD table using a client connection to a distributed system.

See Using MapReduce to Access HDFS Data.

Pivotal HAWQ Integration

In addition to providing a custom input/output system to support standard Hadoop tools, GemFire XD supports a PXF Driver to enable Pivotal HAWQ to read HDFS table data. (The required PXF driver is installed with HAWQ.) You simply define an external table in HAWQ that references GemFire XD HDFS log files, specifying custom properties to determine which log files are used to provide data. The PXF driver enables deep analytic processing of stored HDFS data without having to connect as a client to the GemFire XD distributed system.

See Accessing HDFS Data Using HAWQ.

Off-Heap Table Storage

GemFire XD supports storing table data directly in the JVM heap (the default), or in off-heap memory. Storing table data in off-heap memory enables you to manage very large databases in-memory, while improving CPU utilization and performance by avoiding JVM garbage collection pauses.

See Storing Tables In Off-Heap Memory.

ODBC Driver

GemFire XD now includes an ODBC driver that allows you to execute ODBC API functions on GemFire XD data stores from your client applications. In addition, GemFire XD provides a command-line tool that allow you to easily install and configure the driver using either the unixODBC or iODBC driver manager. The GemFire XD ODBC driver is supported on 32-bit and 64-bit Linux platforms. See Using ODBC Driver Functions in Client Applications for more information.

GemFire XD supports ODBC driver version 3.5 APIs only. For a list of all ODBC function APIs that are supported by GemFire XD, see ODBC API. Any ODBC APIs that are not listed in the reference are not supported with GemFire XD.

Management Features

GemFire XD adds these management features:

  • Federated JMX Architecture. GemFire XD uses MBeans to manage and monitor different parts of the software. With federation of the MBeanServers one member, the JMX Manager Node, provides a proxy view of all the MBeans that the MBeanServer hosts, and no separate JMX agent is required. The single JMX manager node can also distribute operations and notifications across the distributed system.
  • JMX Manager MBeans and Managed Node MBeans. New MBeans are available to provide better statistics and information about the GemFire XD distributed system as well as database objects.
  • Pulse Monitoring Application. GemFire XD Pulse is a Web Application that provides a graphical dashboard for monitoring vital, real-time health and performance of GemFire XD clusters, members, and tables. You can use Pulse to examine total memory, CPU, and disk space used by members, uptime statistics, client connections, WAN connections, query statistics, and critical notifications.
  • Enhanced EXPLAIN command. The EXPLAIN command was updated to provide simpler, customizable output for generated query plans.

Automatic Reconnect for Distributed System Members

A GemFire XD member that is forcibly disconnected from a distributed system automatically shuts down and then restarts into a "reconnecting" state while it periodically attempts to rejoin the system. Callback methods are provided so you can perform custom actions during the reconnect process, or you can cancel the reconnection if necessary. See Handling Forced Disconnection.

WAN Conflict Detection

GemFire XD improves the performance of WAN replication. Also, when WAN updates cannot be applied to a cluster due to conflicts or other errors, GemFire XD stores the failed DML operations in XMLs to be applied at a later time. You can program custom error handlers to manage conflict errors as they occur. User-defined error handlers can be used to implement eventual consistency for WAN updates between GemFire XD systems. See Resolving WAN Errors.

Improved Recovery Performance

When starting distributed system members, GemFire XD can speed the recovery of persisted data for partitioned table by distributing only the data necessary to bring each member up-to-date, rather than performing a full recovery.

In addition, GemFire XD now persists table indexes (in .irf files) to provide faster index recovery at startup. See Disk Store File Names and Extensions.

Installing GemFire XD 1.0

This release of GemFire XD is not provided as a standalone product. It is instead delivered as part of Pivotal HD Enterprise, and it requires Pivotal HD to be installed on the same machine in order to provide HDFS and HAWQ integration features.

Note: Although GemFire XD supports Java SE version 1.7.0_05 and version 1.6.0_26, Pivotal HD version 2.0.1 does not support Java 1.6. If you plan to deploy GemFire XD with Pivotal HD 2.0.1 or later, install and use Java SE 1.7.0_05.

Use the Pivotal Command Center CLI (Command Line Interface) to install GemFire XD. The Pivotal Command Center CLI installation process uses the GemFire XD RPM to install multiple instances of GemFire XD on different servers, along with HDFS, MapReduce, and other components you choose to install. See the Pivotal HD Enterprise Installation and Administrator Guide for more information.

Basic Features of GemFire XD

In addition to the new features highlighted above, GemFire XD provides these basic features:

See the GemFire XD User's Guide for more information.

Known Issues

Java Support

Although GemFire XD supports Java SE version 1.7.0_05 and version 1.6.0_26, Pivotal HD version 2.0.1 does not support Java 1.6. If you plan to deploy GemFire XD with Pivotal HD 2.0.1 or later, install and use Java SE 1.7.0_05.

Out of Memory Error When Starting Server Member with JMX Manager

An out of memory error can occur when using the PermGen heap if you attempt to start a JMX manager with a GemFire XD server member. This occurs because of a mismatch in Java versions between GemFire XD and Hadoop nodes.

To avoid this problem, follow the best practice of starting a JMX manager only on GemFire XD locator members, rather than on server members.

Windows Platforms Not Supported

This release of GemFire XD does not support Microsoft Windows platforms or ADO.NET clients. See Supported Configurations and System Requirements.

GemFire XD Issue Summary

The following key issues have been registered as bugs in the Pivotal bug tracking system:

ID Bugnote Title Bugnote Description Workaround
#41930 gfxd script does not support white spaces in member home directory The gfxd script included in this version of the product does not support starting GemFire Members in a directory path that contains white spaces. For example:
$ mkdir my\ server
$ cd my\ server
$ gfxd server start
Starting GemFireXD Server using multicast for peer discovery: 239.192.81.1[10334]
Starting network server for GemFireXD Server at address localhost/127.0.0.1[1527]
Logs generated in /opt/Pivotal_GemFireXD_10_b45952/bin/my server/gfxdserver.log
GemFireXD Server pid: 730 status: stopped
Error starting server process: 
IllegalArgumentException: Unknown argument:  server/start_gfxdserver.log - See log file for details.
Specify a member directory path that does not include spaces.
#42672 Inconsistent behavior of conflict exception (SQLState: X0Z02) thrown by product in transactions for parent and child row updates having foreign key relationship SQLFire may throw a conflict exception (SQLState: X0Z02) when a parent table entry is being UPDATED in a transaction and a child table is inserting a row having a foreign key reference to that parent row. However, for cases when the primary key is not the same as the partitioning key in the parent table, GemFire XD may not throw a conflict exception. Applications should not treat conflicts as unexpected during transactions when a parent table is being updated while inserts are in progress on the child table having a foreign key reference to the parent.
#44074 When using DBSynchronizer, if multiple potentially overlapping DMLs are executed in different transactions executing concurrently, then they may result in potentially different rows being affected in GemFire XD and backend DB. In a situation where multiple DMLs are executing concurrently that potentially overlap in GemFire XD but do not actually conflict, then replay of those DMLs using DBSynchronizer may lead to different rows being affected in the backend DB as compared to GemFire XD. As an example consider a bulk delete that uses some criteria on column and an update that changes the same column: update foo set col1=val1 where col1=val0; delete from foo where col1=val1; n/a
#44414 Unexpected ConflictingPersistentDataException after recovering from multiple failures If multiple members crash during the initial bucket creation or after recovering from a "gfxd shut down all" command, there is a possibility that those members will throw a ConflictingPersistentDataException on restart. n/a
#45544 Insert from thin client into table with auto generated primary key column may insert multiple rows An insert that is executed from a thin client can result in multiple rows being inserted if member failures occur, and if the table has a primary key defined with GENERATED BY DEFAULT identity. This problem can occur if the insert was successful in the first attempt, but the member fails before responding to the thin client. In this case, the thin client retries the operation with a new server, and since the primary key is autogenerated it results in a new id generated for the new insert. n/a
#46792 BucketMovedException with select MAX() over empty, partitioned table Certain queries that perform a table scan of an empty, partitioned table can fail due to GemFire XD scanning buckets on a related partitioned table in the query. For example, consider the following tables and queries:
gfxd>  create table t1 (c1 int, c2 int) partition by column(c1);
gfxd>  create table empty (c1 int, c2 int) partition by column(c1); 
gfxd>  insert into t1 values (null,null),(1,1),(null,null),(2,1),(3,1),(10,10); 
gfxd>  select max((select c1 from empty)) from t1;
The query should return null. Instead, GemFire XD hangs and logs the following exception:
[info 2013/09/11 11:20:32.525 EDT SQLF:  tid=0x44] (XID=154(UserTransaction)@463505cb;txState=null;supportsTX=true), 
(SESSIONID = 3), (DATABASE = sqlfire), (DRDAID = null), Failed Statement is: 
select max((select c1 from empty)) from t1
com.gemstone.gemfire.internal.cache.execute.BucketMovedException:
    Bucket migrated to another node. Please
    retry.[buckedId=1,region=/APP/EMPTY] 
[...]
This type of query is not supported for partitioned tables. The problem does not occur with replicated tables.
#46981 Aggregate queries can grow out of the valid range of the Long datatype During the calculation of average value in a query, the sum aggregate of all values in the column may go out of the valid range of the Long datatype. This causes the exception:
22003:The resulting value is outside the range for the data type <datatypeName>
If you experience this problem, explicitly cast the Long field.
#47199 Server fails to start with SQLException(x0768) When multiple add/drop operations are performed on the same index, procedure, or function, a server may fail to start with the error "Caused by: java.sql.SQLException(X0Y68): PROCEDURE 'procedure_name' already exists". Restart the server.
#47389 Update count incorrect after HA retry If an update operation is retried due to a member failure, then the update count may return a number that is less than the actual number of updated rows. This occurs because GemFire XD only returns the update count of the second, retried operation; updated rows that completed before the member failure are not included in the updatecount. n/a
#47449 Single-hop query may hang in WAN environment When a server goes down, a GemFire XD client read operation may be unable to detect the failure, which results in a hang. Use the "read-timeout" connection property to fail the connection after the specified amount of time. This enables GemFire XD to retry the connection on a new server automatically.
#47687 A JDBC RowLoader may not be invoked if a query uses a CAST in the projected columns If a query contains a CAST operator in the projection, then GemFire XD invokes the query as a generic scan rather than as a point lookup, and in this case any configured RowLoader is not invoked. If a RowLoader must be invoked for the query, perform explicit conversion in the Java code that invokes the query, rather than using CAST in the SQL statement.
#47809 Batch inserts may fail during HA failover GemFire XD member failures that occur during a batch insert may cause a java.sql.BatchUpdateException to be thrown. In this case, the insert operation(s) fail and it is not possible to determine which inserts completed and which did not. Apply inserts within the scope of a transaction to ensure that either all rows are inserted or none are inserted.
#47869 Disk store upgrade from SQLFire to GemFireXD does not work Disk stores created with SQLFire 1.1 and 1.2 cannot be loaded into GemFireXD 1.0. The "upgrade-disk-store" command is not supported with SQLFire disk stores, and it does not upgrade those disk stores to a compatible format. n/a
#47947 Sub-select in INSERT may fail to insert all records Testing has shown that INSERTs with sub-select statements sometimes fail to insert all records. Retry the insert operation or execute the insert within the scope of a transaction.
#48166 ClassCastException with com.vmware.sqlfire.internal.catalog.types.ReferencedColumnsDescriptorImpl In rare circumstances, executing a query may cause: ClassCastException: com.vmware.sqlfire.internal.catalog.types.ReferencedColumnsDescriptorImpl cannot be cast to com.vmware.sqlfire.internal.iapi.store.access.StaticCompiledOpenConglomInfo. Re-execute the query.
#48701 Procedures may not honor invoker permissions GemFire XD stored procedures may not honor the permission lists of a user who invokes the procedure. n/a
#48769 Procedure, triggers, functions don't inherit the rights of user that created them Procedures, triggers, and functions are executed using the rights of the invoker rather than the rights of the user who defined the procedure, function, or trigger. In other words, the CURRENT_USER permissions list is checked instead of the permission list of the user who defined the object being executed. This can lead to unexpected problems such as when a USER1 creates a table, "sample," and then USER2 creates an after update trigger of USER1.sample that selects a new column value (col1) from USER1.sample and places it into a new table. In this case, a USER3 may have read access to the trigger itself, but executing the trigger would cause a permission violation if USER3 had no read access to USER1.sample (col1), which the trigger selects after an update. Grant explicit read/write access to invoking user(s) for any dependent objects used in the body of a procedure, function, or trigger.
#48824 Import table performance with off-heap tables Performance testing has shown a degradation in performance for SYSCS_UTIL.IMPORT_TABLE operations on tables that are configured for off-heap storage. n/a
#48904 ClassCastException: PARTITION BY RANGE (SYMBOL): Cannot have overlapping ranges When creating a table that is partitioned by range, if the ranges are not well defined then GemFire XD throws the error ClassCastException: PARTITION BY RANGE (SYMBOL): Cannot have overlapping ranges. This error may appear as an internal issue, but it indicates a failure in the provided partitioning range. Review and correct the partition range provided in the CREATE TABLE statement.
#49002 Errors reading HDFS write-only table log files Running a MapReduce job or a PXF query against HDFS write-only table data fails if any log file in the table's HDFS store is larger than the HDFS file block size (specified during HDFS configuration as the dfs.block.size parameter). In this case, scanning any HDFS block other than the first block in the file fails. When you create the HDFS store for the write-only table, ensure that the sum of the MaxWriteOnlyFileSize and BatchSize options is less than the HDFS file block size that you have configured (dfs.block.size setting for HDFS configuration).
#49185 Pulse fails to start for multiple users on the same machine Trying to start the GemFire XD Pulse application may fail if another user has previously started Pulse on the same machine. This occurs because necessary folders in the /tmp directory remain and are owned by the previous user that started Pulse. The problem appears as the following exception:
[severe 2013/10/04 15:42:57.255 IST  <localhost-startStop-1> tid=0x35] (tid=11 msgId=4) LifecycleException
java.io.IOException: Failed to create destination directory to copy resources
        at org.apache.catalina.loader.WebappLoader.setRepositories(WebappLoader.java:891)
        ...
n/a
#49195 PXF Driver performance with multiple HDFS home directories The GemFire XD loner system that is started by the PXF driver is not optimized to access multiple HDFS store home directories. In HAWQ, performance is negatively impacted when accessing a second HDFS home directory, because the PXF driver restarts the loner instance. n/a
#49254 - #49259 ODBC Driver Limitations The ODBC driver included in this release of GemFire XD has the following limitations:
  • The ODBC driver does not support descriptors, which refer to data structures that hold information about either columns or dynamic parameters. See Descriptors at the Microsoft Developer Network for more information.
  • The SQLBrowseConnect API for creating ODBC connections is not supported.
  • The SQLDriverConnect API does not support the SQL_DRIVER_PROMPT DriverCompletion flag.
  • The SQLCancel API is implemented in the ODBC driver, but this API is not supported. Calling SQLCancel does not cancel processing.
  • SQL_ATTR_USE_BOOKMARKS, which are used in the SQLFetchScroll and SQLBulkOperation APIs, are not supported.
  • The SQLSetPos API has limited support and the SQL_REFRESH, SQL_UPDATE, and SQL_DELETE operations are not supported. Only the SQL_POSITION operation is supported. With the SQLSetPos API, only the SQL_LOCK_NO_CHANGE lock type is supported.
  • All arguments to the catalog API must be provided in upper case.
n/a
#49295 Transactional insert operation may throw TransactionDataNodeHasDepartedException During member initialization or HA failover, a transactional operation on a table with an HDFS store may throw a TransactionDataNodeHasDepartedException. This occurs because the HDFS queue is not fully initialized before a query is redirected to that node. Catch this exception and retry the operation if necessary.
#49395 Concurrent delete operations by multiple threads causes "Delete did not happen on index" When multiple threads perform concurrent delete operations on a table, a "Delete did not happen on index" error may occur. This problem has been observed when threads use DELETE FROM to delete all content from the table. Use TRUNCATE TABLE instead of DELETE FROM to delete all content from a table.
#49399 Bulk insert to table with a large dataset hangs Sometimes a bulk insert to a large table having a global index may hang due to an internal deadlock. Set conserve-sockets=false and re-try the insert. Do not use conserve-sockets=true.
#49406 HDFS queue limitation causes bottleneck This version of GemFire XD supports only a single HDFS async event queue per set of colocated tables (or per single, non-colocated table). The single queue can become a bottleneck when numerous client threads perform HDFS operations. Bottlenecks are identified by queues that constantly overflow, which reduces performance. As a workaround, run 2-3 JVMs on each server host to increase the number of HDFS queues available per each set of colocated tables (or individual, non-colocated tables) in the system.
#49611 Offline exception X0Z09 during insert Inserting a row to a table that has has foreign keys (which involve a remote index) and unique constraints may cause offline exception X0Z09. Use a transaction with REPEATABLE_READ isolation level to perform the operation
#49667 Exception during rollback An exception may occur during rollback for a failed delete operation from a thin client connection. This problem has been observed during HA failover scenarios. This exception may be ignored. Retry the failed operation
#49681 Delete operations may fail to delete data on an member that is starting up If a GemFire XD member is in the process of starting up in the distributed system, then data may not be deleted if member recover has not begun at the time when the delete operation reaches the member. This issue is only applicable to non-persistent tables. Bring new members online at a time when the system is not expected to perform delete operations.
#49716 If a commit fails due to a GemFire XD member failure (SQLStates 40XD0 and 40XD2), closing the connection may also fail If a commit fails due to a GemFire XD member failure (SQLState error 40XD0 or 40XD2), then closing the connection may also fail. To close a connection that has failed due to node failure in a transaction (SQLStates 40XD0, 40XD2), roll the transaction back and then ignore any exception in close, because the immediate server may have failed. For example:
try {
 conn.rollback();
 conn.close(); 
} catch (SQLException sqle) {
 // log failure if required 
}
#49727 Client may receive node failure exception even if transaction commits If the connection between a GemFire XD client and server is broken, it is possible that the client may receive a node failure exception even thought the client's transaction successfully commits on the server. There is currently no way for the client to determine the state of the transaction after such a failure. n/a
#49748 Query of WAN-replicated table on a receiving site hangs In a WAN configuration, any WAN-replicated table on a receiving site must have the same schema as the associated table on the sending site. There can be several problem scenarios if two sites attempt to use WAN replication to replicate tables having differenc schemas. One problem scenario is as follows:
  1. Site-2 has a table with one extra column, compared to an associated table in site-1.
  2. A row is inserted on site-1 which is then replicated to site-2.
  3. A select query of the table on site-2 will hang.
All tables which are enabled for WAN replication must have same schema on all GemFire XD sites.
#49760 Assertion failure for ListOfDeltas during index recovery The following error can occurs during index recovery: AssertionError: getIndexKey: Unhandled row com.gemstone.gemfire.internal.cache.ListOfDeltas. This error indicates that failures occurred during node member initialization. This error can be ignored.
#49899 AssertionError in versioning code When executing remote operations to a non-persistent table, recreating a bucket might fail with "Assertion error creating bucket in region com.gemstone.gemfire.InternalGemFireError?: recordVersion invoked for a local version tag that is higher than our local version." n/a
#49901 Gateway initialization may fail with "IllegalStateException: Value is no longer available" when using off-heap tables When using off-heap tables with a gateway configuration, you may see a secondary gateway fail during startup with "IllegalStateException: Value is no longer available". This is a transient problem. Restart the member that failed with this exception.
#49904 Evicted data could temporarily reappear after member recovery For HDFS tables that use the EVICT BY CRITERIA clause, it is possible that an evicted table value could temporarily reappear in the distributed system if the following sequence of events occurred:
  1. The member hosting secondary buckets for the table goes offline.
  2. The member hosting primary buckets evicts a table entry.
  3. The secondary member returns online, and recovers the older entry.
  4. The primary member goes offline.
In this case, a query against the table would use the secondary member's data, which contains the entry that was previously evicted by the primary member.
This problem has negligible impact, because the recurring value would be evicted during the next configured eviction cycle.
#49936 Row eviction is not performed for 'EVICT INCOMING' even though the row matches eviction criteria Custom eviction in an HDFS table takes place after indexes are updated and the DML event is replicated to secondaries. If a GemFire XD member after these operations but before eviction takes place, then the entry is not evicted even if the event is automatically retried. (This happens because the secondary would have already seen the event and so it would not put it into its local Map, which is necessary to trigger the eviction.) Use EVICTION BY CRITERIA with an EVICTION FREQUENCY instead of using EVICT INCOMING if you must ensure that custom eviction occurs during HA scenarios.
#49941 Insert operations hang after HDFS namenode and datanodes become unreachable Network failures may lead to unreachable HDFS namenode and datanode hosts. When this occurs, HDFS clients such as GemFire XD wait for the socket timeout (an HDFS client configuration property) before failing a write operation. Concurrent user insert or read requests fail one by one, after each request fails to establish a connection. If new requests continue to arrive, the time that it takes to report a failure continues to increase. n/a
#49942 Client reports SQLException after namenode loss If an HDFS write operation is active during at the time a namenode fails due to a broken network connection, the client closes local file system instances. In this case, a user of GemFire XD sees a SQLException caused by the HDFS error:
 (java.io.IOException: Filesystem closed). Execute SQL
  statement failed with: X0Z30 java.sql.SQLException(X0Z30): An error
  was received from HDFS while performing 'handleException'. at
  com.pivotal.gemfirexd.internal.iapi.error.StandardException.newException(StandardException.java:202)
  at
  com.pivotal.gemfirexd.internal.engine.Misc.wrapSQLException(Misc.java:912)
  at
  com.pivotal.gemfirexd.internal.engine.Misc.wrapRemoteSQLException(Misc.java:897)
  at
  com.pivotal.gemfirexd.internal.engine.distributed.utils.GemFireXDUtils.processCancelException(GemFireXDUtils.java:1952)
  at
  com.pivotal.gemfirexd.internal.engine.distributed.ResultHolder.processException(ResultHolder.java:1535)
  at
  com.pivotal.gemfirexd.internal.engine.distributed.ResultHolder.hasNext(ResultHolder.java:1480)
  at
  com.pivotal.gemfirexd.internal.engine.sql.execute.GemFireDistributedResultSet$SequentialIterator.(GemFireDistributedResultSet.java:594)
  at
  com.pivotal.gemfirexd.internal.engine.sql.execute.GemFireDistributedResultSet$SequentialIterator.(GemFireDistributedResultSet.java:573)
  at
  com.pivotal.gemfirexd.internal.engine.sql.execute.GemFireDistributedResultSet.getIterator(GemFireDistributedResultSet.java:413)
  at
  com.pivotal.gemfirexd.internal.engine.sql.execute.GemFireDistributedResultSet.setup(GemFireDistributedResultSet.java:202)
  at
  com.pivotal.gemfirexd.internal.engine.distributed.message.GfxdFunctionMessage.executeFunction(GfxdFunctionMessage.java:308)
n/a
#49943 DiskRegionStats.entriesOnlyOnDisk may show an incorrect value After persistent recovery from disk, the entriesOnlyOnDisk statistic may indicate that entries are still on disk, even though the entries are actually in memory. n/a
#49963 SQLIntegrityConstraintViolationException may observed for a unique constraint on partitioning column If a unique constraint contains a column on which table is partitioned, then an unexpected SQLIntegrityConstraintViolationException may occur for that constraint. Choose a partitioning column that is not used in the unique constraint.
#49984 When using transactions, UNIQUE constraint violation may be thrown when a unique column is updated or deleted multiple times The following is an example where updating unique columns multiple times in a transaction causes constraint violations:
gfxd> create table a (symbol varchar(10), exchange varchar(10), constraint sec_uq
  unique (symbol, exchange)); 
0 rows inserted/updated/deleted 
gfxd> set ISOLATION READ COMMITTED; 
0 rows inserted/updated/deleted 
gfxd> insert into a (symbol, exchange) values('a', 'a'); 
1 row inserted/updated/deleted 
gfxd> commit; 
gfxd> AUTOCOMMIT off; 
gfxd> update a set symbol = 'b' where symbol='a' and exchange = 'a'; 
1 row inserted/updated/deleted 
gfxd> select * from a; 
SYMBOL |EXCHANGE
------------------- 
b      |a 
1 row selected 
gfxd> update a set symbol =
  'a' where symbol ='b' and exchange = 'a'; 
ERROR 23505: SQLSTATE=23505,SEVERITY=-1: 
[...]
n/a
#49987 HDFSIOException during rebalancing A query that runs concurrently with a rebalance operation on an HDFS-persistent table may receive an HDFSIOException. Retry the query after rebalancing is complete.
#49989 Member fails to start with NullPointerException or assertion error when syncing concurrent transactions A new GemFire XD member will sometimes fail to start with a NullPointerException or assertion error if there are concurrent transactions taking place in the distributed system. Restart the failed node.
#49994 Unexpected SQLIntegrityConstraintViolationException after server failover In a server failover scenario, it is possible that an update to a table with a UNIQUE constraint succeeds in updating the table data, but does not update associated index data. This results in a SQLIntegrityConstraintViolationException for subsequent operations. n/a
#50030 ALTER TABLE SET HDFSSTORE is not supported ALTER TABLE with the SET HDFSSTORE clause is not supported, and causes a syntax error to occur. n/a
#50048 EXPLAIN output does not display It is common for GemFire XD to omit the output from an EXPLAIN command because such output frequently exceeds the default maximum display width of the gfxd utility. In gfxd, enter the command "maximumdisplaywidth 10000;" or higher to increase the maximum display width before using the EXPLAIN command.