void getDetails( XmlTransaction &txn, XmlManager &mgr, const XmlContainer &container, const std::string &query, XmlQueryContext &context ) { //////////////////////////////////////////////////////////////////////// ////// Performs an query (in context) against the /////// ////// provided container. /////// //////////////////////////////////////////////////////////////////////// ///// some defensive code eliminated for clarity // // Perform the query. Result type is by default Result Document std::string fullQuery = "collection('" + container.getName() + "')" + query; try { std::cout << "Exercising query '" << fullQuery << "' " << std::endl; std::cout << "Return to continue: "; getc(stdin); XmlResults results( mgr.query( txn, fullQuery, context ) ); XmlValue value; std::cout << "\n\tProduct : Price : Inventory Level\n"; while( results.next(value) ) { /// Retrieve the value as a document XmlDocument theDocument = value.asDocument(); /// Obtain information of interest from the document. Note that the // wildcard in the query expression allows us to not worry about what // namespace this document uses. std::string item = getValue( txn, mgr, theDocument, "fn:string(/*/product)", context); std::string price = getValue( txn, mgr, theDocument, "fn:string(/*/inventory/price)", context); std::string inventory = getValue( txn, mgr, theDocument, "fn:string(/*/inventory/inventory)", context); std::cout << "\t" << item << " : " << price << " : " << inventory << std::endl; } std::cout << "\n"; std::cout << (unsigned int) results.size() << " objects returned for expression '" << fullQuery << "'\n" << std::endl; } //Catches XmlException catch(std::exception &e) { std::cerr << "Query " << fullQuery << " failed\n"; std::cerr << e.what() << "\n"; txn.abort(); exit(-1); } }
void doContextQuery( XmlTransaction &txn, XmlManager &mgr, const std::string cname, const std::string &query, XmlQueryContext &context ) { //////////////////////////////////////////////////////////////////////// ////// Performs a simple query (with context) against the /////// ////// provided container. /////// //////////////////////////////////////////////////////////////////////// ///// some defensive code eliminated for clarity // // Perform the query. Result type is by default Result Document std::string fullQuery = "collection('" + cname + "')" + query; try { std::cout << "Exercising query '" << fullQuery << "' " << std::endl; std::cout << "Return to continue: "; getc(stdin); std::cout << "\n"; XmlResults results( mgr.query(txn, fullQuery, context ) ); XmlValue value; while(results.next(value)) { // Get the document's name and print it to the console XmlDocument theDocument = value.asDocument(); std::cout << "Document name: " << theDocument.getName() << std::endl; std::cout << value.asString() << std::endl; } std::cout << (unsigned int)results.size() << " objects returned for expression '" << fullQuery << "'\n" << std::endl; } //Catches XmlException catch(std::exception &e) { std::cerr << "Query " << fullQuery << " failed\n"; std::cerr << e.what() << "\n"; txn.abort(); exit( -1 ); } }
void MgResourceDefinitionManager::DeleteResource( MgResourceIdentifier* resource, bool strict) { assert(NULL != resource); MG_RESOURCE_SERVICE_TRY() string resourcePathname; MgUtil::WideCharToMultiByte(resource->ToString(), resourcePathname); // Set up an XQuery. string query; if (resource->IsFolder()) { query = "for $i in collection('"; query += m_container.getName(); query += "')"; query += "/*[starts-with(dbxml:metadata('dbxml:name'),'"; query += resourcePathname; query += "')]"; query += " order by dbxml:metadata('dbxml:name', $i) descending return $i"; } else { query = "collection('"; query += m_container.getName(); query += "')"; query += "/*[dbxml:metadata('dbxml:name')='"; query += resourcePathname; query += "']"; } // Execute the XQuery. XmlManager& xmlManager = m_container.getManager(); XmlQueryContext queryContext = xmlManager.createQueryContext(); queryContext.setNamespace(MgResourceInfo::sm_metadataPrefix, MgResourceInfo::sm_metadataUri); XmlResults results = IsTransacted() ? xmlManager.query(GetXmlTxn(), query, queryContext, 0) : xmlManager.query(query, queryContext, 0); if (0 == results.size()) { if (!strict || (IsResourceContentManager() && resource->IsFolder())) { return; } else { m_repositoryMan.ThrowResourceNotFoundException(*resource, L"MgResourceDefinitionManager.DeleteResource", __LINE__, __WFILE__); } } // Delete the resources. MgResourceIdentifier currResource; XmlUpdateContext updateContext = xmlManager.createUpdateContext(); XmlValue xmlValue; while (results.next(xmlValue)) { XmlDocument xmlDoc = xmlValue.asDocument(); currResource.SetResource(MgUtil::MultiByteToWideChar(xmlDoc.getName())); if (!currResource.IsRoot()) { DeleteDocument(currResource, xmlDoc, updateContext); } } if (!resource->IsRoot()) { m_repositoryMan.UpdateDateModifiedResourceSet(resource->GetFullPath(true)); } MG_RESOURCE_CONTAINER_CATCH_AND_THROW(L"MgResourceDefinitionManager.DeleteResource") }
/////////////////////////////////////////////////////////////////////////////// /// \brief /// Packages the specified resource. /// void MgLibraryResourceContentManager::PackageResource(MgResourceIdentifier& resource, MgResourcePackageMaker& packageMaker) { ACE_ASSERT(resource.IsFolder()); MG_RESOURCE_SERVICE_TRY() string resourcePathname; MgUtil::WideCharToMultiByte(resource.ToString(), resourcePathname); // Set up an XQuery. XmlManager& xmlMan = m_container.getManager(); XmlQueryContext queryContext = xmlMan.createQueryContext(); string query; if (m_repositoryMan.m_currUserIsAdmin) { queryContext.setEvaluationType(XmlQueryContext::Lazy); query = "collection('"; } else { queryContext.setEvaluationType(XmlQueryContext::Eager); query = "for $i in collection('"; } query += m_container.getName(); query += "')"; query += "/*[starts-with(dbxml:metadata('dbxml:name'),'"; query += resourcePathname; if (m_repositoryMan.m_currUserIsAdmin) { query += "')]"; } else { query += "')] order by dbxml:metadata('dbxml:name', $i) return $i"; } // Execute the XQuery. XmlResults results = IsTransacted() ? xmlMan.query(GetXmlTxn(), query, queryContext, 0) : xmlMan.query(query, queryContext, 0); MgLibraryRepositoryManager& libraryRepositoryMan = (MgLibraryRepositoryManager&)m_repositoryMan; MgResourceDataFileManager* dataFileMan = libraryRepositoryMan.GetResourceDataFileManager(); ACE_ASSERT(NULL != dataFileMan); MgResourceDataStreamManager* dataStreamMan = libraryRepositoryMan.GetResourceDataStreamManager(); ACE_ASSERT(NULL != dataStreamMan); // Get the resources MgResourceIdentifier currResource; XmlValue xmlValue; while (results.next(xmlValue)) { // Note that the permission checks were already done at the time we // packaged the resource headers. const XmlDocument& xmlDoc = xmlValue.asDocument(); currResource.SetResource(MgUtil::MultiByteToWideChar(xmlDoc.getName())); // Package the resource content. if (!packageMaker.PackageResourceContent(currResource, xmlDoc)) { // The current user has no read permission to this resource. continue; } // Skip packaging resource data if there is no resource tag. XmlValue tagValue; if (!xmlDoc.getMetaData(MgResourceInfo::sm_metadataUri, MgResourceInfo::sm_metadataNames[MgResourceInfo::Tags], tagValue)) { continue; } STRING resourceTags; MgUtil::MultiByteToWideChar(tagValue.asString(), resourceTags); // Get the file path if it exists. MgTagManager tagMan(resourceTags); STRING filePath; MgTagInfo filePathTag; if (tagMan.GetTag(MgResourceTag::DataFilePath, filePathTag, false)) { filePath = dataFileMan->GetResourceDataFilePath(); filePath += filePathTag.GetAttribute(MgTagInfo::TokenValue); filePath += L"/"; } // Enumerate the resource data. MgTagMap& tagMap = tagMan.GetTagMap(); for (MgTagMap::const_iterator i = tagMap.begin(); i != tagMap.end(); ++i) { CREFSTRING dataName = (*i).first; // Skip the reserved tags. if (tagMan.IsReservedTag(dataName)) { continue; } // Get the resource data. const MgTagInfo& tagInfo = (*i).second; CREFSTRING mimeType = tagInfo.GetAttribute(MgTagInfo::MimeType); CREFSTRING dataType = tagInfo.GetAttribute(MgTagInfo::StorageType); Ptr<MgByteReader> byteReader; if (MgResourceDataType::File == dataType) { ACE_ASSERT(!filePath.empty()); STRING pathname = filePath; pathname += dataName; byteReader = dataFileMan->GetResourceData(pathname, mimeType); } else if (MgResourceDataType::Stream == dataType) { string dataKey; MgUtil::WideCharToMultiByte( tagInfo.GetAttribute(MgTagInfo::TokenValue), dataKey); byteReader = dataStreamMan->GetResourceData(dataKey, dataName, mimeType); } else if (MgResourceDataType::String == dataType) { string data; MgUtil::WideCharToMultiByte( tagInfo.GetAttribute(MgTagInfo::TokenValue), data); Ptr<MgByteSource> byteSource = new MgByteSource( (BYTE_ARRAY_IN)data.c_str(), (INT32)data.length()); byteSource->SetMimeType(mimeType); byteReader = byteSource->GetReader(); } else { throw new MgInvalidResourceDataTypeException( L"MgLibraryResourceContentManager.PackageResource", __LINE__, __WFILE__, NULL, L"", NULL); } // Package the resource data. packageMaker.PackageResourceData(currResource, byteReader, dataName, dataType); } } MG_RESOURCE_SERVICE_CATCH_AND_THROW(L"MgLibraryResourceContentManager.PackageResource") }