相关疑难解决方法(0)

我想知道一个'正常'的内部连接是否会导致MySQL查询中的执行性能更高,而不是简单的查询,其中列出所有表,然后使用'和t1.t2id = t2.id'等连接它们.

我是一个新的编写SQL,我有一个关于连接的问题.这是一个选择示例:

select bb.name from big_box bb, middle_box mb, little_box lb
where lb.color = 'green' and lb.parent_box = mb and mb.parent_box = bb;

所以我要说的是,我正在寻找所有大盒子的名字,这些盒子里面嵌套着一个绿色的小盒子.如果我理解正确,上面的语法是通过使用'join'关键字获得相同结果的另一种方法.

问题:上面的select语句是否对它正在进行的任务有效？如果没有,有什么更好的方法呢？是连接的语句语法糖还是实际上正在做其他事情？

如果你有关于这个主题的任何好材料的链接,我很乐意阅读它,但由于我不知道究竟是什么称这种技术,我在谷歌上搜索它有困难.

考虑这两个类似的SQL

(ON条款中的条件)

select t1.field1, t2.field1
from
table1 t1 inner join table2 t2 on t1.id = t2.id and t1.boolfield = 1

(WHERE子句中的条件)

select t1.field1, t2.field1
from
table1 t1 inner join table2 t2 on t1.id = t2.id
where t1.boolfield = 1

我已经对此进行了一些测试,我可以看到将条件放在外部连接的两个不同位置之间的区别.但是在内连接的情况下,结果集可能会有所不同吗？

可能重复:
INNER JOIN与WHERE子句 - 有什么区别吗？
SQL JOIN:USING,ON或WHERE有区别吗？

例如,我有这样的SQL声明:

SELECT *  
  FROM orders, inventory  
 WHERE orders.product = inventory.product

要么

SELECT *  
  FROM orders  
  JOIN inventory  
    ON orders.product = inventory.product

这两者有什么区别？

这两个代码之间有什么不同吗

select a.firstname,
       a.lastname,
       b.salary,
       b.designation
from table a,
     table b
where a.id = b.id

和

select a.firstname,
       a.lastname,
       b.salary,
       b.designation
from table a inner join table b on a.id = b.id

我的数据库结构如下所示：

用户<->个人<->学校

因此，个人对象会像这样保存有关用户和学校的信息：

class Personal
{
   /**
    * @var integer
    *
    * @ORM\Column(name="id", type="integer")
    * @ORM\Id
    * @ORM\GeneratedValue(strategy="AUTO")
    */
   private $id;

   /**
    * @var string
    *
    * @ORM\ManyToOne(targetEntity="user", inversedBy="schools", fetch="EAGER")
    */
   private $user;

   /**
    * @var string
    *
    * @ORM\ManyToOne(targetEntity="school", inversedBy="personal", fetch="EAGER")
    */
   private $school;
}

所以我想获取用户的学校：

$query = $qb
   ->select('school')
   ->from('AppBundle:School', 'school')
   ->leftJoin('school.personal', 'p', 'WITH', 'p.user = :user')
   ->setParameters(array(':user' => $user))
   ->getQuery();

我还尝试了以下方法：

$query = $qb
   ->select('school')
   ->from('AppBundle:School', 'school')
   ->leftJoin('u.personal', 'personal')
   ->leftJoin('personal.user', 'pu')
   ->where('pu = :user')
   ->setParameters(array(':user' => $user)) …

SELECT *
FROM TableOne
INNER JOIN TableTwo ON TableOne.ForeignKeyID = TableTwo.PrimaryKeyID
WHERE TableTwo.SomeColumnOne = 12345;

要么

SELECT *
FROM TableOne
INNER JOIN TableTwo ON TableOne.ForeignKeyID = TableTwo.PrimaryKeyID
AND TableTwo.SomeColumnOne = 12345;

我更喜欢第一种方法,因为JOIN告诉我们两个表应该如何绑定在一起,同时WHERE告诉我们如何过滤结果集.但这两者之间是否有任何性能差异？或者为什么我们应该更喜欢一个而不是另一个？

