/**
* This method stores an xml document given as an org.w3c.dom.Document to the database giving it
* an indentifier. If the identifier provided is null, then the database generates a unique
* identifier on its own.
*
* @param doc The dom represntation of the document to be stored as an org.w3c.dom.Document.
* @param resourceId The resourceId to give to the document as a unique identifier within the
* database. If null a unique identifier is automatically generated.
* @param collection The name of the collection to store the document under. If it does not exist,
* it is created.
* @param username The identifier of the user calling the method used for authentication.
* @param password The password of the user calling the method used for authentication.
*/
public void storeDomDocument(
Document doc, String resourceId, String collection, String username, String password) {
try {
// initialize driver
Class cl = Class.forName(_driver);
Database database = (Database) cl.newInstance();
DatabaseManager.registerDatabase(database);
// try to get collection
Collection col = DatabaseManager.getCollection(_URI + collection, username, password);
if (col == null) {
// collection does not exist: get root collection and create
// for simplicity, we assume that the new collection is a
// direct child of the root collection, e.g. /db/test.
// the example will fail otherwise.
Collection root = DatabaseManager.getCollection(_URI + "/db");
CollectionManagementService mgtService =
(CollectionManagementService) root.getService("CollectionManagementService", "1.0");
col = mgtService.createCollection(collection.substring("/db".length()));
}
// create new XMLResource; an id will be assigned to the new resource
XMLResource document = (XMLResource) col.createResource(resourceId, "XMLResource");
document.setContentAsDOM(doc.getDocumentElement());
col.storeResource(document);
} catch (Exception e) {
e.printStackTrace();
}
}
public Collection getOrCreateCollection(String path) throws XMLDBException {
path = StringUtils.removeStart(path, "/");
path = StringUtils.removeEnd(path, "/");
path = path.replaceAll("[/]+", "/");
String pathWithURI = uri + path;
Collection col = DatabaseManager.getCollection(pathWithURI, userName, password);
if (col != null) {
return col;
} else {
synchronized (syncLock) {
col = DatabaseManager.getCollection(pathWithURI, userName, password);
if (col != null) {
return col;
}
String[] paths = path.split("/");
String[] parentPath = (String[]) ArrayUtils.remove(paths, paths.length - 1);
this.getOrCreateCollection(StringUtils.join(parentPath, '/'));
CollectionManagementService mgt = this.getCollectionManagementService();
col = mgt.createCollection(StringUtils.join(paths, '/'));
// If we are creating a new root collection, we need to set up the indexing configuration
// for this collection,
// which is done by placing a collection.xconf file into the config path structure.
if (paths.length == 1 && getCollectionRoot().endsWith(paths[0])) {
log.info("Configuring Indexes for Collection " + paths[0]);
// Add the index configuration file for our root config
try {
String confFilePath = "/collection.xconf";
String confFileXml =
IOUtils.toString(this.getClass().getResourceAsStream(confFilePath), "UTF-8");
Collection configCol = getOrCreateCollection("/system/config/db/" + paths[0]);
org.xmldb.api.base.Resource r =
configCol.createResource("collection.xconf", "XMLResource");
r.setContent(confFileXml);
configCol.storeResource(r);
log.info(
"Wrote index configuration " + r.getParentCollection().getName() + "/" + r.getId());
} catch (Exception e) {
log.error(
"Failure configuring indexes for collection "
+ paths[0]
+ " - indexes will not be available!",
e);
}
}
return col;
}
}
}
/**
* Store in the "classical" eXist way: the XMLResource stores an XML string before storeResource()
* stores it in the database.
*/
public void testQueryStoreContentAsSAX() {
try {
ContentHandler databaseInserter = doc.setContentAsSAX();
(new TabularXMLReader()).writeDocument(databaseInserter);
root.storeResource(doc);
querySingleLine("", "testQueryStoreContentAsSAX");
} catch (Exception e) {
fail(e.getMessage());
}
}
/*
public final void testDropResourceRoot() throws Exception {
Collection author = this.dbColl.getChildCollection("vcl-data/author");
author.removeResource(author.getResource("author.3.hjb.xml"));
}
public final void testDropResourceSub() throws Exception {
Collection article = this.dbColl.getChildCollection("vcl-data/article");
article.removeResource(article.getResource("article.patent.1.xml"));
}
*/
public final void testStoreResourceRoot() throws Exception {
Collection author = this.dbColl.getChildCollection("vcl-data/author");
Collection vcoll = this.dbColl.getChildCollection("vcl-data/myvc");
int size = vcoll.getResourceCount();
SixdmlResource res =
(SixdmlResource) author.createResource("author.4.manuel.xml", SixdmlResource.RESOURCE_TYPE);
res.setContentAsDOM(
DocumentBuilderFactoryImpl.newInstance()
.newDocumentBuilder()
.parse("data/vcl-data/author.4.manuel.xml"));
author.storeResource(res);
}
/**
* Main method of the example class.
*
* @param args (ignored) command-line arguments
* @throws Exception exception
*/
public static void main(final String[] args) throws Exception {
System.out.println("=== XMLDBInsert ===");
// Collection instance
Collection col = null;
try {
// Register the database
Class<?> c = Class.forName(DRIVER);
Database db = (Database) c.newInstance();
DatabaseManager.registerDatabase(db);
System.out.println("\n* Get collection.");
// Receive the collection
col = DatabaseManager.getCollection(DBNAME);
// ID for the new document
String id = "world";
// Content of the new document
String doc = "<xml>Hello World!</xml>";
System.out.println("\n* Create new resource.");
// Create a new XML resource with the specified ID
XMLResource res = (XMLResource) col.createResource(id, XMLResource.RESOURCE_TYPE);
// Set the content of the XML resource as the document
res.setContent(doc);
System.out.println("\n* Store new resource.");
// Store the resource into the database
col.storeResource(res);
} catch (final XMLDBException ex) {
// Handle exceptions
System.err.println("XML:DB Exception occurred " + ex.errorCode);
ex.printStackTrace();
} finally {
// Close the collection
if (col != null) col.close();
}
}
public final void testStoreResourceSubset() throws Exception {
Collection article = this.dbColl.getChildCollection("vcl-data/article");
Collection vcoll = this.dbColl.getChildCollection("vcl-data/myvc");
int size = vcoll.getResourceCount();
SixdmlResource res =
(SixdmlResource)
article.createResource("article.from.manuel.xml", SixdmlResource.RESOURCE_TYPE);
res.setContentAsDOM(
DocumentBuilderFactoryImpl.newInstance()
.newDocumentBuilder()
.parse("data/vcl-data/article.from.manuel.xml"));
article.storeResource(res);
assertEquals(size, vcoll.getResourceCount());
}
private void addXMLDocument(Collection c, String doc, String id) throws XMLDBException {
Resource r = c.createResource(id, XMLResource.RESOURCE_TYPE);
r.setContent(doc);
((EXistResource) r).setMimeType("application/xml");
c.storeResource(r);
}
/**
* Processes a compressed entry from an archive
*
* @param name The name of the entry
* @param isDirectory true if the entry is a directory, false otherwise
* @param is an InputStream for reading the uncompressed data of the entry
* @param filterParam is an additional param for entry filtering function
* @param storeParam is an additional param for entry storing function
* @throws XMLDBException
*/
protected Sequence processCompressedEntry(
String name, boolean isDirectory, InputStream is, Sequence filterParam, Sequence storeParam)
throws IOException, XPathException, XMLDBException {
String dataType = isDirectory ? "folder" : "resource";
// call the entry-filter function
Sequence filterParams[] = new Sequence[3];
filterParams[0] = new StringValue(name);
filterParams[1] = new StringValue(dataType);
filterParams[2] = filterParam;
Sequence entryFilterFunctionResult =
entryFilterFunction.evalFunction(contextSequence, null, filterParams);
if (BooleanValue.FALSE == entryFilterFunctionResult.itemAt(0)) {
return Sequence.EMPTY_SEQUENCE;
} else {
Sequence entryDataFunctionResult;
Sequence uncompressedData = Sequence.EMPTY_SEQUENCE;
// copy the input data
ByteArrayOutputStream baos = new ByteArrayOutputStream();
byte buf[] = new byte[1024];
int read = -1;
while ((read = is.read(buf)) != -1) {
baos.write(buf, 0, read);
}
byte[] entryData = baos.toByteArray();
if (entryDataFunction.getSignature().getArgumentCount() == 3) {
Sequence dataParams[] = new Sequence[3];
System.arraycopy(filterParams, 0, dataParams, 0, 2);
dataParams[2] = storeParam;
entryDataFunctionResult = entryDataFunction.evalFunction(contextSequence, null, dataParams);
String path = entryDataFunctionResult.itemAt(0).getStringValue();
Collection root =
new LocalCollection(
context.getUser(),
context.getBroker().getBrokerPool(),
new AnyURIValue("/db").toXmldbURI(),
context.getAccessContext());
if (isDirectory) {
XMLDBAbstractCollectionManipulator.createCollection(root, path);
} else {
Resource resource;
File file = new File(path);
name = file.getName();
path = file.getParent();
Collection target =
(path == null)
? root
: XMLDBAbstractCollectionManipulator.createCollection(root, path);
MimeType mime = MimeTable.getInstance().getContentTypeFor(name);
try {
NodeValue content =
ModuleUtils.streamToXML(context, new ByteArrayInputStream(baos.toByteArray()));
resource = target.createResource(name, "XMLResource");
ContentHandler handler = ((XMLResource) resource).setContentAsSAX();
handler.startDocument();
content.toSAX(context.getBroker(), handler, null);
handler.endDocument();
} catch (SAXException e) {
resource = target.createResource(name, "BinaryResource");
resource.setContent(baos.toByteArray());
}
if (resource != null) {
if (mime != null) {
((EXistResource) resource).setMimeType(mime.getName());
}
target.storeResource(resource);
}
}
} else {
// try and parse as xml, fall back to binary
try {
uncompressedData = ModuleUtils.streamToXML(context, new ByteArrayInputStream(entryData));
} catch (SAXException saxe) {
if (entryData.length > 0)
uncompressedData =
BinaryValueFromInputStream.getInstance(
context, new Base64BinaryValueType(), new ByteArrayInputStream(entryData));
}
// call the entry-data function
Sequence dataParams[] = new Sequence[4];
System.arraycopy(filterParams, 0, dataParams, 0, 2);
dataParams[2] = uncompressedData;
dataParams[3] = storeParam;
entryDataFunctionResult = entryDataFunction.evalFunction(contextSequence, null, dataParams);
}
return entryDataFunctionResult;
}
}