Document DocumentSourceBsonArray::getCurrent() {
verify(haveCurrent);
BSONObj documentObj(currentElement.Obj());
Document pDocument(
Document::createFromBsonObj(&documentObj));
return pDocument;
}
intrusive_ptr<const Value> AccumulatorAvg::getValue() const {
if (!pCtx->getInShard()) {
double avg = 0;
if (count) {
if (totalType != NumberDouble)
avg = static_cast<double>(longTotal / count);
else
avg = doubleTotal / count;
}
return Value::createDouble(avg);
}
intrusive_ptr<Document> pDocument(Document::create());
intrusive_ptr<const Value> pSubTotal;
if (totalType == NumberInt)
pSubTotal = Value::createInt((int)longTotal);
else if (totalType == NumberLong)
pSubTotal = Value::createLong(longTotal);
else
pSubTotal = Value::createDouble(doubleTotal);
pDocument->addField(subTotalName, pSubTotal);
intrusive_ptr<const Value> pCount(Value::createLong(count));
pDocument->addField(countName, pCount);
return Value::createDocument(pDocument);
}
void Pipeline::writeExplainMongos(
BSONObjBuilder &result,
const intrusive_ptr<DocumentSource> &pInputSource) const {
/*
For now, this should be a BSON source array.
In future, we might have a more clever way of getting this, when
we have more interleaved fetching between shards. The DocumentSource
interface will have to change to accommodate that.
*/
DocumentSourceBsonArray *pSourceBsonArray =
dynamic_cast<DocumentSourceBsonArray *>(pInputSource.get());
verify(pSourceBsonArray);
BSONArrayBuilder shardOpArray; // where we'll put the pipeline ops
for(bool hasDocument = !pSourceBsonArray->eof(); hasDocument;
hasDocument = pSourceBsonArray->advance()) {
intrusive_ptr<Document> pDocument(
pSourceBsonArray->getCurrent());
BSONObjBuilder opBuilder;
pDocument->toBson(&opBuilder);
shardOpArray.append(opBuilder.obj());
}
BSONArrayBuilder mongosOpArray; // where we'll put the pipeline ops
writeExplainOps(&mongosOpArray);
// now we combine the shard pipelines with the one here
result.append(serverPipelineName, shardOpArray.arr());
result.append(mongosPipelineName, mongosOpArray.arr());
}
void DocumentSourceSort::populate() {
/* make sure we've got a sort key */
verify(vSortKey.size());
/* track and warn about how much physical memory has been used */
DocMemMonitor dmm(this);
/* pull everything from the underlying source */
for(bool hasNext = !pSource->eof(); hasNext;
hasNext = pSource->advance()) {
intrusive_ptr<Document> pDocument(pSource->getCurrent());
documents.push_back(pDocument);
dmm.addToTotal(pDocument->getApproximateSize());
}
/* sort the list */
Comparator comparator(this);
sort(documents.begin(), documents.end(), comparator);
/* start the sort iterator */
docIterator = documents.begin();
if (docIterator != documents.end())
pCurrent = *docIterator;
populated = true;
}
void DocumentSourceGroup::populate() {
for(bool hasNext = !pSource->eof(); hasNext;
hasNext = pSource->advance()) {
intrusive_ptr<Document> pDocument(pSource->getCurrent());
/* get the _id document */
intrusive_ptr<const Value> pId(pIdExpression->evaluate(pDocument));
/* treat Undefined the same as NULL SERVER-4674 */
if (pId->getType() == Undefined)
pId = Value::getNull();
/*
Look for the _id value in the map; if it's not there, add a
new entry with a blank accumulator.
*/
vector<intrusive_ptr<Accumulator> > *pGroup;
GroupsType::iterator it(groups.find(pId));
if (it != groups.end()) {
/* point at the existing accumulators */
pGroup = &it->second;
}
else {
/* insert a new group into the map */
groups.insert(it,
pair<intrusive_ptr<const Value>,
vector<intrusive_ptr<Accumulator> > >(
pId, vector<intrusive_ptr<Accumulator> >()));
/* find the accumulator vector (the map value) */
it = groups.find(pId);
pGroup = &it->second;
/* add the accumulators */
const size_t n = vpAccumulatorFactory.size();
pGroup->reserve(n);
for(size_t i = 0; i < n; ++i) {
intrusive_ptr<Accumulator> pAccumulator(
(*vpAccumulatorFactory[i])(pExpCtx));
pAccumulator->addOperand(vpExpression[i]);
pGroup->push_back(pAccumulator);
}
}
/* point at the existing key */
// unneeded atm // pId = it.first;
/* tickle all the accumulators for the group we found */
const size_t n = pGroup->size();
for(size_t i = 0; i < n; ++i)
(*pGroup)[i]->evaluate(pDocument);
}
/* start the group iterator */
groupsIterator = groups.begin();
if (groupsIterator != groups.end())
pCurrent = makeDocument(groupsIterator);
populated = true;
}
bool Pipeline::run(BSONObjBuilder &result, string &errmsg) {
massert(16600, "should not have an empty pipeline",
!sources.empty());
/* chain together the sources we found */
DocumentSource* prevSource = sources.front().get();
for(SourceContainer::iterator iter(sources.begin() + 1),
listEnd(sources.end());
iter != listEnd;
++iter) {
intrusive_ptr<DocumentSource> pTemp(*iter);
pTemp->setSource(prevSource);
prevSource = pTemp.get();
}
/*
Iterate through the resulting documents, and add them to the result.
We do this even if we're doing an explain, in order to capture
the document counts and other stats. However, we don't capture
the result documents for explain.
*/
if (explain) {
if (!pCtx->getInRouter())
writeExplainShard(result);
else {
writeExplainMongos(result);
}
}
else {
// the array in which the aggregation results reside
// cant use subArrayStart() due to error handling
BSONArrayBuilder resultArray;
DocumentSource* finalSource = sources.back().get();
for(bool hasDoc = !finalSource->eof(); hasDoc; hasDoc = finalSource->advance()) {
Document pDocument(finalSource->getCurrent());
/* add the document to the result set */
BSONObjBuilder documentBuilder (resultArray.subobjStart());
pDocument->toBson(&documentBuilder);
documentBuilder.doneFast();
// object will be too large, assert. the extra 1KB is for headers
uassert(16389,
str::stream() << "aggregation result exceeds maximum document size ("
<< BSONObjMaxUserSize / (1024 * 1024) << "MB)",
resultArray.len() < BSONObjMaxUserSize - 1024);
}
resultArray.done();
result.appendArray("result", resultArray.arr());
}
return true;
}
void CLHTMLActiveDocument::UpdateAllViews()
{
// Invalidate all views of the document
CComQIPtr<CLDOMDocumentImplImpl> pDocument(m_document);
for (int n = 0; n < pDocument->m_pViews.GetSize(); n++)
{
ATLASSERT(0);
#if 0
pDocument->m_pViews[n]->InvalidateRect(NULL);
#endif
}
}
//-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~
WorkbenchService::pSceneModel_type
WorkbenchService::createSceneModel(pExplorerNode_type _pNode, I_Project* _pProject, I_SceneModel::pUserData_type _pUserData)
{
// TODO The primary key for the document is _pNode->getNodeId();
// TODO Cache the document so that a duplicate document is not created.
SceneModel* pRawDocument = new SceneModel(*this, _pProject, _pUserData);
// TODO This should return a future so that the load() can be done in the background
pSceneModel_type pDocument(pRawDocument, boost::bind(&WorkbenchService::destroySceneModel, this, _1));
pRawDocument->load(_pNode);
return pDocument;
}
DLLEXPORT FPDF_DOCUMENT STDCALL
FPDFAvail_GetDocument(FPDF_AVAIL avail, FPDF_BYTESTRING password) {
CFPDF_DataAvail* pDataAvail = static_cast<CFPDF_DataAvail*>(avail);
if (!pDataAvail)
return nullptr;
std::unique_ptr<CPDF_Parser> pParser(new CPDF_Parser);
pParser->SetPassword(password);
std::unique_ptr<CPDF_Document> pDocument(
new CPDF_Document(std::move(pParser)));
CPDF_Parser::Error error = pDocument->GetParser()->StartLinearizedParse(
pDataAvail->m_pDataAvail->GetFileRead(), pDocument.get());
if (error != CPDF_Parser::SUCCESS) {
ProcessParseError(error);
return nullptr;
}
pDataAvail->m_pDataAvail->SetDocument(pDocument.get());
CheckUnSupportError(pDocument.get(), FPDF_ERR_SUCCESS);
return FPDFDocumentFromCPDFDocument(pDocument.release());
}
void Pipeline::run(BSONObjBuilder& result) {
/*
Iterate through the resulting documents, and add them to the result.
We do this even if we're doing an explain, in order to capture
the document counts and other stats. However, we don't capture
the result documents for explain.
*/
if (explain) {
if (!pCtx->getInRouter())
writeExplainShard(result);
else {
writeExplainMongos(result);
}
}
else {
// the array in which the aggregation results reside
// cant use subArrayStart() due to error handling
BSONArrayBuilder resultArray;
DocumentSource* finalSource = sources.back().get();
for (bool hasDoc = !finalSource->eof(); hasDoc; hasDoc = finalSource->advance()) {
Document pDocument(finalSource->getCurrent());
/* add the document to the result set */
BSONObjBuilder documentBuilder (resultArray.subobjStart());
pDocument->toBson(&documentBuilder);
documentBuilder.doneFast();
// object will be too large, assert. the extra 1KB is for headers
uassert(16389,
str::stream() << "aggregation result exceeds maximum document size ("
<< BSONObjMaxUserSize / (1024 * 1024) << "MB)",
resultArray.len() < BSONObjMaxUserSize - 1024);
}
resultArray.done();
result.appendArray("result", resultArray.arr());
}
}
void CTemplateWizardDialog::UpdateFromHtml()
{
CComPtr<IDispatch> pDispDocument;
m_pBrowserApp->get_Document(&pDispDocument);
if (!pDispDocument)
return;
CComQIPtr<IHTMLDocument2, &IID_IHTMLDocument2> pDocument(pDispDocument);
CComPtr<IHTMLElementCollection> pElements;
pDocument->get_all(&pElements);
CComVariant nullVariant;
// Now get the INPUT elements.
CComPtr<IDispatch> pDispInputElements;
pElements->tags(CComVariant("INPUT"), &pDispInputElements);
if (pDispInputElements)
{
CComQIPtr<IHTMLElementCollection, &IID_IHTMLElementCollection> pInputElements(pDispInputElements);
if (pInputElements)
{
long count;
pInputElements->get_length(&count);
for (int i = 0; i < count; i++)
{
// Get the element, if it exists.
CComPtr<IDispatch> pDispElement;
pInputElements->item(CComVariant(i), nullVariant, &pDispElement);
if (!pDispElement)
continue;
CComQIPtr<IHTMLElement, &IID_IHTMLElement> pElement(pDispElement);
if (!pElement)
continue; //??
CComBSTR bstrID;
pElement->get_id(&bstrID);
CComQIPtr<IHTMLInputElement, &IID_IHTMLInputElement> pInputElement(pDispElement);
if (!pInputElement)
continue; //??
// Get the type.
CComBSTR bstrType;
pInputElement->get_type(&bstrType);
CString strType(bstrType);
CString id(bstrID);
if (strType == "text" || strType == "file")
{
CComBSTR bstrValue;
pInputElement->get_value(&bstrValue);
CString value(bstrValue);
value = g_wwhizTemplateManager->ParseCode(value, NULL, &m_code);
m_params[id] = value;
}
else if (strType == "checkbox")
{
short variant;
pInputElement->get_checked(&variant);
if (variant == VARIANT_FALSE)
m_params[id] = "0";
else
m_params[id] = "1";
}
else if (strType == "radio")
{
short variant;
pInputElement->get_checked(&variant);
if (variant == VARIANT_FALSE)
m_params[id] = "0";
else
m_params[id] = "1";
}
}
}
}
// Now get the SELECT elements.
CComPtr<IDispatch> pDispSelectElements;
pElements->tags(CComVariant("SELECT"), &pDispSelectElements);
if (pDispSelectElements)
{
CComQIPtr<IHTMLElementCollection, &IID_IHTMLElementCollection> pSelectElements(pDispSelectElements);
if (pSelectElements)
{
long count;
pSelectElements->get_length(&count);
for (int i = 0; i < count; i++)
{
// Get the element, if it exists.
CComPtr<IDispatch> pDispElement;
pSelectElements->item(CComVariant(i), nullVariant, &pDispElement);
if (!pDispElement)
continue;
CComQIPtr<IHTMLElement, &IID_IHTMLElement> pElement(pDispElement);
if (!pElement)
continue; //??
CComBSTR bstrID;
pElement->get_id(&bstrID);
CString id(bstrID);
if (id.IsEmpty())
continue;
CComQIPtr<IHTMLSelectElement, &IID_IHTMLSelectElement> pSelectElement(pElement);
if (!pSelectElement)
continue; //??
// Get the type.
CComBSTR bstrType;
pSelectElement->get_type(&bstrType);
CString strType(bstrType);
// Get the current selection index.
long curSel;
pSelectElement->get_selectedIndex(&curSel);
// Get the item at the index.
CComPtr<IDispatch> pDispOptionElement;
pSelectElement->item(CComVariant(curSel), nullVariant, &pDispOptionElement);
if (pDispOptionElement)
{
CComQIPtr<IHTMLOptionElement, &IID_IHTMLOptionElement> pOptionElement(pDispOptionElement);
CComBSTR bstrItem;
pOptionElement->get_text(&bstrItem);
m_params[id] = bstrItem;
}
}
}
}
}
intrusive_ptr<DocumentSource> DocumentSourceProject::createFromBson(
BSONElement *pBsonElement,
const intrusive_ptr<ExpressionContext> &pExpCtx) {
/* validate */
uassert(15969, str::stream() << projectName <<
" specification must be an object",
pBsonElement->type() == Object);
/* chain the projection onto the original source */
intrusive_ptr<DocumentSourceProject> pProject(
DocumentSourceProject::create(pExpCtx));
/*
Pull out the $project object. This should just be a list of
field inclusion or exclusion specifications. Note you can't do
both, except for the case of _id.
*/
BSONObj projectObj(pBsonElement->Obj());
BSONObjIterator fieldIterator(projectObj);
Expression::ObjectCtx objectCtx(
Expression::ObjectCtx::DOCUMENT_OK);
while(fieldIterator.more()) {
BSONElement outFieldElement(fieldIterator.next());
string outFieldPath(outFieldElement.fieldName());
string inFieldName(outFieldPath);
BSONType specType = outFieldElement.type();
int fieldInclusion = -1;
switch(specType) {
case NumberDouble: {
double inclusion = outFieldElement.numberDouble();
fieldInclusion = static_cast<int>(inclusion);
goto IncludeExclude;
}
case NumberLong: {
long long inclusion = outFieldElement.numberLong();
fieldInclusion = static_cast<int>(inclusion);
goto IncludeExclude;
}
case NumberInt:
/* just a plain integer include/exclude specification */
fieldInclusion = outFieldElement.numberInt();
IncludeExclude:
uassert(15970, str::stream() <<
"field inclusion or exclusion specification for \"" <<
outFieldPath <<
"\" must be true, 1, false, or zero",
((fieldInclusion == 0) || (fieldInclusion == 1)));
if (fieldInclusion == 0)
pProject->excludePath(outFieldPath);
else
pProject->includePath(outFieldPath);
break;
case Bool:
/* just a plain boolean include/exclude specification */
fieldInclusion = (outFieldElement.Bool() ? 1 : 0);
goto IncludeExclude;
case String:
/* include a field, with rename */
fieldInclusion = 1;
inFieldName = outFieldElement.String();
pProject->addField(
outFieldPath,
ExpressionFieldPath::create(
Expression::removeFieldPrefix(inFieldName)));
break;
case Object: {
intrusive_ptr<Expression> pDocument(
Expression::parseObject(&outFieldElement, &objectCtx));
/* add The document expression to the projection */
pProject->addField(outFieldPath, pDocument);
break;
}
default:
uassert(15971, str::stream() <<
"invalid BSON type (" << specType <<
") for " << projectName <<
" field " << outFieldPath, false);
}
}
return pProject;
}
intrusive_ptr<Document> Document::create(size_t sizeHint) {
intrusive_ptr<Document> pDocument(new Document(sizeHint));
return pDocument;
}
intrusive_ptr<Document> Document::createFromBsonObj(BSONObj *pBsonObj) {
intrusive_ptr<Document> pDocument(new Document(pBsonObj));
return pDocument;
}
void CTemplateWizardDialog::DocumentComplete(LPDISPATCH pDisp, VARIANT* URL)
{
UNUSED_ALWAYS(pDisp);
// ASSERT(V_VT(URL) == VT_BSTR);
CString str(V_BSTR(URL));
// Load in the new file...
HRESULT hr;
LPUNKNOWN pUnkContainedBrowser = NULL;
LPUNKNOWN pUnkDispParam = NULL;
IStream *pStream = NULL;
HGLOBAL hHTMLText;
CComPtr<IDispatch> pDispDocument;
// HWND shellWnd;
// HWND ieWnd;
// Test for valid pointers.
if (!m_pBrowserApp || !pDisp)
goto CleanUp;
// To test object equality, use COM identity rules: query both
// pointers for IUnknown and compare them.
hr = m_pBrowserApp->QueryInterface(IID_IUnknown,
(void**)&pUnkContainedBrowser);
if (hr)
goto CleanUp;
// Query the passed-in IDispatch for IUnknown.
hr = pDisp->QueryInterface(IID_IUnknown,
(void**)&pUnkDispParam);
if (hr)
goto CleanUp;
// If they're unequal, the event is for a subframe and we're not
// interested.
if (pUnkContainedBrowser != pUnkDispParam)
goto CleanUp;
// As a further check, make sure the URL is "about:blank".
if (str == "about:blank")
{
// The string is about:blank. This means load the correct page.
LONG len = (LONG)m_htmlFile.GetLength();
BYTE* data = m_htmlFile.Detach();
hHTMLText = GlobalAlloc(GPTR, len + 1);
if (!hHTMLText)
goto CleanUp;
memcpy((CHAR *)hHTMLText, (char*)data, len);
*(char*)((char*)hHTMLText + len) = 0;
free(data);
hr = ::CreateStreamOnHGlobal(hHTMLText, TRUE, &pStream);
if (hr)
goto CleanUp;
// Call the helper function to load the WebOC from the stream.
//
hr = LoadWebOCFromStream(m_pBrowserApp, pStream);
goto CleanUp;
}
/* // Set the focus to the right window.
shellWnd = ::FindWindowEx(m_wndBrowser.GetSafeHwnd(), NULL, "Shell DocObject View", NULL);
ieWnd = ::FindWindowEx(shellWnd, NULL, "Internet Explorer_Server", NULL);
::SetFocus(ieWnd);
*/
// Set to the first available input field.
m_pBrowserApp->get_Document(&pDispDocument);
if (pDispDocument)
{
CComQIPtr<IHTMLDocument2, &IID_IHTMLDocument2> pDocument(pDispDocument);
// Get all of the HTML elements.
CComPtr<IHTMLElementCollection> pElements;
pDocument->get_all(&pElements);
CComVariant nullVariant;
CComPtr<IDispatch> pDispFirstElement;
// Now get the INPUT elements.
CComPtr<IDispatch> pDispInputElements;
pElements->tags(CComVariant("INPUT"), &pDispInputElements);
if (pDispInputElements)
{
CComQIPtr<IHTMLElementCollection, &IID_IHTMLElementCollection> pInputElements(pDispInputElements);
if (pInputElements)
{
long count;
pInputElements->get_length(&count);
for (int i = 0; i < count; i++)
{
// Get the element, if it exists.
CComPtr<IDispatch> pDispElement;
pInputElements->item(CComVariant(i), nullVariant, &pDispElement);
if (!pDispElement)
continue;
CComQIPtr<IHTMLElement, &IID_IHTMLElement> pElement(pDispElement);
if (!pElement)
continue; //??
CComBSTR bstrID;
pElement->get_id(&bstrID);
CComQIPtr<IHTMLInputElement, &IID_IHTMLInputElement> pInputElement(pElement);
if (!pInputElement)
continue; //??
// Get the type.
CComBSTR bstrType;
pInputElement->get_type(&bstrType);
CString strType(bstrType);
CString id(bstrID);
CString value;
if (!m_params.Lookup(id, value))
{
value = m_code.GetEntry(id);
}
if (strType == "text")
{
value = g_wwhizTemplateManager->ParseCode(value, NULL, &m_code);
pInputElement->put_value(CComBSTR(value));
if (!pDispFirstElement)
pDispFirstElement = pDispElement;
}
else if (strType == "checkbox")
{
pInputElement->put_checked(value == "1" ? VARIANT_TRUE : VARIANT_FALSE);
}
else if (strType == "radio")
{
pInputElement->put_checked(value == "1" ? VARIANT_TRUE : VARIANT_FALSE);
}
else if (strType == "file")
{
CComQIPtr<IHTMLInputFileElement,
&IID_IHTMLInputFileElement> pInputFileElement(pElement);
if (!pInputFileElement)
continue; //??
value = g_wwhizTemplateManager->ParseCode(value, NULL, &m_code);
pInputFileElement->put_value(CComBSTR(value));
if (!pDispFirstElement)
pDispFirstElement = pDispElement;
}
}
}
}
// Now get the SELECT elements.
CComPtr<IDispatch> pDispSelectElements;
pElements->tags(CComVariant("SELECT"), &pDispSelectElements);
if (pDispSelectElements)
{
CComQIPtr<IHTMLElementCollection, &IID_IHTMLElementCollection> pSelectElements(pDispSelectElements);
if (pSelectElements)
{
long count;
pSelectElements->get_length(&count);
for (int i = 0; i < count; i++)
{
// Get the element, if it exists.
CComPtr<IDispatch> pDispElement;
pSelectElements->item(CComVariant(i), nullVariant, &pDispElement);
if (!pDispElement)
continue;
CComQIPtr<IHTMLElement, &IID_IHTMLElement> pElement(pDispElement);
if (!pElement)
continue; //??
CComBSTR bstrID;
pElement->get_id(&bstrID);
CComQIPtr<IHTMLSelectElement, &IID_IHTMLSelectElement> pSelectElement(pElement);
if (!pSelectElement)
continue; //??
// Get the type.
CComBSTR bstrType;
pSelectElement->get_type(&bstrType);
CString strType(bstrType);
CString id(bstrID);
CString value;
if (!m_params.Lookup(id, value))
{
value = m_code.GetEntry(id);
}
// This is the only way I can figure out to do this!
// Match the name.
long optionCount;
pSelectElement->get_length(&optionCount);
int j;
for (j = 0; j < optionCount; j++)
{
// Get the item at the index.
CComPtr<IDispatch> pDispOptionElement;
pSelectElement->item(CComVariant(j), nullVariant, &pDispOptionElement);
if (pDispOptionElement)
{
CComQIPtr<IHTMLOptionElement, &IID_IHTMLOptionElement> pOptionElement(pDispOptionElement);
CComBSTR bstrItem;
pOptionElement->get_text(&bstrItem);
CString strItem(bstrItem);
if (value == strItem)
{
pSelectElement->put_selectedIndex(j);
break;
}
}
}
if (j == optionCount)
{
pSelectElement->put_selectedIndex(0);
}
}
}
}
if (pDispFirstElement)
{
CComQIPtr<IHTMLControlElement, &IID_IHTMLControlElement> pHtmlElement(pDispFirstElement);
pHtmlElement->focus();
CComQIPtr<IHTMLInputTextElement, &IID_IHTMLInputTextElement> pElement(pDispFirstElement);
if (pElement)
{
pElement->select();
}
}
}
CleanUp:
if (pStream)
pStream->Release();
if (pUnkContainedBrowser)
pUnkContainedBrowser->Release();
if (pUnkDispParam)
pUnkDispParam->Release();
if (!m_asciiFilename.IsEmpty())
{
_unlink(m_asciiFilename);
m_asciiFilename.Empty();
}
}
intrusive_ptr<DocumentSource> DocumentSourceProject::createFromBson(
BSONElement *pBsonElement,
const intrusive_ptr<ExpressionContext> &pCtx) {
/* validate */
assert(pBsonElement->type() == Object); // CW TODO user error
/* chain the projection onto the original source */
intrusive_ptr<DocumentSourceProject> pProject(
DocumentSourceProject::create());
/*
Pull out the $project object. This should just be a list of
field inclusion or exclusion specifications. Note you can't do
both, except for the case of _id.
*/
BSONObj projectObj(pBsonElement->Obj());
BSONObjIterator fieldIterator(projectObj);
Expression::ObjectCtx objectCtx(
Expression::ObjectCtx::DOCUMENT_OK);
while(fieldIterator.more()) {
BSONElement outFieldElement(fieldIterator.next());
string outFieldPath(outFieldElement.fieldName());
string inFieldName(outFieldPath);
BSONType specType = outFieldElement.type();
int fieldInclusion = -1;
switch(specType) {
case NumberDouble: {
double inclusion = outFieldElement.numberDouble();
if ((inclusion == 0) || (inclusion == 1))
fieldInclusion = (int)inclusion;
else {
assert(false); // CW TODO unimplemented constant expression
}
goto IncludeExclude;
}
case NumberInt:
/* just a plain integer include/exclude specification */
fieldInclusion = outFieldElement.numberInt();
assert((fieldInclusion >= 0) && (fieldInclusion <= 1));
// CW TODO invalid field projection specification
IncludeExclude:
if (fieldInclusion == 0)
pProject->excludePath(outFieldPath);
else
pProject->includePath(outFieldPath);
break;
case Bool:
/* just a plain boolean include/exclude specification */
fieldInclusion = outFieldElement.Bool() ? 1 : 0;
goto IncludeExclude;
case String:
/* include a field, with rename */
fieldInclusion = 1;
inFieldName = outFieldElement.String();
pProject->addField(
outFieldPath,
ExpressionFieldPath::create(
Expression::removeFieldPrefix(inFieldName)));
break;
case Object: {
intrusive_ptr<Expression> pDocument(
Expression::parseObject(&outFieldElement, &objectCtx));
/* add The document expression to the projection */
pProject->addField(outFieldPath, pDocument);
break;
}
default:
assert(false); // CW TODO invalid field projection specification
}
}
return pProject;
}
bool Pipeline::run(BSONObjBuilder &result, string &errmsg,
const intrusive_ptr<DocumentSource> &pInputSource) {
/* chain together the sources we found */
DocumentSource *pSource = pInputSource.get();
for(SourceVector::iterator iter(sourceVector.begin()),
listEnd(sourceVector.end()); iter != listEnd; ++iter) {
intrusive_ptr<DocumentSource> pTemp(*iter);
pTemp->setSource(pSource);
pSource = pTemp.get();
}
/* pSource is left pointing at the last source in the chain */
/*
Iterate through the resulting documents, and add them to the result.
We do this even if we're doing an explain, in order to capture
the document counts and other stats. However, we don't capture
the result documents for explain.
We wrap all the BSONObjBuilder calls with a try/catch in case the
objects get too large and cause an exception.
*/
try {
if (explain) {
if (!pCtx->getInRouter())
writeExplainShard(result, pInputSource);
else {
writeExplainMongos(result, pInputSource);
}
}
else
{
BSONArrayBuilder resultArray; // where we'll stash the results
for(bool hasDocument = !pSource->eof(); hasDocument;
hasDocument = pSource->advance()) {
intrusive_ptr<Document> pDocument(pSource->getCurrent());
/* add the document to the result set */
BSONObjBuilder documentBuilder;
pDocument->toBson(&documentBuilder);
resultArray.append(documentBuilder.done());
}
result.appendArray("result", resultArray.arr());
}
} catch(AssertionException &ae) {
/*
If its not the "object too large" error, rethrow.
At time of writing, that error code comes from
mongo/src/mongo/bson/util/builder.h
*/
if (ae.getCode() != 13548)
throw;
/* throw the nicer human-readable error */
uassert(16029, str::stream() <<
"aggregation result exceeds maximum document size limit ("
<< (BSONObjMaxUserSize / (1024 * 1024)) << "MB)",
false);
}
return true;
}