提前致谢!

select * from StudySQL.dbo.id_name n
inner join StudySQL.dbo.id_sex s
on n.id=s.id
and s.sex='f'

select * from StudySQL.dbo.id_name n
inner join StudySQL.dbo.id_sex s
on n.id=s.id
where s.sex='f'

结果是一样的.那么他们之间有什么区别？

加

我做了几个有趣的尝试.

select * from StudySQL.dbo.id_name n

1 | baby
3 | alice

select * from StudySQL.dbo.id_class c

1 | math      
3 | physics   
3 | english   
4 | chinese 


select * from StudySQL.dbo.id_name n
left join StudySQL.dbo.id_class c
on n.name='alice'

name  id    id  class
baby    1   NULL    NULL
alice   3   1           math …

我的SQL Server数据库中有3个表.

它们链接在一起,如图所示(线条连接到图片中的右侧行)

我有一个查询,它应该返回所有补偿tblreparations信息,其中包含有关修复内容的一些信息,但它会返回3次修复,一次为客户端(荷兰语中的klant)分配给它的每台笔记本电脑,而补偿表(荷兰语的修理)laptopID每行只包含一个

这是查询:

SELECT AankopenReparaties.Id, 
       AankopenReparaties.KlantenId, 
       AankopenReparaties.actietype, 
       AankopenReparaties.voorwerptype, 
       laptopscomputers.merk, 
       laptopscomputers.model, 
       laptopscomputers.info, 
       AankopenReparaties.info, 
       AankopenReparaties.Prijs, 
       AankopenReparaties.lopend 
FROM AankopenReparaties, laptopscomputers 
WHERE (aankopenreparaties.lopend = 'lopend');

它返回这个

它应该只有一行,因为赔偿表(aankopenreparaties)只包含一行一个 laptopID

有谁知道如何解决这一问题？

请帮助,因为它应尽快修复(这是学校的任务)

我在下面的两个查询和相同的执行计划中都得到相同的结果，有什么区别吗？还是我更喜欢写查询？

SELECT PS.StepID,PR.ProgramID FROM ProgramSteps PS, Programs PR
WHERE PS.ProgramID = PR.ProgramID

SELECT PS.StepID,PR.ProgramID FROM ProgramSteps PS
INNER JOIN Programs PR ON PS.ProgramID = PR.ProgramID

如果表可以基本上是内连接的,因为where子句排除了所有不匹配的记录,所以使用以下2个查询语句语法样式中的第一个确切地说有多糟糕:

SELECT {COLUMN LIST}
FROM TABLE1 t1, TABLE2 t2, TABLE3 t3, TABLE4 t4 (etc)
WHERE t1.uid = t2.foreignid
AND t2.uid = t3.foreignid
AND t3.uid = t4.foreignid
etc

代替

SELECT {COLUMN LIST}
FROM TABLE1 t1
INNER JOIN TABLE2 t2 ON t1.uid = t2.foreignid
INNER JOIN TABLE3 t3 ON t2.uid = t3.foreignid
INNER JOIN TABLE4 t4 ON t3.uid = t4.foreignid

我不确定这是否仅限于微软SQL,甚至是特定版本,但我的理解是第一个场景执行完全外部联接以使所有可能的相关性都可访问.

我过去使用过第一种方法来优化查询,这些查询可以访问两个非常大的数据存储区,每个存储区都有外围表连接到它们,这些连接的产品在查询的后期汇集在一起​​.通过允许每个"较大"表连接到它们各自的查找表,并且只组合每个较大表的特定子集,我发现在特定过滤之前将大表引入彼此有显着的速度改进.

在正常(简单连接)情况下,使用第二种情况会不会更好？我发现它更容易阅读,看起来它会更快.

这是我的情况,我有一个名为Statuses(statusID, statusName)的表有22个状态,还有其他表有statusID列.

现在,客户希望将Statuses表中的所有22种状态合并为13种状态.然后我们必须更新,确切地说,映射statusID所有其他表中的所有.

有人可以帮我从这里出去吗？