标签: cross-join

假设我的表中有以下行

表行

id
63
64
65
66
67
68

如果我运行以下查询,我会得到30行.

SELECT r1.id, r2,id 
  FROM rows AS r1 
    CROSS JOIN rows AS r2 
  WHERE r1.id!=r2.id

结果:

63  64
65  64
66  64
67  64
68  64
64  63
65  63
66  63
67  63
68  63
63  65
64  65
66  65
67  65
68  65
63  66
64  66
65  66
67  66
68  66
63  67
64  67
65  67
66  67
68  67
63  68
64  68
65 …

我正在使用带有Spring Data Jpa的Query DSL QueryDslPredicateExecutor

我有以下实体;

@Table(name="a_table")
@Entity
public class A {

     @OneToOne
     @JoinColumn(name = "b_id")
     private B b;
}

@Table(name="b_table")
@Entity
public class B {

     @Column(...)
     private String name;
}

当我构建Predicate传递到我的存储库时,我做了类似的事情.

QA qa = QA.a;
BooleanBuilder booleanBuilder = new BooleanBuilder();       
for(String name : strings) {
    BooleanExpression b_name_eq= qa.b.name.eq(name);
    BooleanExpression some_other_expression = ...;
    booleanBuilder.or(ExpressionUtils.and(b_name_eq, some_other_expression));
}
return booleanBuilder.getValue();

这会产生如下查询

select ... , ... , ...
from a_table at
cross join b_table bt  
where at.b_id=bt.id 
and (bt.name=? and some_other_expression …

我有一个需要计算基于电影内容的相似性的Spark工作.有46k电影.每部电影由一组SparseVectors表示(每个矢量是电影场之一的特征向量,例如Title,Plot,Genres,Actors等).例如,对于Actors和Genres,向量显示给定的actor是否在电影中存在(1)或不存在(0).

任务是为每部电影找到前10个类似的电影.我设法在Scala中编写一个脚本来执行所有这些计算并完成工作.它适用于较小的电影集,如1000部电影,但不适用于整个数据集(内存不足等).

我进行此计算的方法是在电影数据集上使用交叉连接.然后通过仅获取movie1_id <movie2_id的行来减少问题.此时数据集仍然包含46000 ^ 2/2行,即1058000000.每行都有大量数据.

然后我计算每一行的相似度得分.在计算相似度之后,我将movie1_id相同的结果分组,并按照相似性得分的降序对它们进行排序,使用前N个项目的Window函数(类似于此处描述的方式:Spark获得每个项目的前N个最高得分结果(item1,item2) ,得分)).

问题是 - 它可以在Spark中更有效地完成吗？例如,无需执行crossJoin？

还有一个问题--Spark如何处理如此庞大的数据帧(1058000000行由多个SparseVectors组成)？是否必须一次将所有这些保留在内存中？或者它是否以某种方式逐个处理这样的数据帧？

我正在使用以下函数来计算电影矢量之间的相似性:

def intersectionCosine(movie1Vec: SparseVector, movie2Vec: SparseVector): Double = {
val a: BSV[Double] = toBreeze(movie1Vec)
val b: BSV[Double] = toBreeze(movie2Vec)

var dot: Double = 0
var offset: Int = 0
while( offset < a.activeSize) {
  val index: Int = a.indexAt(offset)
  val value: Double = a.valueAt(offset)

  dot += value * b(index)
  offset += 1
}

val bReduced: BSV[Double] = new BSV(a.index, a.index.map(i => b(i)), a.index.length)
val maga: Double …

可以说我有一个table1:

  id      name
-------------
  1       "one"
  2       "two"
  3       "three"

和第一个table2外键:

id    tbl1_fk    option   value
-------------------------------
 1      1         1        1
 2      2         1        1
 3      1         2        1
 4      3         2        1

现在我想作为查询结果:

table1.id | table1.name | option | value
-------------------------------------
      1       "one"        1       1
      2       "two"        1       1
      3       "three"    
      1       "one"        2       1
      2       "two"    
      3       "three"      2       1

我如何实现这一目标？

我已经尝试过:

SELECT
  table1.id,
  table1.name,
  table2.option,
  table2.value
FROM table1 AS table1
LEFT outer JOIN table2 …

有两个表彼此无关(无外键).如何在MySQL中一起显示它们？

表格1

TABLE2

结果

我试图通过两个set-returns函数得到一个"交叉连接",但在某些情况下我没有得到"交叉连接",请参阅示例

行为1:当设置的长度相同时,它会逐个匹配每个集合中的项目

postgres=# SELECT generate_series(1,3), generate_series(5,7) order by 1,2;
 generate_series | generate_series 
-----------------+-----------------
               1 |               5
               2 |               6
               3 |               7
(3 rows)

行为2:当设置的长度不同时,它会"交叉连接"这些集合

postgres=# SELECT generate_series(1,2), generate_series(5,7) order by 1,2;
 generate_series | generate_series 
-----------------+-----------------
               1 |               5
               1 |               6
               1 |               7
               2 |               5
               2 |               6
               2 |               7
(6 rows)

我想我在这里不了解一些事情,有人可以解释一下这种行为吗？

编辑:另一个例子,比以前更奇怪

postgres=# SELECT generate_series(1,2) x, generate_series(1,4) y order by x,y;
 x | y 
---+---
 1 | 1
 1 | 3 …

是否可以使用 linq 进行交叉连接，其中连接数事先未知？

我有这个：

var arrays = new List<string[]>();

如果我知道我可以做三个列表：

var oQuery = from x in arrays[0]
    from y in arrays[1]
    from z in arrays[2]
    select new {x, y, z};

是否可以n使用 linq连接字符串数组？

希望有人可以帮助我在 Google 表格中使用笛卡尔积。我的数据位于两个单独的列中，并希望在单独的选项卡中创建两列的所有可能组合。第一列是 ID（文本），第二列是日期格式。输出应该是两个单独的列。该公式应该是动态的，即当新的 ID 或日期添加到输入列表时列表应该更新。

我在网上寻找解决方案，但尚未找到有效的解决方案。我精通 Excel，但不太精通 Google Sheet :)

这是一个示例表：https://docs.google.com/spreadsheets/d/150uIg3XH1hxZa8vSxDhcVZVOcSEOp175OPYL4Rc-wWI/edit ?usp=sharing

我的查询有问题。我有两个表，我想加入它们以根据第一个表上的主键获取结果，但我缺少第一个表中的 1 个数据。

这是我的小提琴

正如你所看到的，我从第一个月开始就缺少“xx3”

我尝试更改左连接和右连接，但结果仍然相同。正如你所看到的，coalesce(sum(b.sd_qty),0) as total,如果没有qty，我必须设置0为默认值。

在这种情况下，我需要帮助来用新行填充缺失值：

这只是一个例子，但我有很多行具有不同的IDs.

输入数据框：

所以我有一组有限的dates，我想直到每个的最后一个ID（在示例中，对于ID = 123：01/01/2021、01/02/2021、01/03/2021...直到01/08/2021 ）。所以基本上我可以与日历进行交叉联接，但我不知道在交叉联接之​​后如何使用规则或过滤器填充缺失值。

预期输出：（以粗体显示生成的缺失值）