标签: aggregation

当多路调用多个子对象时,什么是阻止循环样板代码的优雅方法？

问题描述示例:

struct Foo {
  void Boo();
  void Hoo();
  bool IsActivated();
};

struct FooAggregator {
  ...
  void Boo();
  void Hoo();
  ...
  std::vector<Foo> m_foos;
};

FooAggregator::Boo() {
  for(size_t i=0, e=m_foos.size(); i!=e; ++i) {
    if(m_foos[i].IsActivated()) {
      m_foos[i].Boo();
    }
  }
}

FooAggregator::Hoo() {
  for(size_t i=0, e=m_foos.size(); i!=e; ++i) {
    if(m_foos[i].IsActivated()) {
      m_foos[i].Hoo();
    }
  }
}

如您所见,FooAggregator实现与单个Foo相同(相似)的接口,迭代调用其各自成员函数的所有Foo对象.

正如您所看到的,迭代循环是完整的样板,为FooAggregator的每个成员函数重复.

从FooAggregators成员函数的实现中删除样板的优雅方法是什么

我用来做那种-的melt和cast所有的时间,而这个时候,我正在寻找一个整齐的衬垫.

require(reshape)
# first I melt some data:
m <- melt(mtcars, id.vars = c("cyl", "am"), measure.vars = "hp")
# then cast it:
cast(m, cyl + am ~ ., each(min, mean, sd, max))
  cyl am min      mean       sd max
1   4  0  62  84.66667 19.65536  97
2   4  1  52  81.87500 22.65542 113
3   6  0 105 115.25000  9.17878 123
4   6  1 110 131.66667 37.52777 175
5   8  0 150 194.16667 33.35984 245
6   8  1 …

ElasticSearch基于查询的所有命中来独立于from和size参数构建聚合结果.这是我们在大多数情况下想要的,但我有一个特殊情况,我需要将聚合限制在前N个命中.限制过滤器不适合,因为它不能获取最佳N项,而只能获取与查询匹配的第一个X(每个分片),而与其分数无关.

有没有办法构建一个命中数具有上限N的查询,以便能够构建限制在那些前N个结果中的聚合？如果是这样怎么样？

附属问题:限制匹配文件的分数可能是另一种选择,即使在我的情况下我需要一个固定的界限.min_score参数是否会影响聚合？

嗨,我在尝试执行下面的查询时收到此错误.任何想法或建议？

错误:"在包含外部引用的聚合表达式中指定了多个列.如果正在聚合的表达式包含外部引用,则该外部引用必须是表达式中引用的唯一列."

SELECT TestInstances.pkTestInstanceID AS 'pkTestInstanceID',
               bands.pkPerformanceLevelReportBandID AS 'BandID',
               bands.StackPosition AS 'StackPosition',
               (SELECT TOP 100 PERCENT SUM(CASE WHEN bands.StackPosition = b.StackPosition THEN 1 ELSE 0 END) * 100/ CASE WHEN COUNT(StudentScores_Subject.pkStudentScoreID) = 0 THEN 1 ELSE COUNT(StudentScores_Subject.pkStudentScoreID) END
                FROM PerformanceLevelReportBands b 
                WHERE b.fkPerformanceLevelReportID = @intPerfLevelReportId
                ORDER BY SUM(CASE WHEN bands.StackPosition = b.StackPosition THEN 1 ELSE 0 END) * 100/ CASE WHEN COUNT(StudentScores_Subject.pkStudentScoreID) = 0 THEN 1 ELSE COUNT(StudentScores_Subject.pkStudentScoreID) END) AS 'Percent',
         COUNT(StudentScores_Subject.pkStudentScoreID) AS 'Count'
         FROM StudentScores_Subject
                INNER JOIN StudentTests ON …

我创建了一个名为test包含prices嵌套字段的类型.

每个文件可以包含多个价格,每个价格包括price和date:

...
"prices":[{  
      "date" : "2017-02-08T16:04:20.424Z",
      "price" : 120
   },
   {  
      "date" : "2017-02-08T17:35:01.424Z",
      "price" : 70
   }]
...

我正在尝试创建一个搜索查询,首先将每个文档的价格汇总到最小值price,然后使用线性衰减函数对聚合返回的所有最小值进行评分

我目前在所有文档上都有一个聚合查询:

{
    "query": {
        "match_all": {}
    },
    "aggs" : {
        "prices" : {
            "nested" : {
                "path" : "prices"
            },
            "aggs" : {
                "min_price" : { "min" : { "field" : "prices.price" } }
            }
        }
    }
}

返回最低价格test.

还有一个线性衰减函数,prices可以对未聚合的所有文档的嵌套进行评分:

