标签: hierarchy

我有一个产品表,其中包含一个类别的FK,Categories表以每个类别可以具有父类别的方式创建,例如:

Computers
    Processors
        Intel
            Pentium
            Core 2 Duo
        AMD
            Athlon

我需要做一个选择查询,如果所选类别是处理器,它将返回Intel,Pentium,Core 2 Duo,Amd等产品......

我考虑创建某种"缓存",它将为数据库中的每个类别存储层次结构中的所有类别,并在where子句中包含"IN".这是最好的解决方案吗？

我有一个表使用Adjacency List模型存储分层信息.(使用自引用键 - 下面的示例.此表可能看起来很熟悉):

category_id name                 parent
----------- -------------------- -----------
1           ELECTRONICS          NULL
2           TELEVISIONS          1
3           TUBE                 2
4           LCD                  2
5           PLASMA               2
6           PORTABLE ELECTRONICS 1
7           MP3 PLAYERS          6
8           FLASH                7
9           CD PLAYERS           6
10          2 WAY RADIOS         6

将上述数据"压扁"成这样的东西的最佳方法是什么？

category_id lvl1        lvl2        lvl3        lvl4
----------- ----------- ----------- ----------- -----------
1           1           NULL        NULL        NULL
2           1           2           NULL        NULL
6           1           6           NULL        NULL
3           1           2           3           NULL
4           1 …

在Information Builder中,我需要查看/浏览XIB中的所有对象,并喜欢在Xcode 3中使用对象层次结构视图.但是,在XCode 4中,它只显示顶级对象,而不显示子对象.如何在XCode 4中查看它们？

当我将数组绑定到CUDA中的纹理时,

1. 那个数组复制到纹理空间？要么,
2. 是作为纹理的数组引用？

如果答案是1.,那么我可以从纹理存储空间绑定纹理和安全获取数据,同时将结果写入数组,该数组在全局存储器中分配.

如果答案是2.那么纹理存储器是一个全局存储空间,数据被缓存并空间获取？

我想知道这个话题,因为我已经看到了一些与这个话题相关的问题,我现在还没有明确答案.

提前致谢.

假设我有一个类X,我如何检查哪个是基类/类,以及它们的基类/类等？

我正在将Eclipse与PyDev一起使用,例如对于Java,您可以在类名称上键入CTRL + T并查看层次结构,如:

java.lang.Object
   java.lang.Number
       java.lang.Integer

Python有可能吗？

如果在Eclipse PyDev中不可能,我在哪里可以找到这些信息？

我想知道通过sequence_within_parent列在层次结构查询中对子项进行排序的Oracle SQL查询.

示例数据集和查询是:

create table tasks (task_id                 number
                    ,parent_id               number
                    ,sequence_within_parent number
                    ,task                    varchar2(30)
                    );
insert into tasks values ( 1, NULL, 0, 'Task 1');
insert into tasks values ( 2,    1, 1, 'Task 1.1');
insert into tasks values ( 3,    1, 2, 'Task 1.2');
insert into tasks values ( 4,    2, 2, 'Task 1.1.2');
insert into tasks values ( 5,    3, 1, 'Task 1.2.1');
insert into tasks values ( 6,    2, 1, 'Task 1.1.1');
insert into tasks values ( …

我正在努力寻找一个我希望变成嵌套<select>的数组

我需要:

<select>
<option value="1">Top1</option>
<option value="2">Top2</option>
<option value="9">Top3</option>
<option value="7"> - - Top3.1</option>
<option value="5"> - - Top3.2</option>
<option value="12">- - - - Top3.2.1</option>
<option value="6">Top4</option>
<option value="4">Top5</option>
<option value="8"> - - Top5.1</option>
<option value="3"> - - Top5.2</option>

我无法使用optgroup,因为一切都是可选的.据我所知,您无法选择optgroup标签.

我的数组看起来像这样:

[44] => Array
    (
        [id] => 1
        [name] => Test
        [slug] => test
        [parent] => 0
    )

[45] => Array
    (
        [id] => 2
        [name] => Test-Sub
        [slug] => test-sub
        [parent] => 1
    )

[46] => Array
    (
        [id] …

我的数据库中有以下数据:

Parent      Child
101         102
101         103
101         104
101         105
101         106

我的参数是106.并且使用参数我想要检索其父级下的所有其他子项,即101.我尝试使用递归方法但是在给定以下数据的情况下它不起作用.还有另一种方法来制定查询吗？

假设我有一个像下面这样的对象树，可能是使用这里找到的优秀算法创建的：https : //stackoverflow.com/a/22367819/3123195

{
    "children": [{
        "id": 1,
        "title": "home",
        "parent": null,
        "children": []
    }, {
        "id": 2,
        "title": "about",
        "parent": null,
        "children": [{
            "id": 3,
            "title": "team",
            "parent": 2,
            "children": []
        }, {
            "id": 4,
            "title": "company",
            "parent": 2,
            "children": []
        }]
    }]
}

（特别是在这个例子中，该函数返回的数组作为children数组属性嵌套在一个空对象中。）

我如何将它转换回平面阵列？

我有这个设置：

main.py
/module
/module/__init__.py (empty)
/module.py

这里是我的两个文件的代码，main.py并module.py分别为：

主文件

import logging
from module import module

logger = logging.getLogger(__name__)

def test():
    logger.warning('in main.py/test')

def main():
    handler = logging.StreamHandler()
    handler.setLevel(logging.INFO)
    formatter = logging.Formatter('%(asctime)s %(name)s/%(module)s [%(levelname)s]: %(message)s', '%Y-%m-%d %H:%M:%S')
    handler.setFormatter(formatter)
    logger.addHandler(handler)

    logger.warning('in main.py/main')
    module.something()

if __name__ == "__main__":
    main()    

模块.py

import logging
logger = logging.getLogger(__name__)

def something():
    logger.warning('in module.py/something')

所以，我注意到这会输出以下内容（注意模块记录器没有格式）：

2019-10-01 09:03:40 __main__/main [WARNING]: in main.py/main
in module.py/something

它只是看起来像后，才进行编辑在main.py以变化logger = logging.getLogger( __ name __ )来logger …