不同导致查询不再按预期工作。如何解决此问题？

时间：2018-08-28 07:58:18

标签： sql oracle oracle12c hierarchical-data sqlxml

我有一个节点的分层表，其中有2个表“属性”和“值”通过耦合表链接。现在，我试图进行查询以返回一棵特定的树，并为每个节点返回其子节点的属性和值，而不管其级别如何。

由于我找不到在一个查询中执行此操作的方法，因此将其分为2个，在其中我分别使用存储过程递归地获得子级。下面的查询是一个为特定父节点收集子节点及其所有信息的查询。

但是我遇到了一些奇怪的行为：

我首先获取节点，然后使用子查询获取属性。这些查询可以单独工作，但是一旦我将它们组合在一起，它们就会忽略过滤，并在我尝试使用DISTINCT消除重复项时立即打印所有属性。

select xmlelement("tns:nodes",
    xmlattributes('http://somenamespace.com/' as "xmlns:tns"),
    xmlagg(xmlelement("tns:node",
        xmlelement("tns:code", n.code),
        (select xmlelement("tns:attributes",
                xmlagg(xmlelement("tns:attribute",
                    xmlelement("tns:name", t.name)
                ))
            )
            from (select DISTINCT att_a.name
                    from attributes2 att_a
                    inner join attrib_value_node2 att_avnu on att_avnu.attribute_id = att_a.id
                    where att_avnu.node_id in (select id from nodes2 start with code = n.code connect by prior ID = PARENTID)
                 ) t
        )
    )
))
FROM   NODES2 n
where n.parentID in (select id from nodes2 where code = 'TESTS')
and n.id in (select parentID from nodes2)
order by n.code asc;

当我删除DISTINCT时，查询按预期工作。但是，由于存在具有相同属性但值不同的节点，因此存在重复项。我试图仅通过选择DISTINCT属性来过滤这些内容，但是由于某种原因，一旦我将其放到整个过滤过程中，整个过滤过程就会停止工作，并且只会打印所有属性。

当我通过用字符串手动替换n.code来单独运行属性查询时，它又能正常工作。为什么当查询整体运行时DISTINCT会引起问题？另外我该如何解决？我知道DISTINCT和collect by彼此之间不太友好，但是我没有在同一查询中使用它们。

数据库脚本和数据：

DROP TABLE NODES2;
DROP TABLE VALUES2;
DROP TABLE ATTRIBUTES2;
DROP TABLE ATTRIB_VALUE_NODE2;

CREATE TABLE NODES2 
(   
    "ID" NUMBER, 
    "PARENTID" NUMBER,
    "CODE" VARCHAR2(20)
);

CREATE UNIQUE INDEX "NODES2_PK" ON "NODES2" ("ID");

CREATE TABLE VALUES2 
(   
    "ID" NUMBER,
    "NAME" VARCHAR2(200)
);

CREATE UNIQUE INDEX "VALUES2_PK" ON "VALUES2" ("ID");

CREATE TABLE ATTRIBUTES2 
(   
    "ID" NUMBER,
    "NAME" VARCHAR2(200)
);

CREATE UNIQUE INDEX "ATTRIBUTES2_PK" ON "ATTRIBUTES2" ("ID");

CREATE TABLE "ATTRIB_VALUE_NODE2" 
(
    "ATTRIBUTE_ID" NUMBER NOT NULL, 
    "ATTRIB_VALUE_ID" NUMBER NOT NULL, 
    "NODE_ID" NUMBER NOT NULL
);

INSERT INTO "NODES2" (ID, CODE) VALUES (1,'TESTS');
INSERT INTO "NODES2" (ID, PARENTID, CODE) VALUES (2,1,'TST1');
INSERT INTO "NODES2" (ID, PARENTID, CODE) VALUES (3,1,'TST2');
INSERT INTO "NODES2" (ID, PARENTID, CODE) VALUES (4,1,'TST3');
INSERT INTO "NODES2" (ID, PARENTID, CODE) VALUES (5,2,'TST1-1');
INSERT INTO "NODES2" (ID, PARENTID, CODE) VALUES (6,2,'TST1-2');
INSERT INTO "NODES2" (ID, PARENTID, CODE) VALUES (7,3,'TST2-1');
INSERT INTO "NODES2" (ID, PARENTID, CODE) VALUES (8,3,'TST2-2');
INSERT INTO "NODES2" (ID, PARENTID, CODE) VALUES (9,3,'TST2-3');
INSERT INTO "NODES2" (ID, PARENTID, CODE) VALUES (10,4,'TST3-1');
INSERT INTO "NODES2" (ID, PARENTID, CODE) VALUES (11,4,'TST3-2');

