精华内容
下载资源
问答
  • SQL Server数据库操作中,在2005以上的版本新增加了一个APPLY表运算符的功能
  • 今天小编就为大家分享一篇关于Python中出现IndentationError:unindent does not match any outer indentation level错误的解决方法,小编觉得内容挺不错的,现在分享给大家,具有很好的参考价值,需要的朋友一起跟随...
  • 对于SQL中inner join、outer join和cross join的区别很多人不知道,我也是别人问起,才查找资料看了下,跟自己之前的认识差不多,如果你使用join连表,缺陷的情况下是inner join,另外,开发中使用的left join和right...
  • free-outernet, 自由软件Outernet接收器 免费 outernet自由软件Outernet接收器这是一个免费的软件( 开放源代码) 接收器,用于 Outernet,用于与 gr Outernet/接收器调制解调器一起工作。 正式Outernet接收软件的关键...
  • SQL中的left outer join,inner join,right outer join用法详解
  • This article will provide a full overview, with examples of the SQL Outer join, including the full, right and left outer join as well as cover the union between SQL left and right outer joins. ...

    This article will provide a full overview, with examples of the SQL Outer join, including the full, right and left outer join as well as cover the union between SQL left and right outer joins.

    本文将提供完整的概述,并提供SQL外连接示例,包括完整,右侧和左侧外部连接,以及SQL左侧和右侧外部连接之间的联合。

    It is essential to understand the process to get the data from the multiple tables. A beginner might not have the idea of Joins in SQL Server. In this tip, we will take an overview of the SQL joins, learn SQL OUTER JOIN along with its syntax, examples, and use cases.

    必须了解从多个表中获取数据的过程。 初学者可能没有在SQL Server中加入连接的想法。 在本文中,我们将概述SQL连接,学习SQL OUTER JOIN及其语法,示例和用例。

    In a relational database system, it is best practice to follow the principles of Normalization, in which, basically, we split large tables into the smaller tables. In a select statement, we can retrieve the data from these tables using joins. We can join the tables and get the required fields from these tables in the result set. These tables should have some common field to relate with each other. You might find data split across multiple databases and sometimes it is a very complex structure as well. With Joins, we can join the data together from the multiple tables, databases into a user-friendly way and represent this data in the application.

    在关系数据库系统中,最佳实践是遵循规范化原则,在该原则中,我们基本上将大表拆分为较小的表。 在select语句中,我们可以使用联接从这些表中检索数据。 我们可以联接表并从结果集中的这些表中获取必填字段。 这些表应具有一些相互关联的公共字段。 您可能会发现数据分散在多个数据库中,有时它也是一个非常复杂的结构。 使用Joins,我们可以将来自多个表,数据库的数据连接在一起,以一种用户友好的方式进行,并在应用程序中表示该数据。

    We can represent a SQL JOIN using the following image

    我们可以使用下图表示一个SQL JOIN

    SQL JOIN

    We can many SQL Join types in SQL Server. In the following image, you can see SQL Joins categories

    我们可以在SQL Server中使用许多SQL Join类型。 在下图中,您可以看到SQL Joins类别

    SQL Join types

    Let’s explore SQL Outer Join in details in the upcoming section.

    让我们在接下来的部分中详细探讨SQL外连接。

    SQL OUTER JOIN概述 (Overview of the SQL OUTER JOIN)

    We use the SQL OUTER JOIN to match rows between tables. We might want to get match rows along with unmatched rows as well from one or both of the tables. We have the following three types of SQL OUTER JOINS.

    我们使用SQL OUTER JOIN来匹配表之间的行。 我们可能想从一个或两个表中获取匹配行以及不匹配行。 我们有以下三种类型SQL OUTER JOINS。

    1. SQL Full Outer Join

      SQL Full外连接
    2. SQL Left Outer Join

      SQL左外部联接
    3. SQL Right Outer Join

      SQL右外部联接

    Let’s explore each of SQL Outer Join with examples.

    让我们通过示例探索每个SQL Outer Join。

    SQL Full外连接 (SQL Full Outer Join)

    In SQL Full Outer Join, all rows from both the tables are included. If there are any unmatched rows, it shows NULL values for them.

    在SQL Full Outer Join中,两个表中的所有行都包括在内。 如果有任何不匹配的行,则显示它们的NULL值。

    We can understand efficiently using examples. Let’s create a sample table and insert data into it.

    我们可以使用示例来有效地理解。 让我们创建一个示例表并将数据插入其中。

    CREATE TABLE [dbo].[Employee](
      [EmpID] [int] IDENTITY(1,1) PRIMARY KEY CLUSTERED,
      [EmpName] [varchar](50) NULL,
      [City] [varchar](30) NULL,
      [Designation] [varchar](30) NULL]
    )
     
    CREATE TABLE Departments
    (EmpID          INT  PRIMARY KEY CLUSTERED , 
     DepartmentID  INT, 
     DepartmentName VARCHAR(50)
    );
    

    You can refer the following data model of both the tables.

    您可以参考以下两个表的数据模型。

    Table models

    Insert data into the Employee table with the following script.

    使用以下脚本将数据插入Employee表。

    Sample data
    USE [SQLShackDemo];
    GO
    SET IDENTITY_INSERT [dbo].[Employee] ON; 
    GO
    INSERT INTO [dbo].[Employee]
    ([EmpID], 
     [EmpName], 
     [City], 
     [Designation]
    )
    VALUES
    (1, 
     N'Charlotte Robinson', 
     N'Chicago', 
     N'Consultant'
    );
    GO
    INSERT INTO [dbo].[Employee]
    ([EmpID], 
     [EmpName], 
     [City], 
     [Designation]
    )
    VALUES
    (2, 
     N'Madison Phillips', 
     N'Dallas', 
     N'Senior Analyst'
    );
    GO
    INSERT INTO [dbo].[Employee]
    ([EmpID], 
     [EmpName], 
     [City], 
     [Designation]
    )
    VALUES
    (3, 
     N'Emma Hernandez', 
     N'Phoenix', 
     N'Senior Analyst'
    );
    GO
    INSERT INTO [dbo].[Employee]
    ([EmpID], 
     [EmpName], 
     [City], 
     [Designation]
    )
    VALUES
    (4, 
     N'Samantha Sanchez', 
     N'San Diego', 
     N'Principal Conultant'
    );
    GO
    INSERT INTO [dbo].[Employee]
    ([EmpID], 
     [EmpName], 
     [City], 
     [Designation]
    )
    VALUES
    (5, 
     N'Sadie Ward', 
     N'San Antonio', 
     N'Consultant'
    );
    GO
    INSERT INTO [dbo].[Employee]
    ([EmpID], 
     [EmpName], 
     [City], 
     [Designation]
    )
    VALUES
    (6, 
     N'Savannah Perez', 
     N'New York', 
     N'Principal Conultant'
    );
    GO
    INSERT INTO [dbo].[Employee]
    ([EmpID], 
     [EmpName], 
     [City], 
     [Designation]
    )
    VALUES
    (7, 
     N'Victoria Gray', 
     N'Los Angeles', 
     N'Assistant'
    );
    GO
    INSERT INTO [dbo].[Employee]
    ([EmpID], 
     [EmpName], 
     [City], 
     [Designation]
    )
    VALUES
    (8, 
     N'Alyssa Lewis', 
     N'Houston', 
     N'Consultant'
    );
    GO
    INSERT INTO [dbo].[Employee]
    ([EmpID], 
     [EmpName], 
     [City], 
     [Designation]
    )
    VALUES
    (9, 
     N'Anna Lee', 
     N'San Jose', 
     N'Principal Conultant'
    );
    GO
    INSERT INTO [dbo].[Employee]
    ([EmpID], 
     [EmpName], 
     [City], 
     [Designation]
    )
    VALUES
    (10, 
     N'Riley Hall', 
     N'Philadelphia', 
     N'Senior Analyst'
    );
    GO
    SET IDENTITY_INSERT [dbo].[Employee] OFF;
    GO
    

    Insert Data into the Departments table

    将数据插入“部门”表

    Sample data
    USE [SQLShackDemo];
    GO
    INSERT INTO [dbo].[Departments]
    ([EmpID], 
     [Department_ID], 
     [DepartmentName]
    )
    VALUES
    (1, 
     0, 
     N'Executive'
    );
    GO
    INSERT INTO [dbo].[Departments]
    ([EmpID], 
     [Department_ID], 
     [DepartmentName]
    )
    VALUES
    (2, 
     1, 
     N'Document Control'
    );
    GO
    INSERT INTO [dbo].[Departments]
    ([EmpID], 
     [Department_ID], 
     [DepartmentName]
    )
    VALUES
    (3, 
     2, 
     N'Finance'
    );
    GO
    INSERT INTO [dbo].[Departments]
    ([EmpID], 
     [Department_ID], 
     [DepartmentName]
    )
    VALUES
    (4, 
     3, 
     N'Engineering'
    );
    GO
    INSERT INTO [dbo].[Departments]
    ([EmpID], 
     [Department_ID], 
     [DepartmentName]
    )
    VALUES
    (5, 
     4, 
     N'Facilities and Maintenance'
    );
    GO
    INSERT INTO [dbo].[Departments]
    ([EmpID], 
     [Department_ID], 
     [DepartmentName]
    )
    VALUES
    (6, 
     2, 
     N'Finance'
    );
    GO
    INSERT INTO [dbo].[Departments]
    ([EmpID], 
     [Department_ID], 
     [DepartmentName]
    )
    VALUES
    (10, 
     4, 
     N'Facilities and Maintenance'
    );
    GO
    

    We can represent a logical relationship between two tables using a Venn diagram. In a Venn diagram contains multiple overlapping circles and each circle represents an entity or table. The common area or overlapping area in Venn diagram represents the common values between both tables.

    我们可以使用维恩图表示两个表之间的逻辑关系。 在维恩图中,包含多个重叠的圆圈,每个圆圈代表一个实体或表格。 Venn图中的公共区域或重叠区域表示两个表之间的公共值。

    For example, in the following screenshot, we have two overlapping circles. Each circle resent a table (Employee and Departments). Let’s understand the FULL Outer Join using the following example.

    例如,在以下屏幕截图中,我们有两个重叠的圆圈。 每个圈子都寄出一张表格(员工和部门)。 让我们使用以下示例了解“完全外部联接”。

    We have a common field ( EmpID) in both the tables; therefore, we can join the table with this column. In the following query, we defined the FULL OUTER JOIN between departments and Employee table on the EMPID column of both the table.

    两个表中都有一个公共字段(EmpID)。 因此,我们可以将此表与该列连接。 在以下查询中,我们在两个表的EMPID列上的部门和Employee表之间定义了FULL OUTER JOIN。

    SELECT *
    FROM Employee
         FULL OUTER JOIN Departments ON Employee.EmpID = Departments.EmpID;
    

    SQL Full Outer Join

    SQL Full Outer Join gives following rows in an output

    SQL Full Outer Join在输出中给出以下行

    • Matching Rows between both the tables

      两个表之间的匹配行
    • Unmatched Rows from both the tables (NULL values)

      两个表中不匹配的行(NULL值)

    Let’s execute this query to return Full Outer Join query output. We get the following output.

    让我们执行此查询以返回“完全外部联接”查询输出。 我们得到以下输出。

    We can see a few records with NULL values as well. Let’s understand this in a better way using a Venn diagram.

    我们还可以看到一些带有NULL值的记录。 让我们使用维恩图更好地理解这一点。

    In the following screenshot, you can see the following information

    在以下屏幕截图中,您可以看到以下信息

    • EmpID 1, 2,3,4,5,6,10 exists in both Employee and Departments table. In Full Outer Join query output, we get all these rows with data from both the tables

      雇员表和部门表中都存在EmpID 1、2、3、4、5、6、10。 在“完全外部联接”查询输出中,我们从两个表中获取了所有这些行以及数据
    • EmpID 7, 8, 9 exists in the Employee table but not in the Departments table. It does not include any matching rows in the departments table; therefore; we get NULL values for those records

      EmpID 7、8、9存在于Employee表中,但不存在于Departments表中。 它在Departments表中不包含任何匹配的行; 因此; 我们获得这些记录的NULL值

    SQL Full Outer Join example

    Now, for demo purpose let’s insert one more record in Departments tables. In this query, we insert EmpID 11 that does not exist in the Employee table.

    现在,出于演示目的,让我们在Departments表中再插入一条记录。 在此查询中,我们插入Employee表中不存在的EmpID 11。

    INSERT INTO [dbo].[Departments]
    ([EmpID], 
     [Department_ID], 
     [DepartmentName]
    )
    VALUES
    (11, 
     4, 
     N'Facilities and Maintenance'
    );
    GO
    

    Rerun the SQL Full Outer Join query. In the following image, you get one additional row with NULL values. We do not have any matching row for EmpID 11 in the employee table. Due to this, we get NULL values for it in the output.

    重新运行SQL Full Outer Join查询。 在下图中,您将获得另外一行具有NULL值的行。 在employee表中没有与EmpID 11相匹配的行。 因此,我们在输出中获得了NULL值。

    SQL Full Outer Join example

    As a summary, we can represent the SQL Full Outer Join using the following Venn diagram. We get what is represented in the highlighted area in the output of Full Outer Join.

    概括来说,我们可以使用以下维恩图表示SQL Full Outer Join。 我们得到“完全外部联接”输出中突出显示的区域中表示的内容。

    SQL Full Outer Join

    SQL FULL OUTER JOIN和WHERE子句 (SQL FULL OUTER JOIN and WHERE clause )

    We can add a WHERE clause with a SQL FULL OUTER JOIN to get rows with no matching data between the both Join tables.

    我们可以添加带有SQL FULL OUTER JOIN的WHERE子句,以获取两个Join表之间没有匹配数据的行。

    In the following query, we add a where clause to show only records having NULL values.

    在以下查询中,我们添加where子句以仅显示具有NULL值的记录。

    SELECT *
    FROM Employee
         FULL OUTER JOIN Departments ON Employee.EmpID = Departments.EmpID
    WHERE Employee.EmpID IS NULL
          OR Departments.EmpID IS NULL;
    

    Execute this command and view the output. It only returns rows that do not match either in Employee or Departments table.

    执行此命令并查看输出。 它仅返回在Employee或Departments表中不匹配的行。

    SQL Full Outer Join example

    SQL左外连接 (SQL LEFT OUTER JOIN)

    In a SQL Left Outer Join, we get following rows in our output.

    在SQL左外部联接中,我们在输出中得到以下行。

    • It gives the output of the matching row between both the tables

      它给出两个表之间匹配行的输出
    • If no records match from the left table, it also shows those records with NULL values

      如果左表中没有记录匹配,则还会显示那些具有NULL值的记录

    Execute the following code to return SQL LEFT OUTER JOIN output

    执行以下代码以返回SQL LEFT OUTER JOIN输出

    SELECT *
    FROM Employee
         LEFT OUTER JOIN Departments ON Employee.EmpID = Departments.EmpID
    

    In the following image, you can see we have NULL values for EmpID 7,8 and 9. These EmpID does not exist in the right side Department table.

    在下图中,您可以看到EmpID 7,8和9具有NULL值。这些EmpID在右侧Department表中不存在。

    SQL LEFT OUTER JOIN

    We need to note the table placement position in the Join statement. Currently, we have an Employee table on the left side and Departments table in Right side.

    我们需要注意Join语句中表的放置位置。 当前,我们在左侧有一个Employee表,在右侧有Departments表。

    Let’s rewrite query and swap the position of tables in query. In this query, we have the Department table in left position, so the Left Outer Join should check the values for this table and return a NULL value in case of a mismatch.

    让我们重写查询并交换表在查询中的位置。 在此查询中,我们的Department表位于左侧,因此Left Outer Join应该检查该表的值,并在不匹配的情况下返回NULL值。

    In the following screenshot, you can see that only one NULL value for EmpID 11. It is because EmpID 11 is not available in the Employee table.

    在下面的屏幕快照中,您可以看到EmpID 11只有一个NULL值。这是因为EmpID 11在Employee表中不可用。

    SQL LEFT OUTER JOIN

    As a summary, we can represent SQL Left Outer Join using the following Venn diagram. We get the highlighted area in the output of SQL Left Outer Join.

    作为总结,我们可以使用下面的维恩图表示SQL Left Outer Join。 我们在SQL Left Outer Join的输出中获得了突出显示的区域。

    SQL LEFT OUTER JOIN

    SQL Right外连接 (SQL Right OUTER JOIN)

    In SQL Right Outer Join, we get the following rows in our output.

    在SQL Right Outer Join中,我们在输出中获得以下行。

    • It gives the output of the matching row between both the tables

      它给出两个表之间匹配行的输出
    • If no records match from the right table, it also shows those records with NULL values

      如果右表中没有记录匹配,则还显示那些具有NULL值的记录

    Execute the following query to get the output of Right Outer Join

    执行以下查询以获取Right Outer Join的输出

    SELECT *
    FROM Employee
         RIGHT OUTER JOIN Departments ON Employee.EmpID = Departments.EmpID
    

    In the following image, you can see we get all matching rows along with one row with NULL values. Null value row has EmpID 11 because it does not exist in the Employee table. You can also notice the position of the Department table is in the right position in Join. Due to this, we do not get values from the Employee table (left position) which does not match with Department table (Right side).

    在下图中,您可以看到我们得到了所有匹配的行以及带有NULL值的一行。 空值行的EmpID为11,因为它在Employee表中不存在。 您还可以注意到“部门”表的位置在“联接”中的正确位置。 因此,我们无法从Employee表(左侧)获得的值与Department表(右侧)不匹配。

    SQL Right OUTER JOIN

    As highlighted earlier, the table position is important in the JOIN statement. If we change the table positions, we get different output. In the following query, we have Departments table (Left) and Employee table (Right).

    如前所述,表位置在JOIN语句中很重要。 如果更改表的位置,则会得到不同的输出。 在以下查询中,我们具有Departments表(左)和Employee表(右)。

    SELECT *
    FROM Departments
         RIGHT OUTER JOIN Employee ON Departments.EmpID = Employee.EmpID
     
    

    You can notice the difference in Right Outer Join after swapping tables positions in above query.

    在上述查询中交换表位置后,您会注意到在右外部联接中的差异。

    SQL Right OUTER JOIN

    As a summary, we can represent the SQL Right Outer Join using the following Venn diagram. We get highlighted area in the output of SQL Right Outer Join.

    作为总结,我们可以使用下面的维恩图表示SQL Right Outer Join。 我们在SQL Right Outer Join的输出中突出显示了区域。

    Right Outer Join

    SQL左外部联接和SQL右外部联接之间的联合 (The union between SQL Left Outer Join and SQL Right Outer Join)

    In the previous examples, we explored the SQL Left Outer Join, and the SQL Right Outer Join with different examples. We can do a Union of the result of both SQL Left Outer Join and SQL Right Outer Join. It gives the output of SQL Full Outer Join.

    在前面的示例中,我们使用不同的示例探讨了SQL Left Outer Join和SQL Right Outer Join。 我们可以对SQL Left Outer Join和SQL Right Outer Join的结果进行并集。 它给出了SQL Full Outer Join的输出。

    Execute the following query as an alternative to SQL Full Outer Join.

    执行以下查询,以替代SQL Full Outer Join。

    SELECT *
    FROM Employee
         LEFT OUTER JOIN Departments ON Employee.EmpID = Departments.EmpID
       UNION ALL
       SELECT *
    FROM Employee
         RIGHT OUTER JOIN Departments ON Employee.EmpID = Departments.EmpID
    

    In the following output, we get all matching records, unmatch records from the left table and unmatch records from the right table. It is similar to an output of SQL Full Outer Join.

    在以下输出中,我们获得所有匹配的记录,左表中的不匹配记录和右表中的不匹配记录。 它类似于SQL Full Outer Join的输出。

    SQL JOIN

    结论 (Conclusion)

    In this article, we explored the SQL Outer Join and its types along with examples. I hope you found this article helpful. Feel free to provide feedback in the comments below.

    在本文中,我们探讨了SQL外连接及其类型以及示例。 希望本文对您有所帮助。 请随时在下面的评论中提供反馈。

    翻译自: https://www.sqlshack.com/sql-outer-join-overview-and-examples/

    展开全文
  • 如何在MySQL中进行FULL OUTER JOIN?

    千次阅读 2020-01-02 13:01:37
    我们不能在mysql上测试它,因为它不支持FULL OUTER JOINs,但是我们可以在支持它的数据库上对此进行说明: WITH cte_t1 AS (    SELECT 1 AS id1    UNION ALL SELECT 2    UNION ALL SELECT 5    ...

    我想在MySQL中进行完全外部联接。 这可能吗? MySQL是否支持完全外部联接?


    #1楼

    在SQLite中,您应该这样做:

    SELECT * 
    FROM leftTable lt 
    LEFT JOIN rightTable rt ON lt.id = rt.lrid 
    UNION
    SELECT lt.*, rl.*  -- To match column set
    FROM rightTable rt 
    LEFT JOIN  leftTable lt ON lt.id = rt.lrid
    

    #2楼

    SELECT
        a.name,
        b.title
    FROM
        author AS a
    LEFT JOIN
        book AS b
        ON a.id = b.author_id
    UNION
    SELECT
        a.name,
        b.title
    FROM
        author AS a
    RIGHT JOIN
        book AS b
        ON a.id = b.author_id
    

    #3楼

    也可以,但必须在select中提及相同的字段名称。

    SELECT t1.name, t2.name FROM t1
    LEFT JOIN t2 ON t1.id = t2.id
    UNION
    SELECT t1.name, t2.name FROM t2
    LEFT JOIN t1 ON t1.id = t2.id
    

    #4楼

    使用union查询将删除重复项,这与从不删除任何重复项的full outer join的行为不同:

    [Table: t1]                            [Table: t2]
    value                                  value
    -------                                -------
    1                                      1
    2                                      2
    4                                      2
    4                                      5
    

    这是full outer join的预期结果:

    value | value
    ------+-------
    1     | 1
    2     | 2
    2     | 2
    Null  | 5
    4     | Null
    4     | Null
    

    这是使用的结果, leftright Joinunion

    value | value
    ------+-------
    Null  | 5 
    1     | 1
    2     | 2
    4     | Null
    

    [SQL Fiddle]

    我建议的查询是:

    select 
        t1.value, t2.value
    from t1 
    left outer join t2  
      on t1.value = t2.value
    union all      -- Using `union all` instead of `union`
    select 
        t1.value, t2.value
    from t2 
    left outer join t1 
      on t1.value = t2.value
    where 
        t1.value IS NULL 
    

    以上查询的结果与预期结果相同:

    value | value
    ------+-------
    1     | 1
    2     | 2
    2     | 2
    4     | NULL
    4     | NULL
    NULL  | 5
    

    [SQL Fiddle]


    @Steve Chambers[评论,非常感谢!]
    注意:这可能是最好的解决方案,从效率和产生与FULL OUTER JOIN相同的结果FULL OUTER JOIN这篇博客文章也很好地解释了这一点-引用方法2: “此方法可以正确处理重复的行,并且不包含不应包含的任何内容。有必要使用UNION ALL而不是普通的UNION ,这样可以消除我想要的重复项保持。对于大型结果集,这可能会显着提高效率,因为无需排序和删除重复项。”


    我决定添加另一种解决方案,该解决方案来自full outer join可视化和数学计算,这不是上面的更好,但更具可读性:

    完全外部联接方式(t1 ∪ t2) :全部在t1t2
    (t1 ∪ t2) = (t1 ∩ t2) + t1_only + t2_onlyt1t2所有内容加上t1中不在t2所有内容,以及t2中不在t1

    -- (t1 ∩ t2): all in both t1 and t2
    select t1.value, t2.value
    from t1 join t2 on t1.value = t2.value    
    union all  -- And plus 
    -- all in t1 that not exists in t2
    select t1.value, null
    from t1
    where not exists( select 1 from t2 where t2.value = t1.value)    
    union all  -- and plus
    -- all in t2 that not exists in t1
    select null, t2.value
    from t2
    where not exists( select 1 from t1 where t2.value = t1.value)
    

    [SQL Fiddle]


    #5楼

    修改了shA.t的查询,以提高清晰度:

    -- t1 left join t2
    SELECT t1.value, t2.value
    FROM t1 LEFT JOIN t2 ON t1.value = t2.value   
    
        UNION ALL -- include duplicates
    
    -- t1 right exclude join t2 (records found only in t2)
    SELECT t1.value, t2.value
    FROM t1 RIGHT JOIN t2 ON t1.value = t2.value
    WHERE t2.value IS NULL 
    

    #6楼

    上述答案实际上都不是正确的,因为当存在重复的值时,它们不遵循语义。

    对于诸如(来自此重复项 )的查询:

    SELECT * FROM t1 FULL OUTER JOIN t2 ON t1.Name = t2.Name;
    

    正确的等效项是:

    SELECT t1.*, t2.*
    FROM (SELECT name FROM t1 UNION  -- This is intentionally UNION to remove duplicates
          SELECT name FROM t2
         ) n LEFT JOIN
         t1
         ON t1.name = n.name LEFT JOIN
         t2
         ON t2.name = n.name;
    

    如果您需要使用NULL值(这可能也是必要的),请使用NULL -safe比较运算符<=>而不是=


    #7楼

    回答:

    SELECT * FROM t1 FULL OUTER JOIN t2 ON t1.id = t2.id;
    

    可以重新创建如下:

     SELECT t1.*, t2.* 
     FROM (SELECT * FROM t1 UNION SELECT name FROM t2) tmp
     LEFT JOIN t1 ON t1.id = tmp.id
     LEFT JOIN t2 ON t2.id = tmp.id;
    

    使用UNION或UNION ALL答案不能解决基本表具有重复条目的情况。

    说明:

    在某些情况下,UNION或UNION ALL无法覆盖。 我们不能在mysql上测试它,因为它不支持FULL OUTER JOINs,但是我们可以在支持它的数据库上对此进行说明:

     WITH cte_t1 AS
     (
           SELECT 1 AS id1
           UNION ALL SELECT 2
           UNION ALL SELECT 5
           UNION ALL SELECT 6
           UNION ALL SELECT 6
     ),
    cte_t2 AS
    (
          SELECT 3 AS id2
          UNION ALL SELECT 4
          UNION ALL SELECT 5
          UNION ALL SELECT 6
          UNION ALL SELECT 6
    )
    SELECT  *  FROM  cte_t1 t1 FULL OUTER JOIN cte_t2 t2 ON t1.id1 = t2.id2;
    
    This gives us this answer:
    
    id1  id2
    1  NULL
    2  NULL
    NULL  3
    NULL  4
    5  5
    6  6
    6  6
    6  6
    6  6
    

    UNION解决方案:

    SELECT  * FROM  cte_t1 t1 LEFT OUTER JOIN cte_t2 t2 ON t1.id1 = t2.id2
    UNION    
    SELECT  * FROM cte_t1 t1 RIGHT OUTER JOIN cte_t2 t2 ON t1.id1 = t2.id2
    

    给出错误的答案:

     id1  id2
    NULL  3
    NULL  4
    1  NULL
    2  NULL
    5  5
    6  6
    

    UNION ALL解决方案:

    SELECT  * FROM cte_t1 t1 LEFT OUTER join cte_t2 t2 ON t1.id1 = t2.id2
    UNION ALL
    SELECT  * FROM  cte_t1 t1 RIGHT OUTER JOIN cte_t2 t2 ON t1.id1 = t2.id2
    

    也不正确。

    id1  id2
    1  NULL
    2  NULL
    5  5
    6  6
    6  6
    6  6
    6  6
    NULL  3
    NULL  4
    5  5
    6  6
    6  6
    6  6
    6  6
    

    而此查询:

    SELECT t1.*, t2.*
    FROM (SELECT * FROM t1 UNION SELECT name FROM t2) tmp 
    LEFT JOIN t1 ON t1.id = tmp.id 
    LEFT JOIN t2 ON t2.id = tmp.id;
    

    提供以下内容:

    id1  id2
    1  NULL
    2  NULL
    NULL  3
    NULL  4
    5  5
    6  6
    6  6
    6  6
    6  6
    

    顺序不同,但是与正确答案匹配。


    #8楼

    我修复了响应,并包括了所有行(基于Pavle Lekic的响应)

        (
        SELECT a.* FROM tablea a
        LEFT JOIN tableb b ON a.`key` = b.key
        WHERE b.`key` is null
        )
        UNION ALL
        (
        SELECT a.* FROM tablea a
        LEFT JOIN tableb b ON a.`key` = b.key
        where  a.`key` = b.`key`
        )
        UNION ALL
        (
        SELECT b.* FROM tablea a
        right JOIN tableb b ON b.`key` = a.key
        WHERE a.`key` is null
        );
    

    #9楼

    您对交叉联接解决方案怎么说?

    SELECT t1.*, t2.*
    FROM table1 t1
    INNER JOIN table2 t2 
    ON 1=1;
    

    #10楼

    MySql没有FULL-OUTER-JOIN语法。 您必须通过执行LEFT JOIN和RIGHT JOIN来模拟,如下所示:

    SELECT * FROM t1
    LEFT JOIN t2 ON t1.id = t2.id  
    UNION
    SELECT * FROM t1
    RIGHT JOIN t2 ON t1.id = t2.id
    

    但是MySql也没有RIGHT JOIN语法。 根据MySql的外部 FROM 简化 ,通过在查询的FROMON子句中切换t1和t2,将右FROM转换为等效的左FROM 。 因此,MySql Query Optimizer会将原始查询转换为以下内容-

    SELECT * FROM t1
    LEFT JOIN t2 ON t1.id = t2.id  
    UNION
    SELECT * FROM t2
    LEFT JOIN t1 ON t2.id = t1.id
    

    现在,按原样编写原始查询没有什么害处,但是如果您有谓词,例如WHERE子句(是连接前的谓词)或ON子句的AND谓词(是连接中的谓词),则您可能想看看魔鬼; 这是详细信息。

    MySql查询优化器会定期检查谓词是否被null拒绝空拒绝定义和示例 现在,如果您已完成RIGHT JOIN,但在t1的列上使用了WHERE谓词,则可能有陷入空值拒绝情况的风险。

    例如,以下查询-

    SELECT * FROM t1
    LEFT JOIN t2 ON t1.id = t2.id
    WHERE t1.col1 = 'someValue'
    UNION
    SELECT * FROM t1
    RIGHT JOIN t2 ON t1.id = t2.id
    WHERE t1.col1 = 'someValue'
    

    由Query Optimizer转换为以下内容-

    SELECT * FROM t1
    LEFT JOIN t2 ON t1.id = t2.id
    WHERE t1.col1 = 'someValue'
    UNION
    SELECT * FROM t2
    LEFT JOIN t1 ON t2.id = t1.id
    WHERE t1.col1 = 'someValue'
    

    因此,表的顺序已更改,但谓词仍适用于t1,但是t1现在位于“ ON”子句中。 如果将t1.col1定义为NOT NULL列,则此查询将被拒绝null

    MySql将任何被null拒绝的外部联接(左,右,完整)转换为内部联接。

    因此,您可能期望的结果可能与MySql返回的结果完全不同。 您可能认为它与MySql的RIGHT JOIN有关,但那是不对的。 这就是MySql查询优化器的工作方式。 因此,负责开发人员在构建查询时必须注意这些细微差别。


    #11楼

    您在MySQL上没有FULL JOINS,但是可以肯定地模拟它们

    对于从该SO问题记录下来的代码SAMPLE,您可以:

    有两个表t1,t2:

    SELECT * FROM t1
    LEFT JOIN t2 ON t1.id = t2.id
    UNION
    SELECT * FROM t1
    RIGHT JOIN t2 ON t1.id = t2.id
    

    上面的查询适用于FULL OUTER JOIN操作不会产生任何重复行的特殊情况。 上面的查询取决于UNION集运算符,以删除查询模式引入的重复行。 我们可以通过对第二个查询使用反联接模式来避免引入重复的行,然后使用UNION ALL集运算符将这两个集合并。 在更一般的情况下,FULL OUTER JOIN将返回重复的行,我们可以这样做:

    SELECT * FROM t1
    LEFT JOIN t2 ON t1.id = t2.id
    UNION ALL
    SELECT * FROM t1
    RIGHT JOIN t2 ON t1.id = t2.id
    WHERE t1.id IS NULL
    

    #12楼

    您可以执行以下操作:

    (SELECT 
        *
    FROM
        table1 t1
            LEFT JOIN
        table2 t2 ON t1.id = t2.id
    WHERE
        t2.id IS NULL)
    UNION ALL
     (SELECT 
        *
    FROM
        table1 t1
            RIGHT JOIN
        table2 t2 ON t1.id = t2.id
    WHERE
        t1.id IS NULL);
    

    #13楼

    SQL标准说full join on是行full join oninner join on union all不匹配的左表行扩展为null,将union all右表行扩展为null。 即行inner join on合并left join on union all行,但不inner join on right join on union all行,但不inner join on

    left join onunion all行, right join onunion all行不在inner join oninner join on 。 或者,如果你知道你的inner join on结果不能在一个特定的右表列空,则“ right join on行没有inner join on ”都行中right join onon条件的延长and该列is null

    即类似地, right join on union all合适的left join on在行right join on联接。

    “内联接”和“外联接”有什么区别?

    (SQL Standard 2006 SQL / Foundation 7.7语法规则1,通用规则1b,3c和d,5b。)


    #14楼

    Pablo Santa Cruz给出的答案是正确的。 但是,如果有人在此页面上跌跌撞撞,想要进一步澄清,请按以下详细分类。

    示例表

    假设我们有下表:

    -- t1
    id  name
    1   Tim
    2   Marta
    
    -- t2
    id  name
    1   Tim
    3   Katarina
    

    内部联接

    内部联接,如下所示:

    SELECT *
    FROM `t1`
    INNER JOIN `t2` ON `t1`.`id` = `t2`.`id`;
    

    只会让我们出现在两个表中的记录,如下所示:

    1 Tim  1 Tim
    

    内连接没有方向(如左或右),因为它们明确地是双向的-我们需要双方都匹配。

    外连接

    另一方面,外部联接用于查找其他表中可能没有匹配项的记录。 这样,您必须指定允许连接的哪一侧具有丢失的记录。

    LEFT JOINRIGHT JOINLEFT OUTER JOINRIGHT OUTER JOIN简写; 我将在下面使用它们的全名来增强外部联接与内部联接的概念。

    左外连接

    左外部联接,如下所示:

    SELECT *
    FROM `t1`
    LEFT OUTER JOIN `t2` ON `t1`.`id` = `t2`.`id`;
    

    ...将使我们从左表获得所有记录,无论它们在右表中是否匹配,如下所示:

    1 Tim   1    Tim
    2 Marta NULL NULL
    

    右外连接

    右外部联接,如下所示:

    SELECT *
    FROM `t1`
    RIGHT OUTER JOIN `t2` ON `t1`.`id` = `t2`.`id`;
    

    ...将使我们从右表中获得所有记录,无论它们在左表中是否匹配,如下所示:

    1    Tim   1  Tim
    NULL NULL  3  Katarina
    

    完全外部加入

    完全外部联接将为我们提供两个表中的所有记录,无论它们是否在另一个表中都有匹配项,并且在两端都没有匹配项的情况下都为NULL。 结果将如下所示:

    1    Tim   1    Tim
    2    Marta NULL NULL
    NULL NULL  3    Katarina
    

    但是,正如Pablo Santa Cruz指出的那样,MySQL不支持此功能。 我们可以通过左连接和右连接的UNION来模拟它,如下所示:

    SELECT *
    FROM `t1`
    LEFT OUTER JOIN `t2` ON `t1`.`id` = `t2`.`id`
    
    UNION
    
    SELECT *
    FROM `t1`
    RIGHT OUTER JOIN `t2` ON `t1`.`id` = `t2`.`id`;
    

    您可以将UNION理解为“运行这两个查询,然后将结果堆叠在一起”; 一些行将来自第一个查询,而某些则来自第二个查询。

    应该注意的是,MySQL中的UNION将消除确切的重复项:Tim将出现在此处的两个查询中,但是UNION的结果仅列出了他一次。 我的数据库专家同事认为不应依赖此行为。 因此,为了更明确一点,我们可以在第二个查询中添加WHERE子句:

    SELECT *
    FROM `t1`
    LEFT OUTER JOIN `t2` ON `t1`.`id` = `t2`.`id`
    
    UNION
    
    SELECT *
    FROM `t1`
    RIGHT OUTER JOIN `t2` ON `t1`.`id` = `t2`.`id`
    WHERE `t1`.`id` IS NULL;
    

    另一方面,如果出于某种原因想要查看重复项,则可以使用UNION ALL

    展开全文
  • NULL 博文链接:https://appofis.iteye.com/blog/467692
  • 本文主要阐述:控制循环结构的break和continue关键字,break outer和continue outer的用法,以及使用return结束方法, 使用break结束循环 break用于完全结束一个循环,跳出循环体。不管是哪种循环结构,只要碰到...

    本文主要阐述:控制循环结构的break和continue关键字,break outer和continue outer的用法,以及使用return结束方法,

    使用break结束循环

    break用于完全结束一个循环,跳出循环体。不管是哪种循环结构,只要碰到break,系统就会完全结束该循环。

    值得注意的是:break默认是完全结束该循环,如果想要直接结束外层循环,则需在外层循环之前增加 outer: 标签,此时break outer结构将直接结束外层循环;

    注意:java中outer标签一定要放在循环前才能起作用;

    例:
    break

    public class BreakTest {
    	public static void main(String[] args) {
    		for (int i = 0; i < 5; i++) {
    			for (int j = 1; j < 5; j++) {
    				System.out.println("此时i="+i+",j="+j);
    				if (j == 2) {
    					break;
    				}
    			}
    		}
    		System.out.println("循环结束");
    	}
    }
    /**
    * 此时i=0,j=1
    * 此时i=0,j=2
    * 此时i=1,j=1
    * 此时i=1,j=2
    * 此时i=2,j=1
    * 此时i=2,j=2
    * 此时i=3,j=1
    * 此时i=3,j=2
    * 此时i=4,j=1
    * 此时i=4,j=2
    * 循环结束
    **/
    

    break outer

    public class BreakTest {
    	public static void main(String[] args) {
    		outer:
    		for (int i = 0; i < 5; i++) {
    			for (int j = 1; j < 5; j++) {
    				System.out.println("此时i="+i+",j="+j);
    				if (j == 2) {
    					break outer;
    				}
    			}
    		}
    		System.out.println("循环结束");
    	}
    }
    /**
    * 输出
    * 此时i=0,j=1
    * 此时i=0,j=2
    * 循环结束
    **/
    

    使用continue结束循环

    与break不同的是, continue只是忽略本次循环的剩余语句,直接开始下一次循环,而不会完全终止该循环,而break是完全终止循环本身。

    同样的是,也可continue outer方式结束循环,outer标签需在某一循环之前定义,它将会忽略outer中所指定的循环中本次循环所剩下的语句,但不会影响下次循环。

    例:
    continue

    public class BreakTest {
    	public static void main(String[] args) {
    		for (int i = 0; i < 3; i++) {
    			for (int j = 1; j < 4; j++) {
    				System.out.println("此时i="+i+",j="+j);
    				if (j == 2) {
    					continue;
    				}
    				System.out.println("内层循环第"+j+"次完整执行");
    			}
    			System.out.println("外层循环第"+(i+1)+"次完整执行");
    		}
    	}
    }
    /*
    此时i=0,j=1
    内层循环第1次完整执行
    此时i=0,j=2
    此时i=0,j=3
    内层循环第3次完整执行
    外层循环第1次完整执行
    此时i=1,j=1
    内层循环第1次完整执行
    此时i=1,j=2
    此时i=1,j=3
    内层循环第3次完整执行
    外层循环第2次完整执行
    此时i=2,j=1
    内层循环第1次完整执行
    此时i=2,j=2
    此时i=2,j=3
    内层循环第3次完整执行
    外层循环第3次完整执行
    */
    

    continue outer

    public class BreakTest {
    	public static void main(String[] args) {
    		outer:
    		for (int i = 0; i < 3; i++) {
    			for (int j = 1; j < 4; j++) {
    				System.out.println("此时i="+i+",j="+j);
    				if (j == 2) {
    					continue outer;
    				}
    				System.out.println("内层循环第"+j+"次完整执行");
    			}
    			System.out.println("外层循环第"+(i+1)+"次完整执行");
    		}
    	}
    }
    /*
    此时i=0,j=1
    内层循环第1次完整执行
    此时i=0,j=2
    此时i=1,j=1
    内层循环第1次完整执行
    此时i=1,j=2
    此时i=2,j=1
    内层循环第1次完整执行
    此时i=2,j=2
    */
    

    使用return结束方法

    与break和continue不同的是,return将直接结束整个方法。不管return处于多少层循环之内,他都将完全结束该方法。

    例:

    public class BreakTest {
    	public static void main(String[] args) {
    		for (int i = 0; i < 3; i++) {
    			System.out.println("第一层循环执行"+(i+1)+"次");
    			for (int j = 0; j < 3; j++) {
    				System.out.println("第二层循环执行"+(j+1)+"次");
    				for (int t = 0; t < 3; t++) {
    					System.out.println("第三层循环执行"+(t+1)+"次");
    					for (int k = 0; k < 3; k++) {
    						System.out.println("第四层循环执行"+(k+1)+"次");
    						return;
    					}
    				}
    			}
    		}
    	}
    }
    /*
    第一层循环执行1次
    第二层循环执行1次
    第三层循环执行1次
    第四层循环执行1次
    */
    
    展开全文
  • outer apply的用法

    千次阅读 2018-04-11 21:31:51
     outer apply(select top 1 material_no,  isnull(ocMaterial.object_name_cn,'') as material_name_cn    from TA04_product_part_bom ppb  left join T200_product_code pc on pc.product_no=ppb.material_...
    IF EXISTS (SELECT * FROM sysobjects WHERE name ='P201_ProductStockRemainFlowQry' and xtype='P') 
    
    DROP PROCEDURE [dbo].[P201_ProductStockRemainFlowQry] 
    go
    /*          
    成品库存流转查询报表取数          
    exec P201_ProductStockRemainFlowQry @strSysNo='447',@strProductNameCn='',@dtEndDate='2018-3-20'          
    */          
    CREATE Proc P201_ProductStockRemainFlowQry(@strSysNo varchar(20),@strProductNameCn varchar(100),          
      @dtEndDate datetime)          
    as           
    Begin            
       print '1:' + convert(varchar(40),getdate(),  121)          
      --取订单(修理包产品)          
      Create table #tbOrderDetail          
      (so_product_no varchar(40),product_no varchar(40),order_num float,destine_num float,delivery_num float,          
       undelivery_num float,delivery_date datetime,product_name_cn varchar(100),ug_product_no varchar(40),
       ug_product_name_cn varchar(100),sale_order_guid varchar(40))          
      Insert Into #tbOrderDetail          
      (so_product_no,product_no,order_num,destine_num,delivery_num,undelivery_num,         
       delivery_date,product_name_cn,ug_product_no,ug_product_name_cn,sale_order_guid)          
      select sod.product_no,rkp.output_product_no1 as product_no,          
             sod.order_num*rkp.output_material_rate1 as order_num,          
             sod.destine_num*rkp.output_material_rate1 as destine_num,          
             sod.delivery_num*rkp.output_material_rate1 as delivery_num,
            (case when sod.order_num-sod.delivery_num>0 then sod.order_num-sod.delivery_num 
                  else 0 end)*rkp.output_material_rate1 as undelivery_num,          
             sod.delivery_date,          
             isnull(ocProduct.object_name_cn,'') as product_name_cn,          
             '' as ug_product_no,          
             '' as ug_product_name_cn,          
             sod.sale_order_guid          
      from T201_sale_order_detail sod           
      inner Join T200_repaire_kit_product rkp on rkp.product_no=sod.product_no and rkp.output_product_no1>''          
      Left Join T200_object_code ocProduct on ocProduct.object_no=rkp.output_product_no1          
      where sod.sys_no=@strSysNo          
       and sod.audit_tag = 'T'          
       and sod.state_type='run'          
       and ocProduct.object_name_cn like '%'+@strProductNameCn+'%'          
       and sod.delivery_date<=@dtEndDate          
       and exists(select  top 1 1 from T200_repaire_kit_product           
                  where product_no=sod.product_no)          
                            
      Insert Into #tbOrderDetail          
      (so_product_no,product_no,order_num,destine_num,delivery_num,undelivery_num,          
       delivery_date,product_name_cn,ug_product_no,ug_product_name_cn,sale_order_guid)          
      select sod.product_no as so_product_no,rkp.output_product_no2 as product_no,          
             sod.order_num*rkp.output_material_rate2 as order_num,          
             sod.destine_num*rkp.output_material_rate2 as destine_num,          
             sod.delivery_num*rkp.output_material_rate2 as delivery_num,
            (case when sod.order_num-sod.delivery_num>0 then sod.order_num-sod.delivery_num 
                  else 0 end)*rkp.output_material_rate2 as undelivery_num,          
             sod.delivery_date,          
             isnull(ocProduct.object_name_cn,'') as product_name_cn,          
             '' as ug_product_no,          
             '' as ug_product_name_cn,          
             sod.sale_order_guid          
      from T201_sale_order_detail sod           
      inner Join T200_repaire_kit_product rkp on rkp.product_no=sod.product_no and rkp.output_product_no2>''          
      Left Join T200_object_code ocProduct on ocProduct.object_no=rkp.output_product_no2          
      where ocProduct.object_name_cn like '%'+@strProductNameCn+'%'          
       and sod.delivery_date<=@dtEndDate          
       and exists(select  top 1 1 from T200_repaire_kit_product           
                  where product_no=sod.product_no)          
                   
      --取订单(非修理包产品)                   
      Insert Into #tbOrderDetail          
      (so_product_no,product_no,order_num,destine_num,delivery_num,undelivery_num,          
       delivery_date,product_name_cn,ug_product_no,ug_product_name_cn,sale_order_guid)          
      select sod.product_no as so_product_no,sod.product_no,          
             sod.order_num,          
             sod.destine_num,          
             sod.delivery_num, 
             case when sod.order_num-sod.delivery_num>0 then sod.order_num-sod.delivery_num 
                  else 0 end as undelivery_num,         
             sod.delivery_date,          
             isnull(ocProduct.object_name_cn,'') as product_name_cn,          
             '' as ug_product_no,          
             '' as ug_product_name_cn,          
             sod.sale_order_guid          
      from T201_sale_order_detail sod           
      Left Join T200_object_code ocProduct on ocProduct.object_no=sod.product_no          
      where ocProduct.object_name_cn like '%'+@strProductNameCn+'%'          
       and sod.delivery_date<=@dtEndDate          
       and not exists(select  top 1 1 from T200_repaire_kit_product           
                      where product_no=sod.product_no)           
                                
       print '2:' + convert(varchar(40),getdate(),  121)                     
      --更新ug品名          
      --取UG品的产品类别编码          
      declare @syspar_type_no_of_UG varchar(20)           
      select @syspar_type_no_of_UG = dbo.F100_GetStrSysParValue(replace(db_name(),'wsbase',''),'type_no_of_UG')           
      Declare @tbUgType table(type_no varchar(40))                                           
      Insert Into @tbUgType                                                          
      Select distinct str_value                                               
      from dbo.GF_StringSplit(@syspar_type_no_of_UG,';')                                               
      where str_value<>''     
                 
      print '2-1:' + convert(varchar(40),getdate(),  121)               
      update sod          
        set sod.ug_product_no=isnull(ppb.material_no,''),          
            sod.ug_product_name_cn=isnull(ppb.material_name_cn,'')          
      from #tbOrderDetail sod           
      outer apply(select top 1 material_no,          
                     isnull(ocMaterial.object_name_cn,'') as material_name_cn           
                  from TA04_product_part_bom ppb          
                  left join T200_product_code pc on pc.product_no=ppb.material_no          
                  left join @tbUgType ut on ut.type_no=pc.type_no          
                  left join T200_object_code ocMaterial on ocMaterial.object_no=ppb.material_no          
                  where ppb.output_product_no=sod.product_no        
                    and ppb.main_tag='T'    
                    and ut.type_no is not null    
                  order by ppb.material_no)ppb           
          
      print '3:' + convert(varchar(40),getdate(),  121)              
     -- 返回结果          
     Create table #tbResult          
     (product_no varchar(40),product_name_cn varchar(100),order_num float,destine_num float,delivery_num float,          
      undelivery_num float,remain_num float,first_delivery_date datetime,last_delivery_date datetime,          
      ug_product_no varchar(40),ug_product_name_cn varchar(100),ug_remain_num float,ug_plan_num float,          
      material_no varchar(40),material_name_cn varchar(100),material_rate float,mr_remain_num float,          
      mjg_num float,rcl_num float,cjg_num float,dz_num float,zt_num float,        
      product_produce_no varchar(40),prod_product_no varchar(40),last_active_no varchar(40),        
      cj_product_no varchar(40),dj_product_no varchar(40))        
     --插入ug品名不为空的记录         
     Insert Into #tbResult(product_no,product_name_cn,order_num,destine_num,delivery_num,undelivery_num,          
     remain_num,first_delivery_date,last_delivery_date,ug_product_no,ug_product_name_cn,          
     ug_remain_num,ug_plan_num,material_no,material_name_cn,material_rate,mr_remain_num,          
     mjg_num,rcl_num,cjg_num,dz_num,zt_num,product_produce_no,prod_product_no,last_active_no,        
     cj_product_no,dj_product_no)          
     select main.product_no,main.product_name_cn,main.order_num,main.destine_num,
     main.delivery_num,main.undelivery_num,
     isnull(srProduct.remain_num,0) as remain_num,          
     main.first_delivery_date,main.last_delivery_date,          
     main.ug_product_no,main.ug_product_name_cn,
     isnull(srUgProduct.remain_num,0) as ug_remain_num,
     isnull(pd.undelivery_num,0) as ug_plan_num,          
     isnull(mr.material_no,'') as material_no,          
     isnull(ocMaterial.object_name_cn,'') as material_name_cn,          
     isnull(mr.material_rate,0) as material_rate,          
     main.mr_remain_num,main.mjg_num,main.rcl_num,main.cjg_num,main.dz_num,main.zt_num,        
     isnull(ug.product_produce_no,'') as product_produce_no,        
     isnull(ug.product_no,'') as prod_product_no,        
     '' as last_active_no,        
     '' as cj_product_no,        
     '' as dj_product_no        
             
     from (select sod.product_no,sod.product_name_cn,        
            sum(sod.order_num) as order_num,          
            sum(sod.destine_num) as destine_num,          
            sum(sod.delivery_num) as delivery_num,
            sum(sod.undelivery_num) as undelivery_num,                   
            min(sod.delivery_date) as first_delivery_date,          
            max(sod.delivery_date) as last_delivery_date,          
            max(sod.ug_product_no) as ug_product_no,          
            max(sod.ug_product_name_cn) as ug_product_name_cn,               
            CAST(0 as float) as mr_remain_num,          
            CAST(0 as float) as mjg_num,          
            CAST(0 as float) as rcl_num,          
            CAST(0 as float) as cjg_num,          
            CAST(0 as float) as dz_num,          
            CAST(0 as float) as zt_num           
                      
     from #tbOrderDetail sod           
     outer apply(select top 1 product_produce_no,product_no,bom_level           
                 from TA04_product_part_bom           
                 where output_product_no=sod.ug_product_no         
                   and main_tag='T'         
                 order by material_no)ug           
     where sod.ug_product_no>''      
     group by sod.product_no,sod.product_name_cn           
     )main  
     outer apply(select SUM(remain_num) as remain_num           
                 from T205_stock_remain sr           
                 where sr.product_no=main.product_no)srProduct          
     outer apply(select SUM(remain_num) as remain_num           
                 from T205_stock_remain sr           
                 where sr.product_no=main.ug_product_no)srUgProduct          
     outer apply(select SUM(plan_num-delivery_num) as undelivery_num           
                 from TA03_PD_plan_detail pd           
                 where pd.product_no=main.ug_product_no          
                   and state_type='run')pd           
     outer apply(select top 1 product_no,product_produce_no,material_no,bom_level           
                 from TA04_product_part_bom           
                 where output_product_no=main.product_no          
                   and material_no=main.ug_product_no          
                   and main_tag='T'        
                  order by material_no)ug          
     outer apply(select ppb.material_no,ppb.material_rate,ppb.bom_level          
                 from TA04_product_part_bom ppb          
                 left join T200_product_code pc on pc.product_no=ppb.material_no         
                 where ppb.output_product_no=ug.material_no          
                   and ppb.product_no=ug.product_no          
                   and ppb.product_produce_no=ug.product_produce_no          
                   and LEN(ppb.bom_level)=LEN(ug.bom_level)+4        
                   and ppb.main_tag='T'        
                   and pc.self_purchase='self_made')mr           
      Left Join T200_object_code ocMaterial on ocMaterial.object_no=mr.material_no         
           
     print '4:' + convert(varchar(40),getdate(),  121)              
     --插入ug品名为空的记录        
     Insert Into #tbResult(product_no,product_name_cn,order_num,destine_num,delivery_num,undelivery_num,          
     remain_num,first_delivery_date,last_delivery_date,ug_product_no,ug_product_name_cn,          
     ug_remain_num,ug_plan_num,material_no,material_name_cn,material_rate,mr_remain_num,          
     mjg_num,rcl_num,cjg_num,dz_num,zt_num,product_produce_no,prod_product_no,last_active_no,        
     cj_product_no,dj_product_no)          
     select main.product_no,main.product_name_cn,main.order_num,main.destine_num,
     main.delivery_num,main.undelivery_num,
     isnull(srProduct.remain_num,0) as remain_num,       
     main.first_delivery_date,main.last_delivery_date,          
     main.ug_product_no,main.ug_product_name_cn,
     isnull(srUgProduct.remain_num,0) as ug_remain_num,
     isnull(pd.undelivery_num,0) as ug_plan_num,          
     isnull(mr.material_no,'') as material_no,          
     isnull(ocMaterial.object_name_cn,'') as material_name_cn,          
     isnull(mr.material_rate,0) as material_rate,          
     main.mr_remain_num,main.mjg_num,main.rcl_num,main.cjg_num,main.dz_num,main.zt_num,        
     isnull(ug.product_produce_no,'') as product_produce_no,        
     isnull(ug.product_no,'') as prod_product_no,        
     '' as last_active_no,        
     '' as cj_product_no,        
     '' as dj_product_no        
             
     from (select sod.product_no,sod.product_name_cn,          
            sum(sod.order_num) as order_num,          
            sum(sod.destine_num) as destine_num,          
            sum(sod.delivery_num) as delivery_num,
            sum(sod.undelivery_num) as undelivery_num,                 
            min(sod.delivery_date) as first_delivery_date,          
            max(sod.delivery_date) as last_delivery_date,          
            max(sod.ug_product_no) as ug_product_no,          
            max(sod.ug_product_name_cn) as ug_product_name_cn,                            
            CAST(0 as float) as mr_remain_num,          
            CAST(0 as float) as mjg_num,          
            CAST(0 as float) as rcl_num,          
            CAST(0 as float) as cjg_num,          
            CAST(0 as float) as dz_num,          
            CAST(0 as float) as zt_num           
                      
     from #tbOrderDetail sod           
     outer apply(select top 1 product_produce_no,product_no,bom_level           
                 from TA04_product_part_bom           
                 where output_product_no=sod.ug_product_no         
                   and main_tag='T'         
                 order by material_no)ug           
     where sod.ug_product_no=''      
     group by sod.product_no,sod.product_name_cn           
     )main 
     outer apply(select SUM(remain_num) as remain_num           
                 from T205_stock_remain sr           
                 where sr.product_no=main.product_no)srProduct          
     outer apply(select SUM(remain_num) as remain_num           
                 from T205_stock_remain sr           
                 where sr.product_no=main.ug_product_no)srUgProduct          
     outer apply(select SUM(plan_num-delivery_num) as undelivery_num           
                 from TA03_PD_plan_detail pd           
                 where pd.product_no=main.ug_product_no          
                   and state_type='run')pd          
     outer apply(select top 1 product_no,product_produce_no,material_no,bom_level           
                 from TA04_product_part_bom           
                 where output_product_no=main.product_no       
                   and product_no=main.product_no       
                   and material_no=main.product_no           
                   and main_tag='T'        
                  order by material_no)ug          
     outer apply(select ppb.material_no,ppb.material_rate,ppb.bom_level          
                 from TA04_product_part_bom ppb          
                 left join T200_product_code pc on pc.product_no=ppb.material_no         
                 where ppb.output_product_no=ug.material_no          
                   and ppb.product_no=ug.product_no          
                   and ppb.product_produce_no=ug.product_produce_no     
                   and LEN(ppb.bom_level)=LEN(ug.bom_level)+4        
                   and ppb.main_tag='T'        
                   and pc.self_purchase='self_made')mr           
      Left Join T200_object_code ocMaterial on ocMaterial.object_no=mr.material_no           
            
       print '5:' + convert(varchar(40),getdate(),  121)                
      --更新最后一道工序        
      update main          
        set main.last_active_no=isnull(ppc.active_no,'')         
      from #tbResult main         
      outer apply(select top 1 ppc.active_no        
                  from TA04_product_part_craft ppc          
                  where ppc.output_product_no=main.material_no          
                    and ppc.product_no=main.product_no          
                    and ppc.product_produce_no=main.product_produce_no          
                  order by craft_sequence desc)ppc        
                          
      --更新车件品名        
      update main          
        set main.cj_product_no=isnull(ppb.material_no,'')         
      from #tbResult main         
      outer apply(select top 1 ppb.material_no        
                  from TA04_product_part_bom ppb          
                  where ppb.output_product_no=main.material_no          
                    and ppb.product_no=main.product_no          
                    and ppb.product_produce_no=main.product_produce_no        
                    and ppb.main_tag='T'      
                  order by ppb.material_no        
                  )ppb         
                          
      --更新锻件品名        
      update main          
        set main.dj_product_no=isnull(ppb.material_no,'')         
      from #tbResult main         
      outer apply(select top 1 ppb.material_no        
                  from TA04_product_part_bom ppb          
                  where ppb.output_product_no=main.cj_product_no          
                    and ppb.product_no=main.product_no          
                    and ppb.product_produce_no=main.product_produce_no        
                    and ppb.main_tag='T'     
                   order by ppb.material_no           
                  )ppb               
           
        print '6:' + convert(varchar(40),getdate(),  121)               
      --更新材料完工品数(完工工序是最后一道工序的库存)         
      --完工品:内圈/外圈等材料对应的库存          
      --磨加工:内圈/外圈对应磨加工 的在制库存(按照品名编码找车间在制,除热处理工序)          
      --热处理:内圈/外圈对应热处理 工序的在制库存          
      --车加工:内圈/外圈对应下一级车件的车间在制库存          
      --锻造:内圈/外圈下一级车件对应的原材料库存          
      --在途:内圈/外圈下一级车件对应的原材料采购在途数          
      update main           
        set main.mr_remain_num=ISNULL(sr.remain_num,0),          
            main.mjg_num=ISNULL(mjg.mjg_remain_num,0),          
            main.rcl_num=ISNULL(mjg.rcl_remain_num,0),        
            main.cjg_num=ISNULL(cj.remain_num,0),        
            main.dz_num=ISNULL(dj.remain_num,0),        
            main.zt_num=ISNULL(sod.order_num,0)          
      from #tbResult main          
      outer apply(select SUM(remain_num) as remain_num           
                  from T205_stock_remain           
                  where product_no=main.material_no        
                    and finish_active_no=main.last_active_no)sr          
      outer apply(select SUM(case when finish_active_no='RCL' then remain_num           
                                  else 0 end) as rcl_remain_num,          
                         SUM(case when finish_active_no<>'RCL' then remain_num           
                                  else 0 end) as mjg_remain_num            
                  from T205_stock_remain           
                  where product_no=main.material_no         
                    and finish_active_no<>main.last_active_no         
                    )mjg          
     outer apply(select SUM(remain_num) as remain_num           
                  from T205_stock_remain           
                  where product_no=main.cj_product_no)cj        
     outer apply(select SUM(remain_num) as remain_num           
                  from T205_stock_remain           
                  where product_no=main.dj_product_no)dj        
     outer apply(select SUM(order_num-delivery_num) as order_num           
                  from T202_supply_order_detail           
                  where product_no=main.dj_product_no        
                  and audit_tag='T'        
                  and state_type='run')sod        
         
     print '7:' + convert(varchar(40),getdate(),  121)      
                      
     select *           
     from #tbResult main           
               
     select distinct sale_order_guid,product_no           
     from #tbOrderDetail      
         
     print '8:' + convert(varchar(40),getdate(),  121)         
                 
    End 
    展开全文
  • 使用free-outernet和gr-outernet,您可以接收Outernet文件服务广播的文件以及Outernet时间服务广播的时间包。 所有这些软件都是反向工程的结果,因为Outernet不会发布有关使用的协议的任何文档。 您可以使用free-...
  • I have seen joins called LEFT OUTER JOIN or RIGHT OUTER JOIN. In some places I have seen LEFT JOIN or RIGHT JOIN. I am confused by this. I posted a question 2 days ago, but I am unable to ...
  • Cross Apply 与 Outer Apply 的区别

    千次阅读 2018-05-11 22:22:38
    Cross Apply 与 Outer Apply 的区别,就像是 Inner join 与 Outer Join 的区别。 Inner Join 如果两边的表,无论是 Left Table, 或者是 Right Table, 做了限制,都会被应用到两边去,即一方的结果影响了另一方的...
  • Lateral View Outer

    千次阅读 2019-12-17 16:39:36
    lateralView: LATERAL VIEW [OUTER] udtf(expression) tableAlias AS columnAlias (',' columnAlias) * fromClause: FROM baseTable (lateralView)* Lateral view outer:当table function不输出任何一行时,对应的...
  • 关键字break和continue都是结束循环的作用,但是它只能结束它外面的第一层循环,如果代码里面是一层一层又一层的循环,但是想直接结束最外层循环就需要outer了。 看如下代码: outer:for (int i = 0; i < 10; i++...
  • spark outer join push down filer rule(spark 外连接中的下推规则) 背景 对于spark的不同的join操作来说,有些谓词是能下推,是有谓词是不能下推的,今天我们实地操作一番,从现象和源码级别分析一下,这到底是...
  • 本篇主要讲解被忽略的outer的作用。 ===lateral view 与 lateral view outer的区别 两者的区别: 主要就是当explode函数里传入的数据是否为null,lateral view explode(null) temp as id 时,结果不显示任何数据**(注意...
  • >>> data1.rightOuterJoin(data2).collect() [(6, (1, 1)), (7, (1, 1)), (8, (1, 1)), (9, (1, 1)), (10, (None, 1)), (11, (None, 1)), (12, (None, 1)), (13, (None, 1)), (14, (None, 1))] >>> data2.right...
  • 求问mysql中from中outer某表,这个单独outer是什么含义? 例如,select * from table1,outer table2
  • ].Zero-G.Outer.Limits.KeyGen

    2012-10-26 17:43:15
    [Zero-G.OUTER.LIMITS.音景效果盘].Zero-G.Outer.Limits.KeyGen
  • outer.java

    2013-12-10 19:54:12
    关于继承的累的写法,个人感觉还不错看一看看以看看
  • SQL FULL OUTER JOIN 关键字 FULL OUTER JOIN 关键字只要左表(table1)和右表(table2)其中一个表中存在匹配,则返回行. FULL OUTER JOIN 关键字结合了 LEFT JOIN 和 RIGHT JOIN 的结果。 SQL FULL OUTER JOIN ...
  • Join是SQL语句中的常用操作,良好的表结构能够...SparkSQL作为大数据领域的SQL实现,自然也对Join操作做了不少优化,今天主要看一下在SparkSQL中的Join,inner join,left outer join,right outer join,full outer...
  • 每个新选项卡上的Outer Worlds HD图像。 对于动作RPG的爱好者,即《赛博朋克2077外野荒野和无主之地》。 每个新选项卡上的Outer Worlds HD图像。 对于动作RPG迷,赛博朋克2077,外野和无主之地。 感谢您给予我们5星...
  • Outer Space字体

    2020-12-26 08:48:29
    该文档为Outer Space字体,是一份很不错的参考资料,具有较高参考价值,感兴趣的可以下载看看
  • inner join、outer join、right join、left join 之间的区别 一、sql的left join 、right join 、inner join之间的区别  left join(左联接) 返回包括左表中的所有记录和右表中联结字段相等的记录  right join...
  • Spark:FullOuterJoin算子

    2020-08-09 11:14:28
    FullOuterJoin算子是Tranformation,具有shuffle 将左表右表全部聚合有的显示Some(value)没有显示None(value) 分区按照Hashpartitioner二个rdd最大分区数分区 底层调的是cogroup,然后flatMapValues压平 有个...
  • inner join、 left join 、right join、 outer join之间的区别

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 207,016
精华内容 82,806
关键字:

outer