标签: aggregation

我有这种格式的大文本文件:

aaa bbb 1      
aaa ccc 2      
aaa ddd 3      
bbb ww 1      
bbb kio 3      

我想聚合它,结果应该是:

aaa bbb 1/6  
aaa ccc 2/6  
aaa ddd 3/6  
bbb ww 1/4  
bbb kio 3/4  

第3列 - 概率p(y | x)

我应该怎么用awk,sed呢？

让我们假设我已经拥有了包含几个子程序的Child包和Parent包.这两个包通过聚合组合在一起,就像在perltoot:

use warnings;
use strict;

package Child;

sub new {
    my ($class, %arg) = @_;
    return bless { %arg }, $class;
}

sub method_x {
    warn 'call method x';
}

sub method_y {
    warn 'call method y';
}

sub method_z {
    warn 'call method z';
}

1;


package Parent;

sub new {
    my ($class, %arg) = @_;
    return bless {
        child => undef,
        %arg,
    }, $class;
}

sub child { shift->{child} }
sub x …

我想创建一个列表，其中包含多个代理以及他们拨打的电话数量，如下所示：

public class Agent
{
    public string Agent_ID{ get; set; }
    public string Name { get; set; }
    public int Calls { get; set; }

}

var list = new List<Agent>() // To create a list to hold the data
{ 
    new Agent() { Agent_ID = "TK_J", Name = "James", Calls = 10 },
    new Agent() { Agent_ID = "TK_K", Name = "Kurtis", Calls = 10 },
    new Agent() { Agent_ID = "TK_R", Name = "Rebecca", Calls = 5 }, …

我正在尝试进行一些聚合查询并遇到一些问题。

GET /my_index/_search
{
"size" : 0,
"aggs":{
   "group_by":{
       "terms": {
            "field" : "category"
       }
   }
  }
  }

这让我回来了：

"hits": {
  "total": 180,
  "max_score": 0,
  "hits": []
 },
"aggregations": {
  "group_by": {
     "doc_count_error_upper_bound": 0,
     "sum_other_doc_count": 1,
     "buckets": [
        {
           "key": "pf_rd_m",
           "doc_count": 139
        },
        {
           "key": "other",
           "doc_count": 13
        },
        {
           "key": "_encoding",
           "doc_count": 12
        },
        {
           "key": "ie",
           "doc_count": 10
        },
        {
           "key": "cadeaux",
           "doc_count": 2
        },
        {
           "key": "cartes",
           "doc_count": 2
        },
        {
           "key": "cheques",
           "doc_count": 2
        }, …

我们使用 ElasticSearch 根据 5 个字段查找报价，例如一些“自由文本”、报价状态和客户名称。我们还需要聚合客户名称和报价状态这两个字段。因此，当有人输入一些自由文本时，我们发现 10 个文档的状态为关闭，8 个文档的状态为打开，“状态过滤器”应包含 close(10) 和 open(8)。

现在的问题是，当我选择状态“关闭”包含在过滤器中时，打开的聚合结果更改为0。我希望它保持为8。那么如何防止聚合上的过滤器影响聚合本身？

这是第一个查询，搜索“java”：

{
    "query": {
        "bool": {
            "filter": [
            ],
            "must": {
                "simple_query_string": {
                    "query" : "java"
                }
            }
        }
    },
    "aggs": {
        "OFFER_STATE_F": {
            "terms": {
                "size": 0,
                "field": "offer_state_f",
                "min_doc_count": 0
            }
        }
    },
    "from": 0,
    "size": 1,
    "fields": ["offer_id_ft", "offer_state_f"]
}

结果是这样的：

{
  "hits": {
    "total": 960,
    "max_score": 0.89408284000000005,
    "hits": [
      {
        "_type": "offer",
        "_index": "select",
        "_id": "40542",
        "fields": {
          "offer_id_ft": [
            "40542"
          ],
          "offer_state_f": [ …

假设我有以下代码：

class A {
public:
    void doSomething(B* b);
}

class B {
}

我将如何在 UML 图中描述这一点？我的第一个想法是 A 使用 B，所以从 A 到 B 应该有一条虚线。 但是在一些学校论文中（这是学校作业报告中很小的一部分），他们似乎使用了聚合符号（空菱形和实线）。

这对我来说似乎不对——如果 A 实际上包含一个指向 B 的指针作为成员，那似乎是对的。但是当只有某些方法使用指向 B 的指针，并且不将其存储在任何成员变量中时，这似乎是错误的。

这里有什么？

（我可以问我的老师，但他们通常需要很长时间才能回答此类问题……老实说，我更信任 Stackoverflow 的集体智囊团 :)）

我正在通过以下链接找出组合和聚合之间的区别。

https://www.geeksforgeeks.org/association-composition-aggregation-java/

我能够理解，组合意味着一种关系，其中孩子不能独立于父母而存在，而聚合意味着一种关系，其中孩子可以独立于父母而存在。但无法理解如何以编程方式区分。下面是链接中给出的聚合和组合的示例。在这两种情况下，除了 Student 和 Department 类有一个额外的变量“name”外，这两种类的结构相同。如在组合中“子不能独立于父而存在”，但是在这里，我可以创建一个单独的 Book 对象并使用它，而无需将其添加到 Library。

聚合

// student class
class Student 
{
    String name;
    int id ;
    String dept;

    Student(String name, int id, String dept) 
    { 
        this.name = name;
        this.id = id;
        this.dept = dept;
    }
}



/* Department class contains list of student
Objects. It is associated with student
class through its Object(s). */
class Department 
{
    String name;
    private List<Student> students;

    Department(String name, List<Student> students) 
    {
        this.name = name;
        this.students = students;    
    } …

我是spark scala的新手，我有以下情况我在集群上有一个表“TEST_TABLE”（可以是hive表）我正在将它转换为数据帧：

scala> val testDF = spark.sql("select * from TEST_TABLE limit 10")

现在可以将 DF 视为

scala> testDF.show()

COL1|COL2|COL3  
----------------
abc|abcd|abcdef 
a|BCBDFG|qddfde 
MN|1234B678|sd

我想要一个像下面这样的输出

COLUMN_NAME|MAX_LENGTH
       COL1|3
       COL2|8
       COL3|6

在 spark scala 中这样做是否可行？

我正在尝试向我的网站添加类似功能。我用以下模式制作了一个喜欢的集合。我使用自定义 _id 来避免创建额外的索引。

{
  _id: {
    postId: ObjectId,
    userId: ObjectId
  }
}

我的服务器上有一个路由，它使用 MongoDB聚合搜索帖子集合。我正在尝试向当前管道添加一个$lookup阶段，以便添加一个带有布尔类型的喜欢属性，指示用户是否喜欢该帖子。这里的$查找未工作阶段（喜欢返回一个空数组全偶的时候有一个相应的像文件）：

{
  $lookup: {
    from: 'likes',
    let: { likedPostId: '$_id.postId', likerUserId: '$_id.userId' },
    pipeline: [
      { $match:
        { $expr:
          { $and:
            [
              { $eq: [
                '$$likerUserId',
                  ObjectId('12345')
              ]},
              { $eq: [
                  '$$likedPostId',
                  '$_id'
              ]}
            ]
          }
        }
      }
    }
  ],
  as: 'liked'
  }
}