Insert into ATTRIBUTES2 (ID,NAME) values (1,'TestAttribute');
Insert into ATTRIBUTES2 (ID,NAME) values (2,'TestAttribute2');
Insert into ATTRIBUTES2 (ID,NAME) values (3,'TestAttribute3');
Insert into ATTRIBUTES2 (ID,NAME) values (4,'TestAttribute4');
Insert into ATTRIBUTES2 (ID,NAME) values (5,'TestAttribute5');

Insert into "VALUES2" (ID,NAME) values (1,'TestValue1');
Insert into "VALUES2" (ID,NAME) values (2,'TestValue2');
Insert into "VALUES2" (ID,NAME) values (3,'TestValue3');
Insert into "VALUES2" (ID,NAME) values (4,'TestValue4');
Insert into "VALUES2" (ID,NAME) values (5,'TestValue5');

Insert into ATTRIB_VALUE_NODE2 (ATTRIBUTE_ID,ATTRIB_VALUE_ID,NODE_ID) values (1,1,5);
Insert into ATTRIB_VALUE_NODE2 (ATTRIBUTE_ID,ATTRIB_VALUE_ID,NODE_ID) values (2,2,5);
Insert into ATTRIB_VALUE_NODE2 (ATTRIBUTE_ID,ATTRIB_VALUE_ID,NODE_ID) values (1,2,6);
Insert into ATTRIB_VALUE_NODE2 (ATTRIBUTE_ID,ATTRIB_VALUE_ID,NODE_ID) values (1,3,7);
Insert into ATTRIB_VALUE_NODE2 (ATTRIBUTE_ID,ATTRIB_VALUE_ID,NODE_ID) values (3,3,8);
Insert into ATTRIB_VALUE_NODE2 (ATTRIBUTE_ID,ATTRIB_VALUE_ID,NODE_ID) values (3,4,8);

没有DISTINCT的输出：

<tns:nodes xmlns:tns="http://somenamespace.com/">
    <tns:node>
        <tns:code>TST1</tns:code>
        <tns:attributes>
            <tns:attribute>
                <tns:name>TestAttribute</tns:name>
            </tns:attribute>
            <tns:attribute>
                <tns:name>TestAttribute2</tns:name>
            </tns:attribute>
            <tns:attribute>
                <tns:name>TestAttribute</tns:name>
            </tns:attribute>
        </tns:attributes>
    </tns:node>
    <tns:node>
        <tns:code>TST2</tns:code>
        <tns:attributes>
            <tns:attribute>
                <tns:name>TestAttribute</tns:name>
            </tns:attribute>
            <tns:attribute>
                <tns:name>TestAttribute3</tns:name>
            </tns:attribute>
            <tns:attribute>
                <tns:name>TestAttribute3</tns:name>
            </tns:attribute>
        </tns:attributes>
    </tns:node>
    <tns:node>
        <tns:code>TST3</tns:code>
        <tns:attributes/>
    </tns:node>
</tns:nodes>

DISTINCT输出：

<tns:nodes xmlns:tns="http://somenamespace.com/">
    <tns:node>
        <tns:code>TST1</tns:code>
        <tns:attributes>
            <tns:attribute>
                <tns:name>TestAttribute</tns:name>
            </tns:attribute>
            <tns:attribute>
                <tns:name>TestAttribute2</tns:name>
            </tns:attribute>
            <tns:attribute>
                <tns:name>TestAttribute3</tns:name>
            </tns:attribute>
        </tns:attributes>
    </tns:node>
    <tns:node>
        <tns:code>TST2</tns:code>
        <tns:attributes>
            <tns:attribute>
                <tns:name>TestAttribute</tns:name>
            </tns:attribute>
            <tns:attribute>
                <tns:name>TestAttribute2</tns:name>
            </tns:attribute>
            <tns:attribute>
                <tns:name>TestAttribute3</tns:name>
            </tns:attribute>
        </tns:attributes>
    </tns:node>
    <tns:node>
        <tns:code>TST3</tns:code>
        <tns:attributes>
            <tns:attribute>
                <tns:name>TestAttribute</tns:name>
            </tns:attribute>
            <tns:attribute>
                <tns:name>TestAttribute2</tns:name>
            </tns:attribute>
            <tns:attribute>
                <tns:name>TestAttribute3</tns:name>
            </tns:attribute>
        </tns:attributes>
    </tns:node>
