标签: aggregate-functions

我有一个数据框，我想从中提取最大值、最小值并计算其中的记录数。

数据框是：

scala> val df = spark.range(10000)
df: org.apache.spark.sql.Dataset[Long] = [id: bigint]

为了获取我正在使用的所需值df.select()，如下所示：

scala> df.select(min("id"), max("id"), count("id")).show
+-------+-------+---------+
|min(id)|max(id)|count(id)|
+-------+-------+---------+
|      0|   9999|    10000|
+-------+-------+---------+

这给了我正确的结果，但是当我尝试时df.agg()它也给了我相同的答案。

scala> df.agg(min("id"), max("id"), count("id")).show
+-------+-------+---------+
|min(id)|max(id)|count(id)|
+-------+-------+---------+
|      0|   9999|    10000|
+-------+-------+---------+

所以，我的问题是它们之间有什么区别df.select()，df.agg()如果它们提供相同的结果，我应该使用哪一个以获得更好的性能？

请帮我解决这个错误。

SELECT StateProvince,STRING_AGG(AddressID, ',') WITHIN GROUP (ORDER BY AddressID)
FROM [SalesLT].[Address] GROUP BY StateProvince;

我找不到其中的错误，但它说

“(”附近的语法不正确。

我有这张表：

CREATE TABLE my_table (
    id uuid PRIMARY KEY,
    name text NOT NULL,
    key text NOT NULL,
    x int NOT NULL,
    y int NOT NULL,
    UNIQUE (name, key)
);

有了这个数据：

id 名称 键 xy
12345678-abcd-1234-abcd-123456789000 富一 1 2
12345678-abcd-1234-abcd-123456789001 富 b 3 4
12345678-abcd-1234-abcd-123456789002 富c 5 6
12345678-abcd-1234-abcd-123456789003 富德 7 8
12345678-abcd-1234-abcd-123456789004 条 v 0 0
12345678-abcd-1234-abcd-123456789005 酒吧 w 1 1
12345678-abcd-1234-abcd-123456789006 巴 z 2 2
12345678-abcd-1234-abcd-123456789007 巴兹 8 7
12345678-abcd-1234-abcd-123456789008 巴兹 b 6 5
12345678-abcd-1234-abcd-123456789009 巴兹 c 4 3 …

我有一张员工表。请在下面找到表结构和数据。

我想找到最高工资和最低工资以及员工姓名。

预期输出将是：

为了找出最高工资以及员工姓名，我编写了以下查询：

SELECT name,salary FROM  employee where salary
= (select max(salary) from employee);

为了找出最低工资以及员工姓名，我编写了以下查询：

SELECT name,salary FROM  employee where salary
= (select min(salary) from employee);

但我无法合并这两个查询。

有人可以指导我构建 SQL 查询，该查询将返回最高工资和最低工资以及员工姓名吗？

我正在尝试按日期字符串进行分组并计算每个日期有多少数据。

首先，我将 ISOdate 转换为日期字符串：

db.test.aggregate([
    {
        $project: {
                yearMonthDay: { $dateToString: { format: "%Y-%m-%d", date: "$file_date" } }
        }
    },
])

结果：

到目前为止一切都很好，直到我这样做：

db.closing_nassau.aggregate([
    {
        $project: {
                yearMonthDay: { $dateToString: { format: "%Y-%m-%d", date: "$detail.file_date" } }
        }
    },
    { $group: { date: "$yearMonthDay", count: { $sum: 1 } } },
])

一直显示：

"message" : "字段‘日期’必须是累加器对象”

我认为这应该有效。我首先将 ISOdate 转换为日期字符串。我按日期字符串分组并计算每个日期。我尝试删除它count: { $sum: 1 }，但它仍然显示相同的错误，因此问题出在分组依据上。

请随时询问更多信息以帮助我。

我有一张带有结构的大桌子

CREATE TABLE t (
  id SERIAL primary key ,
  a_list int[] not null,
  b_list int[] not null,
  c_list int[] not null,
  d_list int[] not null,
  type int not null 
)

我想查询a_list, b_list, c_list,中的所有唯一值，d_list如下type所示

    select 
        some_array_unique_agg_function(a_list), 
        some_array_unique_agg_function(b_list), 
        some_array_unique_agg_function(c_list), 
        some_array_unique_agg_function(d_list),
        count(1) 
    where type = 30

例如对于这个数据

+----+---------+--------+--------+---------+------+
| id | a_list  | b_list | c_list | d_list  | type |
+----+---------+--------+--------+---------+------+  
| 1  | {1,3,4} | {2,4}  | {1,1}  | {2,4,5} | 30 …

我的数据库中有两个表

第一个是people有列的

id: int,
name: varchar(10)

另一个relationships代表单向跟随的存在

me: int
following: int

其中me和是与 table 中 person 的主键following匹配的外键。idpeople

我想运行一个查询，给定一个id人，返回他们的姓名、他们关注的人数以及关注他们的人数。

我目前的尝试是

id: int,
name: varchar(10)

但它引发了有关 where 语法的错误。我想我需要group by在某个地方使用，但我正在努力了解它如何在多个表上工作。

所以说鉴于id=2它会返回[{name: "sam", followers: 4, following: 3}]

我是 firebase 的新手，我想为喜欢计数创建一个聚合函数。

我有三个根集合：提要、喜欢和用户。

feeds 具有以下字段：

description: <description of feed>

likeCount:<Total count of like>

title: <feed title>

userId: <userId of feed>

Likes 有以下字段：

feedId: <id of the feed where a user gives like>

likeBy: <id of the user who likes the feed>

likeTo: <id of the user how created a feed>

用户有以下字段：

username: <User name>

email: <User email>

当用户喜欢某个提要时，就会在喜欢集合中添加新条目。

我正在尝试创建一个聚合函数，以便increase likeCount in feed collection用户在提要上给出喜欢的信息。

我正在检查解决方案。我找到了嵌套结构的解决方案，如下所示

所以，我的问题是，是否可以使用我的数据结构（三个根集合：提要、喜欢和用户）为喜欢计数创建一个聚合函数？如果是的话我怎样才能实现它？

或者我需要更改我的数据结构吗？

无法显示输出，包括没有销售的区域。

一家保险公司保存其员工的销售记录。每个雇员都被分配到一个州。州按地区分组。下表包含数据：

TABLE regions
  id INTEGER PRIMARY KEY
  name VARCHAR(50) NOT NULL

TABLE states
  id INTEGER PRIMARY KEY
  name VARCHAR(50) NOT NULL
  regionId INTEGER NOT NULL REFERENCES regions(id)

TABLE employees
  id INTEGER PRIMARY KEY
  name VARCHAR(50) NOT NULL
  stateId INTEGER NOT NULL REFERENCES states(id)

TABLE sales
  id INTEGER PRIMARY KEY
  amount INTEGER NOT NULL
  employeeId INTEGER NOT NULL REFERENCES employees(id)  

管理层需要一份比较区域销售分析报告。

编写一个返回的查询：

The region name.
Average sales per employee for the region (Average sales = Total sales made for the …

我有一个包含数组值列的表（在 group by 和 array_agg 函数之后）

COLUMN_VALUE          | other_columns...
-----------:          | -------:
 {0.45,0.45,0.97,0.99}|        ..
 {0.45,0.45,0.85,0.99}|        ..
 {0.45,0.45,0.77,0.99}|        ..
 {0.45,0.45,0.10,0.99}|        ..

如何获得最频繁的值？（本例中每行 0.45）

我的猜测再次是 unnest 和 groupby，但我正在尝试找到更强大、更快的东西。

我用来构建表的查询

COLUMN_VALUE          | other_columns...
-----------:          | -------:
 {0.45,0.45,0.97,0.99}|        ..
 {0.45,0.45,0.85,0.99}|        ..
 {0.45,0.45,0.77,0.99}|        ..
 {0.45,0.45,0.10,0.99}|        ..