标签: outer-join

在这篇维基百科文章SQL join之后,我希望能够清楚地了解如何与data.table建立联接.在这个过程中,我们可能在加入NAs时发现了一个错误.以wiki为例:

R) X = data.table(name=c("Raf","Jon","Ste","Rob","Smi","Joh"),depID=c(31,33,33,34,34,NA),key="depID")
R) Y = data.table(depID=c(31,33,34,35),depName=c("Sal","Eng","Cle","Mar"),key="depID")
R) X
   name depID
1:  Joh    NA
2:  Raf    31
3:  Jon    33
4:  Ste    33
5:  Rob    34
6:  Smi    34
R) Y
   depID depName
1:    31     Sal
2:    33     Eng
3:    34     Cle
4:    35     Mar

LEFT OUTER JOIN

R) merge.data.frame(X,Y,all.x=TRUE)
  depID name depName
1    31  Raf     Sal
2    33  Jon     Eng
3    33  Ste     Eng
4    34  Rob     Cle
5    34  Smi     Cle
6    NA …

我已经搜索了这个简单问题的答案,但找不到类似的问题.我有3个数据表:

set.seed(0)
demo <- data.table(id = 1:10, demo.var = rnorm(10), key = 'id'); demo
lab <- data.table(id = 1:7, tc = rnorm(7), key = 'id'); lab
anthro <- data.table(id = 4:9, bmi = rnorm(6), key = 'id'); anthro

lab和anthro中的所有ID都在demo data.table中,但lab和anthro在演示中包含不同的ID子集

都

lab[demo]
anthro[demo]

提供我想要的信息:所有10个ID以及来自实验室或anthro data.table的附加信息,但是有没有以类似的方式将所有3个合并在一起？我尝试了一些排列,例如

anthro[lab][demo]

但是这只保留了实验室数据中的ID的anthro信息.表 - 对于ID 8和9没有人为信息

在此先感谢您的帮助

在CentOS 6上的PostgreSQL 9中,pref_users表中有60000条记录:

# \d pref_users
                   Table "public.pref_users"
   Column   |            Type             |     Modifiers      
------------+-----------------------------+--------------------
 id         | character varying(32)       | not null
 first_name | character varying(64)       | not null
 last_name  | character varying(64)       | 
 login      | timestamp without time zone | default now()
 last_ip    | inet                        | 
 (... more columns skipped...)

另一张桌子可容纳大约500名用户,不允许再玩游戏:

# \d pref_ban2
                 Table "public.pref_ban2"
   Column   |            Type             |   Modifiers   
------------+-----------------------------+---------------
 id         | character varying(32)       | not null
 first_name | character varying(64)       | 
 last_name  | character varying(64) …

使用MySQL 5.x我想有效地从表X中选择所有行,其中表Y中没有相关行满足某些条件,例如

给我X中的所有记录,其中不存在与foo = bar相关的Y.

SELECT count(id) FROM X
LEFT OUTER JOIN Y ON y.X_id = X.id AND y.foo = 'bar'
WHERE y....?

据我所知,左外连接保证为左(第一)表中的每一行产生一行 - 在这种情况下为X - 是否找到了连接表中令人满意的行.我想要做的只是选择那些没有找到行的行.

在我看来,如果没有匹配的记录,y.X_id应为NULL,但此测试似乎不起作用.y.X_id = 0或!y.X_id也不是.

编辑:纠正的转录错误(ON不是AS),这是由几个回答指出的.修正了语法错误.

以下两句话:

hello there
bye!

在表sentence_words中表示:

WORD_ID  SENTENCE_ID    WORD    WORD_NUMBER
10       1              hello   1
11       1              there   2
12       2              bye!    1

我想做一个外连接查询,给我结果:

WORD1      WORD2
hello      there
bye!       NULL

请注意,我可能想在句子的中间开始,所以我不能假设word2有word_number = 2.如果我选择my_start_number = 2那么查询应该给我:

WORD1   WORD2
there   NULL

我试过了:

(my_start_number = 1)

select  s1.word word1, s2.word word2
from sentence_words s1
left join sentence_words s2
on s1.sentence_id = s2.sentence_id
where s1.word_number = my_start_number
 and (s2.word_number = s1.word_number +1 or s2.word_number is null);

如果句子中有两个单词,那只会给我一个结果.我不知道该怎么做并不复杂.

一些SQL代码:

SELECT *
FROM table1 tab1 
   LEFT OUTER JOIN table2 tab2 ON (tab1.fg = tab2.fg)
   LEFT OUTER JOIN table4 tab4 ON (tab1.ss = tab4.ss)
   INNER JOIN table3 tab3 ON (tab4.xya = tab3.xya)
   LEFT OUTER JOIN table5 tab5 ON (tab4.kk = tab5.kk)

我知道不同类型的JOIN会做什么,但我想知道的是:对于每个JOIN,哪个表承担"LEFT"表的作用？将table1永远具有"LEFT"表的作用？

与此问题类似:内部加入clojure

是否有任何Clojure库中的地图集合执行外连接(左,右和完全)的功能？

我想这可以通过修改代码来完成,clojure.set/join但这似乎是一个很常见的要求,因此检查它是否已经存在是值得的.

像这样的东西:

(def s1 #{{:a 1, :b 2, :c 3}
          {:a 2, :b 2}})

(def s2 #{{:a 2, :b 3, :c 5}
          {:a 3, :b 8}})


;=> (full-join s1 s2 {:a :a})
;
;   #{{:a 1, :b 2, :c 3}
;     {:a 2, :b 3, :c 5}
;     {:a 3, :b 8}}

左右外连接的适当函数,即包括nil左,右或两侧的连接键没有值(或值)的条目.

如果我写一个sql:

select * 
from a,b 
where     a.id=b.id(+) 
      and b.val="test"

并且我希望b中相应记录所在的所有记录都不存在或者存在val ="test",这是正确的查询吗？

嗨,我在这里比较新,并尝试用numpy做一些计算.我从一个特定的计算中经历了很长的时间,并且无法以任何更快的方式实现同​​样的事情.

基本上它是光线三角形交叉算法的一部分,我需要从两个不同大小的矩阵计算所有矢量交叉产品.

我使用的代码是:

allhvals1 = numpy.cross( dirvectors[:,None,:], trivectors2[None,:,:] )

其中dirvectors是的阵列n* vectors (xyz)和trivectors2是的阵列m*vectors(xyz).allhvals1是一个大小的交叉产品的数组n*M*vector (xyz).这有效,但速度很慢.它本质上是来自每个阵列的每个向量的n*m矩阵.希望你明白.根据参数的不同,每个的大小从大约1-4000变化(我基本上根据大小对dirvectors进行分块).

任何建议表示赞赏 不幸的是,我的矩阵数学有点不稳定.

我正在阅读Michael Dippery @ 2015的书"Professional Swift".在第25页的书中,他写道:

"break和continue语句都会从最里面的循环中断开.但是,你可以标记循环,这样你就可以突破外循环了"

let data = [[3,9,44],[52,78,6],[22,91,35]]
let searchFor = 78
var foundVal = false

outer: for ints in data {
    inner: for val in ints {
        if val == searchFor {
            foundVal = true
            break outer
        }
    }
}

if foundVal {
    print("Found \(searchFor) in \(data)")
} else {
    print("Could not find \(searchFor) in \(data)")
}

但是,当我改变时,在操场上:

break outer 

代码到

break inner

出现相同的结果:

发现 78 in [[3, 9, 44], [52, 78, 6], [22, 91, 35]]

还有必要 …