public void clear() throws IOException, SimpleXAResourceException { persistentNodePool.clear(); persistentStringPool.clear(); }
public void close() { // Node pool try { persistentNodePool.close(); } catch (NodePoolException e) { logger.error("Unable to close node pool", e); } // String pool try { persistentStringPool.close(); } catch (StringPoolException e) { logger.error("Unable to close string pool", e); } }
public void delete() { // Node pool try { persistentNodePool.delete(); } catch (NodePoolException e) { logger.error("Unable to delete node pool", e); } // String pool try { persistentStringPool.delete(); } catch (StringPoolException e) { logger.error("Unable to delete string pool", e); } }
/** * Retrieve the SPObject factory from the stringpool to allow for the creation * of new SPObjects. * * @return The factory to allow for creation of SPObjects */ public SPObjectFactory getSPObjectFactory() { return persistentStringPool.getSPObjectFactory(); }
/** * {@inheritDoc} * * NB: This method does not perform any absolute/relative URI mapping. */ public SPObject findSPObject(long gNode) throws StringPoolException { if (gNode < NodePool.MIN_NODE) { throw new IllegalArgumentException("Attempt to resolve temporary gNode in BackupRestoreSession"); } return persistentStringPool.findSPObject(gNode); }
/** * {@inheritDoc} */ public Tuples findStringPoolType( SPObject.TypeCategory typeCategory, URI typeURI ) throws StringPoolException { try { // get the nodes from both string pools Tuples[] tuples = new Tuples[2]; tuples[0] = persistentStringPool.findGNodes(typeCategory, typeURI); tuples[1] = temporaryStringPool.findGNodes(typeCategory, typeURI); return appendTuples(tuples); } catch (TuplesException te) { throw new StringPoolException(te); } }
public ResolverSession newReadOnlyResolverSession() throws ResolverSessionFactoryException { try { logger.debug("Obtaining new RO XAResolverSession on SP/NP : " + persistentStringPool.getClass()); return new StringPoolSession(databaseURI, hostnameAliases, persistentStringPool.newReadOnlyStringPool(), persistentNodePool.newReadOnlyNodePool(), temporaryStringPoolFactory.newStringPool(), temporaryNodePoolFactory.newNodePool(), persistentStringPool); } catch (StringPoolException es) { throw new ResolverSessionFactoryException("Unable to obtain new StringPool", es); } catch (NodePoolException en) { throw new ResolverSessionFactoryException("Unable to obtain new NodePool", en); } }
public ResolverSession newWritableResolverSession() throws ResolverSessionFactoryException { try { logger.debug("Obtaining new RW XAResolverSession on SP/NP : " + persistentStringPool.getClass()); return new StringPoolSession(databaseURI, hostnameAliases, persistentStringPool.newWritableStringPool(), persistentNodePool.newWritableNodePool(), temporaryStringPoolFactory.newStringPool(), temporaryNodePoolFactory.newNodePool(), persistentStringPool); } catch (StringPoolException es) { throw new ResolverSessionFactoryException("Unable to obtain new StringPool", es); } catch (NodePoolException en) { throw new ResolverSessionFactoryException("Unable to obtain new NodePool", en); } }
public long findGNode(SPObject spObject) throws StringPoolException { return persistentStringPool.findGNode(spObject, persistentNodePool); } }
public void commit() throws SimpleXAResourceException { if (logger.isDebugEnabled()) { logger.debug("Committing phase on StringPoolSession " + System.identityHashCode(this)); } if (state == COMMIT) { return; } else if (state != PREPARE) { throw new SimpleXAResourceException("Attempting to commit phase without preparing"); } state = COMMIT; synchronized (globalLock) { persistentStringPool.commit(); persistentNodePool.commit(); for (int i = 0; i < resources.length; i++) { resources[i].commit(); } } }
protected long localize(Value node, int flags) throws LocalizeException { if (state != OBTAIN) { throw new LocalizeException(node, "Attempting to localize outside transaction (STATE = " + state + ") " + System.identityHashCode(this)); } if (node == null) { throw new IllegalArgumentException("Null 'node' parameter"); } if (node instanceof BNode) { return localizeBlankNode((BNode)node, flags); } SPObjectFactory spoFactory = persistentStringPool.getSPObjectFactory(); SPObject spObject; try { spObject = spoFactory.newSPObject(node); } catch (RuntimeException ex) { throw new LocalizeException(node, "Couldn't convert Node to SPObject", ex); } assert spObject != null; try { return localizeSPObject(spObject, flags); } catch (NodePoolException e) { throw new LocalizeException(node, "Couldn't localize node", e); } catch (StringPoolException e) { throw new LocalizeException(node, "Couldn't localize node", e); } }
/** * {@inheritDoc} */ public SPObject findStringPoolObject(long gNode) throws StringPoolException { // Container for our SPObject SPObject spo = null; if (gNode >= NodePool.MIN_NODE) { if (logger.isDebugEnabled()) { logger.debug("!! Searching for persistent node from id: " + gNode); } // Check if we have a persistent Node and find it if we have spo = mapAbsolute(persistentStringPool.findSPObject(gNode)); } else { if (logger.isDebugEnabled()) { logger.debug("!! Searching for temporary node from id: " + gNode); } // We have a temporary node so check the temporary pool (Using the // inverted negative id) spo = temporaryStringPool.findSPObject(-gNode); } return spo; }
/** * {@inheritDoc} */ public Tuples findStringPoolRange( SPObject lowValue, boolean inclLowValue, SPObject highValue, boolean inclHighValue ) throws StringPoolException { try { // get the nodes from both string pools Tuples[] tuples = new Tuples[2]; tuples[0] = persistentStringPool.findGNodes(lowValue, inclLowValue, highValue, inclHighValue); tuples[1] = temporaryStringPool.findGNodes(lowValue, inclLowValue, highValue, inclHighValue); Tuples result = appendTuples(tuples); tuples[0].close(); tuples[1].close(); return result; } catch (TuplesException te) { throw new StringPoolException(te); } }
/** * Creates a new Read Only ResolverSession that supports JRDF. * * @throws ResolverSessionFactoryException * @return ResolverSession */ public ResolverSession newReadOnlyResolverSession() throws ResolverSessionFactoryException { try { logger.debug("Obtaining new RO XAResolverSession on SP/NP : " + sessionFactory.getPersistentStringPool().getClass()); return new JRDFResolverSession(databaseURI, hostnameAliases, sessionFactory.getPersistentStringPool().newReadOnlyStringPool(), sessionFactory.getPersistentNodePool().newReadOnlyNodePool(), sessionFactory.getTemporaryStringPoolFactory().newStringPool(), sessionFactory.getTemporaryNodePoolFactory().newNodePool(), sessionFactory.getGlobalLock()); } catch (StringPoolException es) { throw new ResolverSessionFactoryException("Unable to obtain new StringPool", es); } catch (NodePoolException en) { throw new ResolverSessionFactoryException("Unable to obtain new NodePool", en); } }
/** * Creates a new Read/Write ResolverSession that supports JRDF. * * @throws ResolverSessionFactoryException * @return ResolverSession */ public ResolverSession newWritableResolverSession() throws ResolverSessionFactoryException { try { logger.debug("Obtaining new RW XAResolverSession on SP/NP : " + sessionFactory.getPersistentStringPool().getClass()); return new JRDFResolverSession(databaseURI, hostnameAliases, sessionFactory.getPersistentStringPool().newWritableStringPool(), sessionFactory.getPersistentNodePool().newWritableNodePool(), sessionFactory.getTemporaryStringPoolFactory().newStringPool(), sessionFactory.getTemporaryNodePoolFactory().newNodePool(), sessionFactory.getGlobalLock()); } catch (StringPoolException es) { throw new ResolverSessionFactoryException("Unable to obtain new StringPool", es); } catch (NodePoolException en) { throw new ResolverSessionFactoryException("Unable to obtain new NodePool", en); } }
SPObjectFactory spObjectFactory = persistentStringPool.getSPObjectFactory(); try { spObject = spObjectFactory.newSPURI(createURI(null, null, null, query, fragment)); SPObjectFactory spObjectFactory = persistentStringPool.getSPObjectFactory(); try { spObject = spObjectFactory.newSPURI(createURI(null, null, null, getQuery(uri), fragment));
public Value globalize(long localNode) throws GlobalizeException { if (state == ROLLBACK || state == RELEASE) { throw new GlobalizeException(localNode, "Attempting to globalize outside transaction."); } // Validate "localNode" parameter if (localNode == NONE) { throw new IllegalArgumentException("NONE isn't a local node"); } // Look up the local node in the string pool SPObject spObject; try { if (localNode < 0) { spObject = temporaryStringPool.findSPObject(-localNode); } else { spObject = mapAbsolute(persistentStringPool.findSPObject(localNode)); } } catch (StringPoolException e) { throw new GlobalizeException(localNode, "String pool lookup failed", e); } // Generate and return the corresponding RDF node Value node = globalizeBlankNode(localNode, spObject); assert node != null; // Return the RDF node return node; }
public void clear(int phaseNumber) throws IOException, SimpleXAResourceException { persistentNodePool.clear(phaseNumber); persistentStringPool.clear(phaseNumber); } }
private SPObject mapAbsolute(SPObject spObject) { if ( spObject != null && spObject.getTypeCategory() == SPObject.TypeCategory.URI ) { URI uri = ((SPURI)spObject).getURI(); if (!isAbsolute(uri)) { // Model URIs are stored as a relative URI containing only a fragment. // Relative URIs with both a query string and a fragment are also used // for views. SPObjectFactory spObjectFactory = persistentStringPool.getSPObjectFactory(); try { // Construct an absolute URI based on the database URI. String query = getQuery(uri); String ssp = getSchemeSpecificPart(databaseURI); if (query != null) ssp += '?' + query; spObject = spObjectFactory.newSPURI(createURI(getScheme(databaseURI), ssp, getFragment(uri))); } catch (Exception ex) { logger.warn( "Cannot create absolute URI with base:\"" + databaseURI + "\", query:\"" + getQuery(uri) + "\", fragment:\"" + getFragment(uri) + "\"", ex ); } } } return spObject; }