想象一下,我有一个包含{id,username,firstname,lastname}的客户的数据库表
如果我想找到有多少个不同名字的实例我可以做:
select firstname, count(*) from Customers group by 2 order by 1;
firstname | count(*)
====================
bob | 1
jeff | 2
adam | 5
如何计算多次出现的名字数量？在伪sql中它将是这样的:
select
COUNT(
firstname,
count(*) as num_occurrences
)
from
Customers
group by 2
having num_occurrences > 1;
有没有办法编写强类型的 SQL Server 存储过程（即返回列的已知结果集）并使其组语句是动态的。
就像是：
SELECT SUM( Column0 ) FROM Table1
GROUP BY @MyVar
我也尝试了以下方法：
SELECT SUM( Column0 ) FROM Table1
GROUP BY CASE @MyVar WHEN 'Column1' THEN Column1 ELSE Column2
第二条语句仅适用于 Column1 和 Column2 的数据库类型相同的场景。如果它们不是 SQL 引擎，则会抛出类似于以下内容的错误：“将 nvarchar 值 'SYSTEM' 转换为数据类型 [The Different TYPE] 时，转换失败。”
我能做些什么来获得强大的结果集，同时又拥有一些动态的部分——即我的情况下的石斑鱼？这将暴露给 LINQ。
编辑：
看起来你可以做到，但你不应该！绝对矫枉过正。测试显示执行计划慢了一千倍。并且它只会随着更大的结果集而变慢。
我有一个有点愚蠢的问题.如果我有一个矩阵(或数据框,哪个更容易使用),如:
Year Match
2008 1808
2008 137088
2008 1
2008 56846
2007 2704
2007 169876
2007 75750
2006 2639
2006 193990
2006 2
而且我想总结这些年来的每一场比赛(所以,例如,2008年的比赛是这样的,2008 195743我将如何做到这一点？我脑子里有一些解决方案,但它们都是不必要的复杂和R趋势有一些更简单的解决方案隐藏在某个地方.
您可以使用以下内容生成相同的矩阵:
structure(c(2008L, 2008L, 2008L, 2008L, 2007L, 2007L, 2007L,
2006L, 2006L, 2006L, 1808L, 137088L, 1L, 56846L, 2704L, 169876L,
75750L, 2639L, 193990L, 2L), .Dim = c(10L, 2L), .Dimnames = list(
NULL, c("Year", "Match")))
谢谢你尽你所能的帮助.
我有以下数据:
> dput(bla)
structure(list(V1 = structure(c(4L, 4L, 4L, 2L), .Label = c("DDDD",
"EEEE", "NNNN", "PPPP", "ZZZZ"), class = "factor"), V2 = c(100014096L,
100014098L, 100014099L, 100014995L), V3 = c(0.742, 0.779, 0.744,
0.42), V4 = c(1.077, 1.054, 1.049, 0.984), V5 = c(0.662, 0.663,
0.671, 0.487), V6 = c(1.107, 1.14, 1.11, 0.849), V7 = c(0.456,
0.459, 0.459, 1.278)), .Names = c("V1", "V2", "V3", "V4", "V5",
"V6", "V7"), class = "data.frame", row.names = c(NA, 4L))
> bla
V1 V2 V3 V4 V5 V6 V7 …如标题所示，我正在使用Express我的webapp。
目前，我的代码如下所示：
API控制器
var mongoose = require('mongoose');
var Doc = mongoose.model('Document');
var sendJSONresponse = function(res, status, content) {
res.status(status);
res.json(content);
};
// "/api/documents"
module.exports.listAllDocuments = function(req, res) {
var stream = Doc.find().stream();
stream.on('data', function (chunk) {
res.write(JSON.stringify(chunk));
}).on('error', function (err) {
console.log('Error: ' + err);
}).on('end', function () {
res.end();
});
};
var stream = Doc.find().stream();我希望利用而不是使用aggregate()。
像一样find()，aggregate()应该是可读流，对吗？
但是，当我简单地find()用一个aggregate()电话代替时，它似乎不起作用。
它说类型错误：Object #<Aggregate> has no method 'stream'。有什么方法可以流式传输聚合的JSON数据 …
我需要在五个列上加入两个实体，并且需要在SELECT中的每一列上加上GROUP BY，并在每个GROUP BY上获得一个COUNT。尽管这对SQL来说对我来说是小菜一碟，但我却对我为LINQ找到的每个示例都感到困惑。
我发现了以下两个问题（在多个列[重复]上的C＃Linq分组依据和在多个列上分组），但我仍然对如何执行此操作感到困惑。这是我的SQL语句：
SELECT o.org_hq_name,
o.org_command_name,
o.org_region_name,
o.org_installation_name,
o.org_site_name,
o.org_subsite_name,
o.org_hq_id,
o.org_command_id,
o.org_region_id,
o.org_installation_id,
o.org_site_id,
count(org_site_id) AS count
FROM organization o, asset a
WHERE o.org_hq_id = hq_org_id
AND o.org_command_id = a.command_org_id
AND o.org_region_id = a.region_org_id
AND o.org_installation_id = a.installation_org_id
AND o.org_site_id = a.site_org_id
GROUP BY o.org_hq_name,
o.org_command_name,
o.org_region_name,
o.org_installation_name,
o.org_site_name,
o.org_subsite_name,
o.org_hq_id,
o.org_command_id,
o.org_region_id,
o.org_installation_id,
o.org_site_id
我在下面有一个加入：
var join1 = from m in context.asset
join o in context.organization
on new {hqID = a.hq_org_id, commandID = …我有一个包含5列的数据集:
store_id year event item units
123 2015 sale_2 abc 2
234 2015 sale_3 def 1
345 2015 sale_2 xyz 5
我想转出items的store_id, year, and event获得sum.例如
store_id year event abc def xyz
123 2015 sale_2 7 0 0
234 2015 sale_2 2 1 0
我无法找出最好的方法.通常我会在插入符号中使用dummyVars来执行此操作,但我需要总和而不是标记.我看了tapply但它不能处理超过2个分组变量.
还有其他建议吗？
如何df使用分区的Spark计算列中String的出现次数id？
例如,找到a "test"列"name"中的值df
在SQL中将是:
SELECT
SUM(CASE WHEN name = 'test' THEN 1 else 0 END) over window AS cnt_test
FROM
mytable
WINDOW window AS (PARTITION BY id)
我试过用了 map( v => match { case "test" -> 1.. })
和类似的东西:
def getCount(df: DataFrame): DataFrame = {
val dfCnt = df.agg(
.withColumn("cnt_test",
count(col("name")==lit('test'))
)
这是一项昂贵的操作吗？什么是检查特定字符串出现然后执行操作的最佳方法(sum, max, min, etc)？
谢谢
在Spark的文档中，聚合器：
抽象类Aggregator [-IN，BUF，OUT]扩展了Serializable
用户定义的聚合的基类，可以在数据集操作中使用该基类来获取组中的所有元素并将它们减少为单个值。
UserDefinedAggregateFunction为：
抽象类UserDefinedAggregateFunction扩展了Serializable
实现用户定义的聚合函数（UDAF）的基类。
根据Dataset Aggregator-Databricks的说法，“聚合器类似于UDAF，但是接口以JVM对象而不是Row的形式表示。”
看来这两个类非常相似，除了接口中的类型以外还有什么其他区别？
一个类似的问题是：UDAF与聚合器在Spark中的性能
我正在尝试根据ID对实体进行分组，运行下面的代码，我有此数据框：
val pet_type_count = pet_list.groupBy("id","pets_type").count()
pet_type_count.sort("id").limit(20).show
+----------+---------------------+-----+
| id| pets_type|count|
+----------+---------------------+-----+
| 0| 0| 2|
| 1| 0| 3|
| 1| 3| 3|
| 10| 0| 4|
| 10| 1| 1|
| 13| 0| 3|
| 16| 1| 3|
| 17| 1| 1|
| 18| 1| 2|
| 18| 0| 1|
| 19| 1| 7|
+----------+---------------------+-----+
我想按ID对分组的结果进行分组，现在返回每个ID的元组列表，因此我可以对每个ID应用以下udf：
val agg_udf = udf { (v1: List[Tuple2[String, String]]) =>
var feature_vector = Array.fill(5)(0)
for (row <- v1) {
val index = (5 - …