Optimization of nested queries in a complex object model

H.J. Steenhagen, Hennie J. Steenhagen, Peter M.G. Apers, Henk Blanken

    Research output: Chapter in Book/Report/Conference proceedingConference contributionAcademicpeer-review

    13 Citations (Scopus)
    67 Downloads (Pure)

    Abstract

    Transformation of nested SQL queries into join queries is advantageous because a nested SQL query can be looked upon as a nested-loop join, which is just one of the several join implementations that may be available in a relational DBMS. In join queries, dangling (unmatched) operand tuples are lost, which causes a problem in transforming nested queries having the aggregate function COUNT between query blocks-a problem that has become well-known as the COUNT bug. In the relational context, the outerjoin has been employed to solve the COUNT bug. In complex object models supporting an SQL-like query language, transformation of nested queries into join queries is an important optimization issue as well. The COUNT bug turns out to be a special case of a general problem being revealed in a complex object model. To solve the more general problem, we introduce the nest join operator, which is a generalization of the outerjoin for complex objects.
    Original languageEnglish
    Title of host publicationAdvances in database technology - EDBT '94
    EditorsMatthias Jarke, Janis Bubenko, Keith Jeffery
    Place of PublicationBerlin
    PublisherSpringer
    Pages337-350
    ISBN (Print)3-540-57818-8
    DOIs
    Publication statusPublished - 28 Mar 1994
    Event4th International Conference on Extending Database Technology, EDBT 1994 - Cambridge, United Kingdom
    Duration: 28 Mar 199431 Mar 1994
    Conference number: 4

    Publication series

    NameLecture notes in computer science
    PublisherSpringer
    Volume779
    ISSN (Print)0302-9743
    ISSN (Electronic)1611-3349

    Conference

    Conference4th International Conference on Extending Database Technology, EDBT 1994
    Abbreviated titleEDBT
    CountryUnited Kingdom
    CityCambridge
    Period28/03/9431/03/94

    Fingerprint

    Query languages

    Keywords

    • METIS-118956
    • IR-96073

    Cite this

    Steenhagen, H. J., Steenhagen, H. J., Apers, P. M. G., & Blanken, H. (1994). Optimization of nested queries in a complex object model. In M. Jarke, J. Bubenko, & K. Jeffery (Eds.), Advances in database technology - EDBT '94 (pp. 337-350). (Lecture notes in computer science; Vol. 779). Berlin: Springer. https://doi.org/10.1007/3-540-57818-8_62
    Steenhagen, H.J. ; Steenhagen, Hennie J. ; Apers, Peter M.G. ; Blanken, Henk. / Optimization of nested queries in a complex object model. Advances in database technology - EDBT '94. editor / Matthias Jarke ; Janis Bubenko ; Keith Jeffery. Berlin : Springer, 1994. pp. 337-350 (Lecture notes in computer science).
    @inproceedings{6377890d0d2d4c6fb813dfe85630ee87,
    title = "Optimization of nested queries in a complex object model",
    abstract = "Transformation of nested SQL queries into join queries is advantageous because a nested SQL query can be looked upon as a nested-loop join, which is just one of the several join implementations that may be available in a relational DBMS. In join queries, dangling (unmatched) operand tuples are lost, which causes a problem in transforming nested queries having the aggregate function COUNT between query blocks-a problem that has become well-known as the COUNT bug. In the relational context, the outerjoin has been employed to solve the COUNT bug. In complex object models supporting an SQL-like query language, transformation of nested queries into join queries is an important optimization issue as well. The COUNT bug turns out to be a special case of a general problem being revealed in a complex object model. To solve the more general problem, we introduce the nest join operator, which is a generalization of the outerjoin for complex objects.",
    keywords = "METIS-118956, IR-96073",
    author = "H.J. Steenhagen and Steenhagen, {Hennie J.} and Apers, {Peter M.G.} and Henk Blanken",
    year = "1994",
    month = "3",
    day = "28",
    doi = "10.1007/3-540-57818-8_62",
    language = "English",
    isbn = "3-540-57818-8",
    series = "Lecture notes in computer science",
    publisher = "Springer",
    pages = "337--350",
    editor = "Matthias Jarke and Janis Bubenko and Keith Jeffery",
    booktitle = "Advances in database technology - EDBT '94",

    }

    Steenhagen, HJ, Steenhagen, HJ, Apers, PMG & Blanken, H 1994, Optimization of nested queries in a complex object model. in M Jarke, J Bubenko & K Jeffery (eds), Advances in database technology - EDBT '94. Lecture notes in computer science, vol. 779, Springer, Berlin, pp. 337-350, 4th International Conference on Extending Database Technology, EDBT 1994, Cambridge, United Kingdom, 28/03/94. https://doi.org/10.1007/3-540-57818-8_62

    Optimization of nested queries in a complex object model. / Steenhagen, H.J.; Steenhagen, Hennie J.; Apers, Peter M.G.; Blanken, Henk.

    Advances in database technology - EDBT '94. ed. / Matthias Jarke; Janis Bubenko; Keith Jeffery. Berlin : Springer, 1994. p. 337-350 (Lecture notes in computer science; Vol. 779).

    Research output: Chapter in Book/Report/Conference proceedingConference contributionAcademicpeer-review

    TY - GEN

    T1 - Optimization of nested queries in a complex object model

    AU - Steenhagen, H.J.

    AU - Steenhagen, Hennie J.

    AU - Apers, Peter M.G.

    AU - Blanken, Henk

    PY - 1994/3/28

    Y1 - 1994/3/28

    N2 - Transformation of nested SQL queries into join queries is advantageous because a nested SQL query can be looked upon as a nested-loop join, which is just one of the several join implementations that may be available in a relational DBMS. In join queries, dangling (unmatched) operand tuples are lost, which causes a problem in transforming nested queries having the aggregate function COUNT between query blocks-a problem that has become well-known as the COUNT bug. In the relational context, the outerjoin has been employed to solve the COUNT bug. In complex object models supporting an SQL-like query language, transformation of nested queries into join queries is an important optimization issue as well. The COUNT bug turns out to be a special case of a general problem being revealed in a complex object model. To solve the more general problem, we introduce the nest join operator, which is a generalization of the outerjoin for complex objects.

    AB - Transformation of nested SQL queries into join queries is advantageous because a nested SQL query can be looked upon as a nested-loop join, which is just one of the several join implementations that may be available in a relational DBMS. In join queries, dangling (unmatched) operand tuples are lost, which causes a problem in transforming nested queries having the aggregate function COUNT between query blocks-a problem that has become well-known as the COUNT bug. In the relational context, the outerjoin has been employed to solve the COUNT bug. In complex object models supporting an SQL-like query language, transformation of nested queries into join queries is an important optimization issue as well. The COUNT bug turns out to be a special case of a general problem being revealed in a complex object model. To solve the more general problem, we introduce the nest join operator, which is a generalization of the outerjoin for complex objects.

    KW - METIS-118956

    KW - IR-96073

    U2 - 10.1007/3-540-57818-8_62

    DO - 10.1007/3-540-57818-8_62

    M3 - Conference contribution

    SN - 3-540-57818-8

    T3 - Lecture notes in computer science

    SP - 337

    EP - 350

    BT - Advances in database technology - EDBT '94

    A2 - Jarke, Matthias

    A2 - Bubenko, Janis

    A2 - Jeffery, Keith

    PB - Springer

    CY - Berlin

    ER -

    Steenhagen HJ, Steenhagen HJ, Apers PMG, Blanken H. Optimization of nested queries in a complex object model. In Jarke M, Bubenko J, Jeffery K, editors, Advances in database technology - EDBT '94. Berlin: Springer. 1994. p. 337-350. (Lecture notes in computer science). https://doi.org/10.1007/3-540-57818-8_62