public function getPictureTotalSize()
{
$result = $this->collection->aggregate([['$match' => ['-class' => $this->alias]], ['$project' => ['size' => true, '-class' => true]], ['$group' => ['_id' => '$-class', 'total' => ['$sum' => '$size']]]]);
$total = 0;
if ($result['ok'] == 1 && count($result['result'])) {
$total = $result['result'][0]['total'];
}
return $total;
}
/**
*/
public function favouriteRecipients($limit, $filter = null)
{
$query = array(self::SUCCESS => 1, self::WHO => $GLOBALS['registry']->getAuth());
if (!empty($filter)) {
$query[self::ACTION] = array('$in' => $filter);
}
$out = array();
try {
$res = $this->_db->aggregate(array(array('$match' => $query), array('$group' => array('_id' => '$' . self::RECIPIENT, 'count' => array('$sum' => 1))), array('$sort' => array('count' => -1)), array('$limit' => $limit)));
if (isset($res['result'])) {
foreach ($res['result'] as $val) {
$out[] = $val['_id'];
}
}
} catch (MongoException $e) {
}
return $out;
}
/**
* @param array $pipeline
* @param array $op
* @param null $op1
* @return array
*/
public function aggregate($pipeline, $op = null, $op1 = null)
{
$op = $op ?: [];
if (is_array($op) && isset($op['cache']) && $op['cache'] === false) {
unset($op['cache']);
return parent::aggregate($pipeline, $op);
}
if (!isset($pipeline[0])) {
$pipeline = func_get_args();
}
$hash = $this->hash($pipeline);
$result = $this->cache->get($hash);
if (!$result) {
$result = parent::aggregate($pipeline, $op);
$this->cache->set($hash, $result, $this->getCacheTime($op));
}
return $result;
}
/**
* Execute the query as a fresh "select" statement.
*
* @param array $columns
* @return array|static[]
*/
public function getFresh($columns = array())
{
// If no columns have been specified for the select statement, we will set them
// here to either the passed columns, or the standard default of retrieving
// all of the columns on the table using the "wildcard" column character.
if (is_null($this->columns)) {
$this->columns = $columns;
}
// Drop all columns if * is present, MongoDB does not work this way.
if (in_array('*', $this->columns)) {
$this->columns = array();
}
// Compile wheres
$wheres = $this->compileWheres();
// Use MongoDB's aggregation framework when using grouping or aggregation functions.
if ($this->groups or $this->aggregate) {
$group = array();
// Add grouping columns to the $group part of the aggregation pipeline.
if ($this->groups) {
foreach ($this->groups as $column) {
$group['_id'][$column] = '$' . $column;
// When grouping, also add the $last operator to each grouped field,
// this mimics MySQL's behaviour a bit.
$group[$column] = array('$last' => '$' . $column);
}
} else {
// If we don't use grouping, set the _id to null to prepare the pipeline for
// other aggregation functions.
$group['_id'] = null;
}
// Add aggregation functions to the $group part of the aggregation pipeline,
// these may override previous aggregations.
if ($this->aggregate) {
$function = $this->aggregate['function'];
foreach ($this->aggregate['columns'] as $column) {
// Translate count into sum.
if ($function == 'count') {
$group['aggregate'] = array('$sum' => 1);
} else {
$group['aggregate'] = array('$' . $function => '$' . $column);
}
}
} else {
foreach ($this->columns as $column) {
$key = str_replace('.', '_', $column);
$group[$key] = array('$last' => '$' . $column);
}
}
// Build the aggregation pipeline.
$pipeline = array();
if ($wheres) {
$pipeline[] = array('$match' => $wheres);
}
$pipeline[] = array('$group' => $group);
// Apply order and limit
if ($this->orders) {
$pipeline[] = array('$sort' => $this->orders);
}
if ($this->offset) {
$pipeline[] = array('$skip' => $this->offset);
}
if ($this->limit) {
$pipeline[] = array('$limit' => $this->limit);
}
if ($this->projections) {
$pipeline[] = array('$project' => $this->projections);
}
// Execute aggregation
$results = $this->collection->aggregate($pipeline);
// Return results
return $results['result'];
} else {
if ($this->distinct) {
// Return distinct results directly
$column = isset($this->columns[0]) ? $this->columns[0] : '_id';
// Execute distinct
$result = $this->collection->distinct($column, $wheres);
return $result;
} else {
$columns = array();
// Convert select columns to simple projections.
foreach ($this->columns as $column) {
$columns[$column] = true;
}
// Add custom projections.
if ($this->projections) {
$columns = array_merge($columns, $this->projections);
}
// Execute query and get MongoCursor
$cursor = $this->collection->find($wheres, $columns);
// Apply order, offset and limit
if ($this->timeout) {
$cursor->timeout($this->timeout);
}
if ($this->orders) {
$cursor->sort($this->orders);
}
if ($this->offset) {
$cursor->skip($this->offset);
}
if ($this->limit) {
$cursor->limit($this->limit);
}
// Return results as an array with numeric keys
return iterator_to_array($cursor, false);
}
}
}
/**
* Execute the query as a fresh "select" statement.
*
* @param array $columns
* @return array|static[]
*/
public function getFresh($columns = [])
{
// If no columns have been specified for the select statement, we will set them
// here to either the passed columns, or the standard default of retrieving
// all of the columns on the table using the "wildcard" column character.
if (is_null($this->columns)) {
$this->columns = $columns;
}
// Drop all columns if * is present, MongoDB does not work this way.
if (in_array('*', $this->columns)) {
$this->columns = [];
}
// Compile wheres
$wheres = $this->compileWheres();
// Use MongoDB's aggregation framework when using grouping or aggregation functions.
if ($this->groups or $this->aggregate or $this->paginating) {
$group = [];
// Add grouping columns to the $group part of the aggregation pipeline.
if ($this->groups) {
foreach ($this->groups as $column) {
$group['_id'][$column] = '$' . $column;
// When grouping, also add the $last operator to each grouped field,
// this mimics MySQL's behaviour a bit.
$group[$column] = ['$last' => '$' . $column];
}
// Do the same for other columns that are selected.
foreach ($this->columns as $column) {
$key = str_replace('.', '_', $column);
$group[$key] = ['$last' => '$' . $column];
}
}
// Add aggregation functions to the $group part of the aggregation pipeline,
// these may override previous aggregations.
if ($this->aggregate) {
$function = $this->aggregate['function'];
foreach ($this->aggregate['columns'] as $column) {
// Translate count into sum.
if ($function == 'count') {
$group['aggregate'] = ['$sum' => 1];
} else {
$group['aggregate'] = ['$' . $function => '$' . $column];
}
}
}
// When using pagination, we limit the number of returned columns
// by adding a projection.
if ($this->paginating) {
foreach ($this->columns as $column) {
$this->projections[$column] = 1;
}
}
// The _id field is mandatory when using grouping.
if ($group and empty($group['_id'])) {
$group['_id'] = null;
}
// Build the aggregation pipeline.
$pipeline = [];
if ($wheres) {
$pipeline[] = ['$match' => $wheres];
}
if ($group) {
$pipeline[] = ['$group' => $group];
}
// Apply order and limit
if ($this->orders) {
$pipeline[] = ['$sort' => $this->orders];
}
if ($this->offset) {
$pipeline[] = ['$skip' => $this->offset];
}
if ($this->limit) {
$pipeline[] = ['$limit' => $this->limit];
}
if ($this->projections) {
$pipeline[] = ['$project' => $this->projections];
}
$options = ['typeMap' => ['root' => 'array', 'document' => 'array']];
// Execute aggregation
$results = iterator_to_array($this->collection->aggregate($pipeline, $options));
// Return results
return $results;
} elseif ($this->distinct) {
// Return distinct results directly
$column = isset($this->columns[0]) ? $this->columns[0] : '_id';
// Execute distinct
if ($wheres) {
$result = $this->collection->distinct($column, $wheres);
} else {
$result = $this->collection->distinct($column);
}
return $result;
} else {
$columns = [];
// Convert select columns to simple projections.
foreach ($this->columns as $column) {
$columns[$column] = true;
}
// Add custom projections.
if ($this->projections) {
$columns = array_merge($columns, $this->projections);
}
$options = [];
// Apply order, offset, limit and projection
if ($this->timeout) {
$options['maxTimeMS'] = $this->timeout;
}
if ($this->orders) {
$options['sort'] = $this->orders;
}
if ($this->offset) {
$options['skip'] = $this->offset;
}
if ($this->limit) {
$options['limit'] = $this->limit;
}
if ($columns) {
$options['projection'] = $columns;
}
// if ($this->hint) $cursor->hint($this->hint);
// Fix for legacy support, converts the results to arrays instead of objects.
$options['typeMap'] = ['root' => 'array', 'document' => 'array'];
// Execute query and get MongoCursor
$cursor = $this->collection->find($wheres, $options);
// Return results as an array with numeric keys
return iterator_to_array($cursor, false);
}
}
$productIds = [];
foreach ($products as $product) {
$productIds[] = $product['product_id'];
}
$products = $qb->select('p')->andWhere('p.id IN (:product_ids)')->setParameter(':product_ids', $productIds)->getQuery()->execute();
break;
case 'doctrine/mongodb-odm':
$client = new MongoClient();
$database = $container->getParameter('mongodb_database');
$db = $client->{$database};
$productCollection = new MongoCollection($db, PIM_CATALOG_PRODUCT);
$variantGroupIds = $container->get('pim_catalog.repository.group')->getAllVariantGroupsQB()->select('g.id')->getQuery()->execute(null, AbstractQuery::HYDRATE_ARRAY);
array_walk($variantGroupIds, function (&$value) {
$value = $value['id'];
});
$selectedProducts = $productCollection->aggregate([['$unwind' => '$groupIds'], ['$match' => ['groupIds' => ['$in' => $variantGroupIds]]], ['$group' => ['_id' => '$normalizedData.' . $identifierCode, 'variant_count' => ['$sum' => 1]]], ['$match' => ['variant_count' => ['$gt' => 1]]]])['result'];
$productIdentifiers = [];
foreach ($selectedProducts as $product) {
$productIdentifiers[] = $product['_id'];
}
$products = $container->get('pim_catalog.doctrine.query.product_query_factory')->create()->addFilter($identifierCode, 'IN', $productIdentifiers)->execute();
break;
default:
throw new \LogicException(sprintf('Unknown storage driver %s (supported storage drivers : doctrine/orm and doctrine/mongodb-odm)', $storageDriver));
}
$output = new ConsoleOutput();
if (count($products) > 0) {
$output->writeln(sprintf('%s products are in more than one variant group. This is not permitted anymore', count($products)));
$output->writeln('Products in more than one variant group :');
$lines = [];
$tableHelper = new TableHelper();
public function testPipeline()
{
$result = $this->collection->aggregate(['$group' => ['_id' => 'foo', 'sum' => ['$sum' => '$foo']]]);
$this->assertEquals(4, $result['result'][0]['sum']);
}
/**
* aggregate框架指令达成
*
* @return mixed
*/
public function aggregate($pipeline, $op = NULL, $op1 = NULL)
{
if (!$this->_noAppendQuery) {
if (isset($pipeline[0]['$geoNear'])) {
$first = array_shift($pipeline);
array_unshift($pipeline, array('$match' => array('__REMOVED__' => false)));
array_unshift($pipeline, $first);
} else {
array_unshift($pipeline, array('$match' => array('__REMOVED__' => false)));
}
}
return parent::aggregate($pipeline);
}
function mkonegrp($db, $colname, $query, $grouparr)
{
$ops = array();
$ops[] = ['$match' => $query];
// $ops[] = ['$sort' => ['year'=> -1, 'month'=> -1]];
$ops[] = ['$group' => $grouparr];
$option = ['allowDiskUse' => true];
//print_r($ops);
$collection = new MongoCollection($db, $colname);
echo "working on: {$colname} ... with";
$col2name = $colname . "_agg";
$col2 = new MongoCollection($db, $col2name);
//print_r($grouparr['_id']);
//makegrpIndex($db, $col2, $grouparr['_id']);
try {
$cursor = $collection->aggregate($ops, $option);
} catch (MongoException $e) {
echo "error message: " . $e->getMessage() . "\n";
echo "error code: " . $e->getCode() . "\n";
exit(1);
}
$results = $cursor['result'];
foreach ($results as $key => $val) {
foreach ($val as $skey => $sval) {
if ($skey == '_id') {
$r = $sval;
} else {
$r[$skey] = $sval;
}
}
//print_r($r);
$col2->insert($r);
}
}
