Still getting uncaught exception in c++ API running keywords query

Question

When I run a search based on keyword in java application, the first time, most likely the query results is returned, but for the subsequent keywords searches, the application throws the error below...
com.sleepycat.dbxml.XmlException: Uncaught exception from C++ API, errcode = INTERNAL_ERROR
     at com.sleepycat.dbxml.dbxml_javaJNI.XmlQueryExpression_execute__SWIG_1(Native Method)
     at com.sleepycat.dbxml.XmlQueryExpression.execute(XmlQueryExpression.java:85)
     at epss.utilities.XQueryUtil.getQueryResultsByKeywords(XQueryUtil.java:168)
     at epss.search.XmlContentByKeywords.getDocumentContentByKeywords(XmlContentByKeywords.java:123)
     at com.epss.test.TestApp.main(TestApp.java:83)
I know one of the many things to consider fixing this problem is to make sure all berkeley db xml objects (e.g. xmlContainer, XmlManager, XmlResults, XmlQueryExpression, etc) delete() method is called on those obects once they are done to free resources etc. I've been doing all that and still getting the error. This problem doesn't happen when i run a search for based on id (attribute value).
Note: I'm not explicitly using trasanction since i turned on transaction in EnvironmentConfig to create XmlManager.
This is the method that does the query and return us the results...
     * Gets the query results by keywords.
     * @param keywords
     * the keywords under search
     * @param manager
     * the object used to perform activities such as preparing XQuery
     * queries
     * @return the query results by keywords
     public static synchronized XmlResults getQueryResultsByKeywords(
               final String keywords, XmlManager manager) {
          /* Represents a parsed XQuery expression. */
          XmlQueryExpression expr = null;
          /* Encapsulates the results of a query that has been executed. */
          XmlResults results = null;
          /* The query context */
          XmlQueryContext context = null;
          // The value
          XmlValue value = null;
          // Declare string variables
          String query = null;
          // Run logic
          try {
               /* Do null check */
               if (manager != null) {
                    // Make XmlValue object
                    value = new XmlValue(keywords);
                    // Get a query context
                    context = manager.createQueryContext();
                    // Bind xquery variable value to its variable name
                    context.setVariableValue(DataConstants.KEYWORD, value);
                    // Build the query string
                    query = QueryStringUtil.xQueryStringByKeywords(
                              DataConstants.ELEMENTS, DataConstants.KEYWORD);
                    // Compile an XQuery expression into an XmlQueryExpression
                    expr = manager.prepare(query, context);
                    // Evaluates the XQuery expression against the containers
                    results = expr.execute(context);
                    /* Release resources */
                    if (results.size() == 0) {
                         results.delete();
                         results = null;
                    // Free the native resources
                    expr.delete();
                    // Dereference objects
                    expr = null;
                    value = null;
                    context = null;
                    query = null;
                    manager.delete();
                    manager = null;
                    return results;
          } catch (final XmlException e) {
               // Free the native resources
               expr.delete();
               // dereference objects
               expr = null;
               value = null;
               context = null;
               query = null;
               // Write to log
               WriteLog.logExceptionToFile(e);
          return null;
This is the callback method that return the query string...
     * Returns query keyword query string to retrive keywords.
     * @param elementName The particular node under search
     * @param keywords The keywords being searched under the node
     * @return The string used for the query
     public static synchronized String xQueryStringByKeywords(
               final String elementName, final String keywords) {
          /* Build query string */
          final StringBuffer sb = new StringBuffer();
          sb.append("let $found := false\n");
          sb.append("let $terms := tokenize($");
          sb.append(keywords);
          sb.append(", \",\")\n");
          sb.append("for $element in collection('");
          sb.append(DataConstants.CONTAINER);
          sb.append("')");
          sb.append("/(FUNDOC | JOBDOC)");
          sb.append("//");
          sb.append(elementName);
          sb.append("//");
          sb.append("parent::*[1]");
          sb.append("\nlet $found := for $term in $terms\n");
          sb
                    .append(" return if (contains(lower-case($element), lower-case($term)))");
          sb.append(" \nthen \"true\"");
          sb.append(" else \"false\" \n");
          sb.append(" return if ($found = \"false\") \nthen () else $element");
          return sb.toString();
Edited by: user3453165 on Jan 20, 2010 7:20 AM

Answer 1

I am using berkeley db xml 2.5.13 on windows xp. Yes that's the complete error message. I am going to add my environment class and also part of the keyword search class that extends the environment, which will give u idea about how i'm creating and using transaction. I don't explicitly use transaction. I used to explicitly use it but i thought it's redundant. So when i create the db environment, i just call           envc.setTransactional(true) and pass the EnvironmentConfig object (i.e. envc) to the environment to create instance of XmlManager and this is fine. Look below and u will see what i mean. Please let me know if u need more information. Thanks for your help. Appreciate it.
Tue, 2010-01-19 10:58:27 PM
com.sleepycat.dbxml.XmlException: Uncaught exception from C++ API, errcode = INTERNAL_ERROR
     at com.sleepycat.dbxml.dbxml_javaJNI.XmlQueryExpression_execute__SWIG_1(Native Method)
     at com.sleepycat.dbxml.XmlQueryExpression.execute(XmlQueryExpression.java:85)
     at epss.utilities.XQueryUtil.getQueryResultsByKeywords(XQueryUtil.java:166)
     at epss.search.XmlContentByKeywords.getDocumentContentByKeywords(XmlContentByKeywords.java:123)
     at com.epss.test.TestApp.main(TestApp.java:66)
The environment class...
package epss.core;
import java.io.File;
import java.io.FilenameFilter;
import java.io.IOException;
import com.sleepycat.db.DatabaseException;
import com.sleepycat.db.Environment;
import com.sleepycat.db.EnvironmentConfig;
import com.sleepycat.dbxml.XmlContainer;
import com.sleepycat.dbxml.XmlContainerConfig;
import com.sleepycat.dbxml.XmlManager;
import com.sleepycat.dbxml.XmlManagerConfig;
import epss.utilities.GlobalUtil;
* Class used to open and close Berkeley Database environment.
public class DatabaseEnvironment {
     /** The db env_. */
     private Environment dbEnv_ = null;
     /** The mgr_. */
     private XmlManager mgr_ = null;
     /** The opened container. */
     private XmlContainer openedContainer = null;
     /** The new container. */
     private XmlContainer newContainer = null;
     /** The path2 db env_. */
     private File path2DbEnv_ = null;
     /** Whether we are creating or opening database environment. */
     private int mode = -1;
     /** Constants for mode opening or mode creation. */
     private static final int OPEN_DB = 0, CREATE_DB = 1;
     * Set the Mode (CREATE_DB = 1, OPEN_DB = 0).
     * @param m
     * the m
     protected synchronized void setDatabaseMode(final int m) {
          if (m == OPEN_DB || m == CREATE_DB)
               mode = m;
     * Gets the manager.
     * @return the manager
     protected synchronized XmlManager getManager() {
          return mgr_;
     * Gets the opened container.
     * @return the opened container
     protected synchronized XmlContainer getOpenedContainer() {
          return openedContainer;
     * Gets the new container.
     * @return the new container
     protected synchronized XmlContainer getNewContainer() {
          return newContainer;
     * Initialize database environment.
     * @throws Exception
     * the exception
     protected synchronized void doDatabaseSetup(String container)
               throws Exception {
          switch (mode) {
          case OPEN_DB:
               // check database home dir exist
               if (!(isPathToDbExist(new File(DataConstants.DB_HOME)))) {
                    WriteLog.logMessagesToFile(DataConstants.DB_FILE_MISSING);
                    cleanup();
                    throw new IOException(DataConstants.DB_FILE_MISSING);
               } else {
                    // Configure database environment
                    configureDatabaseEnv();
                    // Configuration settings for an XmlContainer instance
                    XmlContainerConfig config = new XmlContainerConfig();
                    // DB shd open within a transaction
                    config.setTransactional(true);
                    // Opens a container, returning a handle to an XmlContainer obj
                    openedContainer = getManager().openContainer(container, config);
               break;
          case CREATE_DB:
               // Set environment home
               setDatabaseHome();
               // Validate database home dir exist
               if (isPathToDbExist(new File(DataConstants.DB_HOME))) {
                    // Configure database environment
                    configureDatabaseEnv();
                    // Configuration settings for an XmlContainer instance
                    XmlContainerConfig config = new XmlContainerConfig();
                    // Sets whether documents are validated
                    config.setAllowValidation(true);
                    // DB shd open within a transaction
                    config.setTransactional(true);
                    // The database container path
                    File file = new File(path2DbEnv_, container);
                    // Creates a container, returning a handle to
                    // an XmlContainer object
                    newContainer = getManager().createContainer(file.getPath(),
                              config);
                    newContainer.setAutoIndexing(true);
               break;
          default:
               throw new IllegalStateException("mode value (" + mode
                         + ") is invalid");
     * Validate path2 db env.
     * @param path2DbEnv
     * the path2 db env
     * @return true, if checks if is path to db env
     private synchronized boolean isPathToDbExist(final File path2DbEnv) {
          boolean returnValue = false;
          if (!(path2DbEnv.isDirectory() || path2DbEnv.exists())) {
               throw new IllegalArgumentException(DataConstants.DIR_ERROR
                         + path2DbEnv.getAbsolutePath()
                         + DataConstants.DOES_NOT_EXIST);
          } else {
               path2DbEnv_ = path2DbEnv;
               // Test whether db home exist when mode is 0
               if (path2DbEnv_.exists() && mode == OPEN_DB) {
                    // Test whether all db files exist
                         returnValue = true;
               } else {
                    // Test whether db home exist when mode is 1
                    if (path2DbEnv_.exists() && mode == CREATE_DB) {
                         returnValue = true;
          return returnValue;
     * Set database environment home.
     * @throws IOException
     * Signals that an I/O exception has occurred.
     private synchronized void setDatabaseHome() throws IOException {
          // The base dir
          File homeDir = new File(DataConstants.DB_HOME);
          // If db home delete fails, throw io exception
          if (!GlobalUtil.deleteDir(homeDir) && homeDir.exists()) {
               WriteLog.logMessagesToFile(DataConstants.ERROR_MSG);
               throw new IOException(DataConstants.ERROR_MSG);
          } else {
               // If delete is successful, recreate db home
               final boolean success = homeDir.mkdir();
               // if home dir creation is successful
               if (success) {
                    // Construct file object
                    File logDir = new File(homeDir, DataConstants.LOG_DIR);
                    // File dbHome = new File(homeDir, DataConstants.DB_DIR);
                    // Create log file
                    boolean logCreated = logDir.mkdir();
                    // Create db home
                    // boolean dbHomeCreated = dbHome.mkdir();
                    if (logCreated) {
                         WriteLog.logMessagesToFile(homeDir.getAbsolutePath()
                                   + " successfully created");
               } else {
                    WriteLog.logMessagesToFile(homeDir.getAbsolutePath()
                              + " failed to create");
     * Sets environment configuration and it's handlers.
     * @throws Exception
     * the exception
     private synchronized void configureDatabaseEnv() throws Exception {
          // Construct a new log file object
          File logDir = new File(path2DbEnv_, DataConstants.LOG_DIR);
          // The environment config
          EnvironmentConfig envc = new EnvironmentConfig();
          // estimate how much space to allocate
          // for various lock-table data structures
          envc.setMaxLockers(10000);
          // estimate how much space to allocate
          // for various lock-table data structures
          envc.setMaxLocks(10000);
          // estimate how much space to allocate
          // for various lock-table data structures
          envc.setMaxLockObjects(10000);
          // automatically remove log files
          // that are no longer needed.
          envc.setLogAutoRemove(true);
          // If environment does not exist create it
          envc.setAllowCreate(true);
          // For multiple threads or processes that are concurrently reading and
          // writing to berkeley db xml
          envc.setInitializeLocking(true);
          // This is used for database recovery from application or system
          // failures.
          envc.setInitializeLogging(true);
          // Provides an in-memory cache that can be shared by all threads and
          // processes
          envc.setInitializeCache(true);
          // Provides atomicity for multiple database access operations.
          envc.setTransactional(true);
          // location of logging files.
          envc.setLogDirectory(logDir);
          // set the size of the shared memory buffer pool
          envc.setCacheSize(500 * 1024 * 1024);
          // turn on the mutexes
          envc.setMaxMutexes(500000);
          // show error messages by BDB XML library
          envc.setErrorStream(System.err);
          // File db_home = new File(path2DbEnv_, "db");
          // Create a database environment
          dbEnv_ = new Environment(path2DbEnv_, envc);
          // Configure an XmlManager instance via its constructors
          XmlManagerConfig mgrConf = new XmlManagerConfig();
          mgrConf.setAllowExternalAccess(true);
          mgrConf.setAllowAutoOpen(true);
          // Create xml manager object
          mgr_ = new XmlManager(dbEnv_, mgrConf);
          mgr_.setDefaultContainerType(XmlContainer.NodeContainer);
     * This method is used to close the database environment freeing any
     * allocated resources that may have been held by it's handlers and closing
     * any underlying subsystems.
     * @throws DatabaseException
     * the database exception
     protected synchronized void cleanup() throws DatabaseException {
          if (path2DbEnv_ != null) {
               path2DbEnv_ = null;
          if (newContainer != null) {
               newContainer.delete();
               newContainer = null;
          if (openedContainer != null) {
               openedContainer.delete();
               openedContainer = null;
          if (mgr_ != null) {
               mgr_.delete();
               mgr_ = null;
          if (dbEnv_ != null) {
               dbEnv_.close();
               dbEnv_ = null;
// This is the keyword search class...
public final class XmlContentByKeywords extends DatabaseEnvironment {
     public synchronized Document getDocumentContentByKeywords(String keywords)
               throws Exception {
          // Encapsulates the results of a query that has been executed.
          XmlResults results = null;
          // The manager
          XmlManager manager = null;
          // Run the logic
          if (keywords != null) {
               try {
                    // Flag to open db
                    final int OPEN_DB = 0;
                    // The keywords content
                    Document keywordsContent = null;
                    // Open db connection
                    try {
                         // Get database instance
                         setDatabaseMode(OPEN_DB);
                         // Open this container in db environment
                         doDatabaseSetup(DataConstants.CONTAINER);
                    } catch (Exception ex) {
                         // Create error node with error message
                         keywordsContent = Wrapper.createErrorDocument(ex
                                   .getMessage());
                         // Return the error node doc
                         return keywordsContent;
                    // Manager instance
                    // final XmlManager manager = getManager();
                    manager = getManager();
                    // Transaction instance
                    // final XmlTransaction txn_ = getTxn();
                    // The map
                    Map<String, Document> map = null;
                    // The temp map
                    Map<String, Document> tempMap = null;
                    // Return the query results
                    results = XQueryUtil.getQueryResultsByKeywords(keywords, manager);
// use results here...
// close results when done
results.delete();
results = null;
manager.delete();
manager = null;
}