{
  "query": {
    "nested": { …

我注意到很多关于COM的书籍等都指出，在COM聚合中实现一个可以用作内部对象的对象相对容易。但是，除非我遗漏了一些东西，否则聚合似乎只能在极其有限的场景中成功，因此只有在明确认识到这种场景时才应提供对它的支持。

困扰我的部分如下。COM 聚合将内部对象的标识与外部对象的标识组合在一起。外部对象的实现者选择内部对象接口的子集，并将对这些接口的请求转发给内部对象。内部对象将所有对接口的请求转发到外部对象。现在假设内部对象作为其实现的一部分构造子 COM 对象。据推测，一个接口指针被传递给该 COM 对象，以便它可以与其父对象进行通信。内部对象对其实现的接口有一些了解。然而，外部对象可能选择不转发其中一些接口。事实上，文档指出外部对象不应盲目转发接口。这似乎意味着内部对象通常不能将接口指针传递给其他 COM 对象，除非特别要求外部对象将所有这些接口转发给内部对象。这不限于子对象场景。实际上，内部对象实现传递接口指针的任何地方似乎都可能受到影响。

因此，聚合似乎不是通用目的，因为——在内部对象必须与其他 COM 对象通信的情况下——它对外部对象提出了严格的要求，即必须最少转发哪些接口，并且不能将更多接口添加到这个列表在内部对象的未来版本中不会破坏与不转发这些接口的现有外部对象的兼容性。

这是对事物实际情况的正确（并且很少被记录）描述还是故事有更多内容？

在 Elasticsearch 中，我们使用了术语 facet 和术语聚合来解决上述问题。不幸的是，这肯定适用于小数据集。但我们正在处理大约 1000 万份文件的数据。

因此，当我们通过使用聚合（设置“大小”：0）或方面（使用“排除”）查询以获取字段（例如公司字段）的所有唯一值时，我们将无法获得整个结果拉紧。似乎 elasticsearch 需要很多时间来响应，最终导致节点故障。

此过程的唯一目的是计算字段中存在多少唯一值（例如公司、唯一公司的数量）。

任何建议将是可观的。

我正在按标签聚合产品搜索结果，标签有名称和 ID 字段。如何将两个字段都返回到聚合存储桶中？我可以得到一个，但我不知道如何得到两个。顺便说一句，我的集群上的脚本访问已关闭，因此我无法使用它。

这是我的产品映射（针对此问题进行了简化）：

"mappings": {
    "products": {
        "properties": { 
            "title": {
                "type": "string"
            },
            "description": {
                "type": "string"
            },
            "topics": {
                "properties": {
                    "id": {
                        "type": "string",
                        "index": "not_analyzed"
                    },
                    "name": {
                        "type" : "string",
                        "index": "not_analyzed"
                    }
                }
            }
        }
    }
}

这是我的查询：

"query": {
    "multi_match": {
        "query": "Testing 1 2 3",
        "fields": ["title", "description"]
    },
    "aggs": {
        "Topics": {
            "terms": {
                "field": "topics.id",
                "size": 15
            }
        }
    }
}

我的聚合桶如下所示：

...第一个桶中的“键”值是topics.id 字段值。有没有办法将我的 topic.name 字段添加到存储桶？

我正在使用 Java instanceof，但它似乎不起作用。

我有三个扩展 Hero 类的 Java 类。
该Hero.java类：

public abstract class Hero {

    protected int health;

    public Hero() { 
    }
}

其他三类：

public class Archer extends Hero {
    public Archer() {
    }
}

public class Mage extends Hero {
    public Mage() {
    }
}

public class Warrior extends Hero {
    public Warrior() {
    }
}

我有这个主类WelcomeScreen.java

public class WelcomeScreen {

    private Archer archer;
    private Mage mage;
    private Warrior warrior;
    private Hero …

在我的 mongodb 查询中，我使用 $addFields 添加由其他三个字段连接的 ID 字段。我的问题是，如果我将新添加的字段与我要查询的值匹配，则不会得到任何结果。对于其他领域，它们工作得很好。

聚合顺序

什么是聚合

data = await model.aggregate([
            {
                $project: {
                    projectName: 1,
                    price: 1,
                    'document': '$$ROOT'
                }
            },
            {
                $addFields:{
                    'document.id': {$concat: ['$document.propertyId.prefix','$document.propertyId.number']}
                }
            },
            {
                $match: {
                    $and: [
                        {
                            $or: [
                                {id: {$regex: '.*' + req.query.search + '.*', $options: "i"}},
                                {projectName: {$regex: '.*' + req.query.search + '.*', $options: "i"}},

                                /*This also doesnt work*/
                                // {'document.id': {$regex: '.*' + req.query.search + '.*', $options: "i"}},
                                // {'document.projectName': {$regex: '.*' + req.query.search + '.*', $options: …