</tns:nodes>

预期输出：

<tns:nodes xmlns:tns="http://somenamespace.com/">
    <tns:node>
        <tns:code>TST1</tns:code>
        <tns:attributes>
            <tns:attribute>
                <tns:name>TestAttribute</tns:name>
            </tns:attribute>
            <tns:attribute>
                <tns:name>TestAttribute2</tns:name>
            </tns:attribute>
        </tns:attributes>
    </tns:node>
    <tns:node>
        <tns:code>TST2</tns:code>
        <tns:attributes>
            <tns:attribute>
                <tns:name>TestAttribute</tns:name>
            </tns:attribute>
            <tns:attribute>
                <tns:name>TestAttribute3</tns:name>
            </tns:attribute>
        </tns:attributes>
    </tns:node>
    <tns:node>
        <tns:code>TST3</tns:code>
    </tns:node>
</tns:nodes>

1 个答案:

答案 0 :(得分：0)

您的两个查询的执行计划很有趣。我无法立即看到为什么它失去了过滤步骤或相关性。您可能需要提出SR以获得完整的解释。

不过，您可以在单个查询中完成此操作，将单个connect-by连接到耦合表和属性表：

select xmlserialize(document
  xmlelement("tns:nodes",
    xmlattributes('https//somenamespace.com/' as "xmlns:tns"),
    xmlagg(
      xmlelement("tns:node",
        xmlelement("tns:code", t.code),
        xmlelement("tns:attributes",
          xmlagg(
            xmlelement("tns:attribute",
              xmlelement("tns:name", t.name)
            )
            order by t.name
          )
        )
      )
      order by t.code
    )
  )
  indent size = 2
)
from (
  select distinct n.code, a.name
  from (
    select id, prior code as code
    from nodes2
    where id != connect_by_root (id)
    start with code = 'TESTS'
    connect by prior id = parentid
  ) n
  join attrib_value_node2 avn on avn.node_id = n.id
  join attributes2 a on a.id = avn.attribute_id
) t
group by t.code;

与您的示例数据一起产生的

<tns:nodes xmlns:tns="https//somenamespace.com/">
  <tns:node xmlns:tns="https//somenamespace.com/">
    <tns:code xmlns:tns="https//somenamespace.com/">TST1</tns:code>
    <tns:attributes xmlns:tns="https//somenamespace.com/">
      <tns:attribute xmlns:tns="https//somenamespace.com/">
        <tns:name xmlns:tns="https//somenamespace.com/">TestAttribute</tns:name>
      </tns:attribute>
      <tns:attribute xmlns:tns="https//somenamespace.com/">
        <tns:name xmlns:tns="https//somenamespace.com/">TestAttribute2</tns:name>
      </tns:attribute>
    </tns:attributes>
  </tns:node>
  <tns:node xmlns:tns="https//somenamespace.com/">
    <tns:code xmlns:tns="https//somenamespace.com/">TST2</tns:code>
    <tns:attributes xmlns:tns="https//somenamespace.com/">
      <tns:attribute xmlns:tns="https//somenamespace.com/">
        <tns:name xmlns:tns="https//somenamespace.com/">TestAttribute</tns:name>
      </tns:attribute>
      <tns:attribute xmlns:tns="https//somenamespace.com/">
        <tns:name xmlns:tns="https//somenamespace.com/">TestAttribute3</tns:name>
      </tns:attribute>
    </tns:attributes>
  </tns:node>
</tns:nodes>

只有XMLSerialize调用可以很好地格式化文档。

重复命名空间声明，这似乎是嵌套XMLAgg调用和关联的group-by子句的产物。我看不到一种方法来不幸地产生那些，但是我想从技术上讲它们并不重要。

相关问题
最新问题