heurist-api 0.1.2__py3-none-any.whl

heurist/models/structural/hml_structure.py

@@ -0,0 +1,36 @@
+from heurist.models.structural.DetailTypes import (
+    DetailTypes as DetailTypesModel,
+)
+from heurist.models.structural.RecStructure import (
+    RecStructure as RecStructureModel,
+)
+from heurist.models.structural.RecTypeGroups import (
+    RecTypeGroups as RecTypeGroupsModel,
+)
+from heurist.models.structural.RecTypes import RecTypes as RecTypesModel
+from heurist.models.structural.Terms import Terms as TermsModel
+from pydantic_xml import BaseXmlModel, element
+
+
+class HMLStructure(BaseXmlModel, tag="hml_structure", search_mode="unordered"):
+    """Parent dataclass forr modeling the entire Heurist database structure.
+
+    Attributes:
+        detail_types (DetailTypes): model for data nested in the DetailTypes tag.
+        record_structures (RecStructure): model for data nested in the RecStructure tag.
+        record_types (RecTypes): model for data nested in the RecTypes tag.
+
+    Examples:
+        >>> from mock_data import DB_STRUCTURE_XML
+        >>>
+        >>>
+        >>> # Parse structure
+        >>> xml = DB_STRUCTURE_XML
+        >>> hml = HMLStructure.from_xml(xml)
+    """
+
+    DetailTypes: DetailTypesModel = element(tag="DetailTypes")
+    RecStructure: RecStructureModel = element(tag="RecStructure")
+    RecTypes: RecTypesModel = element(tag="RecTypes")
+    RecTypeGroups: RecTypeGroupsModel = element(tag="RecTypeGroups")
+    Terms: TermsModel = element(tag="Terms")

heurist/models/structural/rst.py

@@ -0,0 +1,141 @@
+from datetime import datetime
+from typing import Literal, Optional
+
+from pydantic_xml import BaseXmlModel, element
+
+
+class RST(BaseXmlModel, tag="rst", search_mode="unordered"):
+    """Dataclass to model one of the database's Record Structures. Record Structures
+        are the fields of a Record Type.
+
+    When possible, the attribute descriptions are taken from Heurist's source code.
+
+    Attributes:
+        rst_ID (int): Primary key for the record structures table
+        rst_RecTypeID (int): The record type to which this detail is allocated, \
+            0 = all rectypes
+        rst_DetailTypeID (int): Detail type for this field or, if MSB set, \
+            FieldSet code + 32767
+        rst_DisplayName (str): Display name for this dtl type in this rectype, \
+            autofill with dty_Name
+        rst_DisplayHelpText (Optional[str]): The user help text to be displayed for \
+            this detail type for this record type
+        rst_DisplayExtendedDescription (Optional[str]): The rollover text to be \
+            displayed for this detail type for this record type
+        rst_DisplayOrder (int): A sort order for display of this detail type in the \
+            record edit form
+        rst_DisplayWidth (int): The field width displayed for this detail type in \
+            this record type
+        rst_DisplayHeight (int): The field height for this detail type in this record \
+            type, only relevant for memo fields
+        rst_DefaultValue (Optional[str]): The default value for this detail type for \
+            this record type
+        rst_RecordMatchOrder (int): Indicates order of significance in detecting \
+            duplicate records, 1 = highest
+        rst_CalcFunctionID (Optional[int]): FK to table of function specifications for \
+            calculating string values
+        rst_CalcFieldMask (Optional[str]): A mask string along the lines of the title \
+            mask allowing a composite field to be generated from other fields in the \
+            record
+        rst_RequirementType (Literal["required", "recommended", "optional", \
+            "forbidden"]):
+        rst_NonOwnerVisibility (Literal["hidden", "viewable", "public", "pending"]): \
+            Allows restriction of visibility of a particular field in a specified \
+            record type
+        rst_Status (Literal["reserved", "approved", "pending", "open"]): Reserved \
+            Heurist codes, approved/pending by ''Board'', and user additions
+        rst_MayModify (Literal["locked", "discouraged", "open"]): Extent to which \
+            detail may be modified within this record structure
+        rst_OriginatingDBID (int): Database where this record structure element \
+            originated, 0 = locally
+        rst_IDInOriginatingDB (Optional[int]): ID used in database where this record \
+            structure element originated
+        rst_MaxValues (int): Maximum number of values per record for this detail, 1 - \
+            single, >1 limited, NULL or 0 = no limit
+        rst_MinValues (int): If required, minimum number of values per record for this \
+            detail
+        rst_InitialRepeats (int): Number of repeat values to be displayed for this \
+            field when a new record is first displayed
+        rst_DisplayDetailTypeGroupID (Optional[int]): If set, places detail in \
+            specified group instead of according to dty_DetailTypeGroup
+        rst_FilteredJsonTermIDTree (Optional[str]): JSON encoded tree of allowed \
+            terms, subset of those defined in defDetailType. This field is no \
+            longer used
+        rst_PtrFilteredIDs (Optional[str]): Allowed Rectypes (CSV) within list defined \
+            by defDetailType (for pointer details) This field is no longer used
+        rst_CreateChildIfRecPtr (bool): For pointer fields, flags that new records \
+            created from this field should be marked as children of the creating record
+        rst_PointerMode (Literal["dropdown_add", "dropdown", "addorbrowse", "addonly", \
+            "browseonly"]): When adding record pointer values, default or null = show \
+            both add and browse, otherwise only allow add or only allow \
+            browse-for-existing
+        rst_PointerBrowseFilter (Optional[str]): When adding record pointer values, \
+            defines a Heurist filter to restrict the list of target records browsed
+        rst_OrderForThumbnailGeneration (Optional[str]): Priority order of fields to \
+            use in generating thumbnail, null = do not use
+        rst_TermIDTreeNonSelectableIDs (Optional[str]): Term IDs to use as \
+            non-selectable headers for this field
+        rst_ShowDetailCertainty (bool): When editing the field, allow editng of the \
+            dtl_Certainty value (off by default)
+        rst_ShowDetailAnnotation (bool): When editing the field, allow editng of the \
+            dtl_Annotation value (off by default)
+        rst_NumericLargestValueUsed (Optional[int]): For numeric fields, Null = \
+            no auto increment, 0 or more indicates largest value used so far. \
+            Set to 0 to switch on incrementing
+        rst_EntryMask (Optional[str]): Data entry mask, use to control decimals on \
+            numeric values, content of text fields etc. for this record type - future \
+            implementation Aug 2017
+        rst_Modified (datetime): Date of last modification of this record, used to get \
+            last updated date for table
+        rst_LocallyModified (int): Flags a definition element which has been modified \
+            relative to the original source
+        rst_SemanticReferenceURL (Optional[str]): The URI to a semantic definition or \
+            web page describing this field used within this record type
+        rst_TermsAsButtons (bool): If 1, term list fields are represented as buttons \
+            (if single value) or checkboxes (if repeat values)
+    """
+
+    rst_ID: int = element()
+    rst_RecTypeID: int = element()
+    rst_DetailTypeID: int = element()
+    rst_DisplayName: str = element()
+    rst_DisplayHelpText: Optional[str] = element(default=None)
+    rst_DisplayExtendedDescription: Optional[str] = element(default=None)
+    rst_DisplayOrder: int = element()
+    rst_DisplayWidth: int = element()
+    rst_DisplayHeight: int = element()
+    rst_DefaultValue: Optional[str] = element(default=None)
+    rst_RecordMatchOrder: int = element()
+    rst_CalcFunctionID: Optional[int] = element(default=None)
+    rst_CalcFieldMask: Optional[str] = element(default=None)
+    rst_RequirementType: Literal["required", "recommended", "optional", "forbidden"] = (
+        element()
+    )
+    rst_NonOwnerVisibility: Literal["hidden", "viewable", "public", "pending"] = (
+        element()
+    )
+    rst_Status: Literal["reserved", "approved", "pending", "open"] = element()
+    rst_MayModify: Literal["locked", "discouraged", "open"] = element()
+    rst_OriginatingDBID: int = element()
+    rst_IDInOriginatingDB: Optional[int] = element(default=None)
+    rst_MaxValues: int = element()
+    rst_MinValues: int = element()
+    rst_InitialRepeats: int = element()
+    rst_DisplayDetailTypeGroupID: Optional[int] = element(default=None)
+    rst_FilteredJsonTermIDTree: Optional[str] = element(default=None)
+    rst_PtrFilteredIDs: Optional[str] = element(default=None)
+    rst_CreateChildIfRecPtr: bool = element()
+    rst_PointerMode: Literal[
+        "dropdown_add", "dropdown", "addorbrowse", "addonly", "browseonly"
+    ] = element()
+    rst_PointerBrowseFilter: Optional[str] = element(default=None)
+    rst_OrderForThumbnailGeneration: Optional[str] = element(default=None)
+    rst_TermIDTreeNonSelectableIDs: Optional[str] = element(default=None)
+    rst_ShowDetailCertainty: bool = element()
+    rst_ShowDetailAnnotation: bool = element()
+    rst_NumericLargestValueUsed: Optional[int] = element(default=None)
+    rst_EntryMask: Optional[str] = element(default=None)
+    rst_Modified: datetime = element()
+    rst_LocallyModified: int = element()
+    rst_SemanticReferenceURL: Optional[str] = element(default=None)
+    rst_TermsAsButtons: bool = element()

heurist/models/structural/rtg.py

@@ -0,0 +1,25 @@
+from datetime import datetime
+from typing import Optional
+
+from pydantic_xml import BaseXmlModel, element
+
+
+class RTG(BaseXmlModel, tag="rtg", search_mode="unordered"):
+    """Dataclass to model one of the database's Record Type Groups. A Record Type \
+        Group categorizes the record types in the database.
+
+    When possible, the attribute descriptions are taken from Heurist's source code.
+
+    Attributes:
+        rtg_ID (int): __Description__.
+        rtg_Name (str): __Description__.
+        rtg_Domain (str): __Description__.
+        rtg_Description (Optional[str]): __Description__.
+        rtg_Modified (datetime): __Description__.
+    """
+
+    rtg_ID: int = element()
+    rtg_Name: str = element()
+    rtg_Domain: str = element()
+    rtg_Description: Optional[str] = element(default=None)
+    rtg_Modified: datetime = element()

heurist/models/structural/rty.py

@@ -0,0 +1,81 @@
+from datetime import datetime
+from typing import Literal, Optional
+
+from pydantic_xml import BaseXmlModel, element
+
+
+class RTY(BaseXmlModel, tag="rty", search_mode="unordered"):
+    """Dataclass to model one of the database's Record Types. A Record Type is the \
+        schema for an entity in the database.
+
+    When possible, the attribute descriptions are taken from Heurist's source code.
+
+    Attributes:
+        rty_ID (int): Record type code, widely used to reference record types, primary \
+            key
+        rty_Name (str): The name which is used to describe this record (object) type
+        rty_OrderInGroup (int): Ordering within record type display groups for pulldowns
+        rty_Description (str): Description of this record type
+        rty_TitleMask (str): Mask to build a composite title by combining field values
+        rty_CanonicalTitleMask (str): Version of the mask converted to detail codes \
+            for processing
+        rty_Plural (Optional[str]): Plural form of the record type name, manually \
+            entered
+        rty_Status (Literal["reserved", "approved", "pending", "open"]): Reserved \
+            Heurist codes, approved/pending by ''Board'', and user additions
+        rty_OriginatingDBID (Optional[int]): Database where this record type \
+            originated, 0 = locally
+        rty_NameInOriginatingDB: (Optional[str]) Name used in database where this \
+            record type originated
+        rty_IDInOriginatingDB (Optional[int]): ID in database where this record type \
+            originated
+        rty_NonOwnerVisibility (Literal["hidden", "viewable", "public", "pending"]): \
+            Allows blanket restriction of visibility of a particular record type
+        rty_ShowInLists (bool): Flags if record type is to be shown in end-user \
+            interface, 1=yes
+        rty_RecTypeGroupID (int): Record type group to which this record type belongs
+        rty_RecTypeModelIDs (str): The model group(s) to which this rectype belongs, \
+            comma sep. list
+        rty_FlagAsFieldset (bool): 0 = full record type, 1 = Fieldset = set of fields \
+            to include in other rectypes
+        rty_ReferenceURL (Optional[str]): A semantic reference URI for, or a URL \
+            describing, the record type
+        rty_AlternativeRecEditor (Optional[str]): Name or URL of alternative record \
+            editor function to be used for this rectype
+        rty_Type (Literal["normal", "relationship", "dummy"]): Use to flag special \
+            record types to trigger special functions
+        rty_ShowURLOnEditForm (bool): Determines whether special URL field is shown at \
+            the top of the edit form
+        rty_ShowDescriptionOnEditForm (bool): Determines whether the record type \
+            description field is shown at the top of the edit form
+        rty_Modified (datetime): Date of last modification of this record, used to get \
+            last updated date for table
+        rty_LocallyModified (bool): Flags a definition element which has been modified \
+            relative to the original source
+    """
+
+    rty_ID: int = element()
+    rty_Name: str = element()
+    rty_OrderInGroup: int = element()
+    rty_Description: str = element()
+    rty_TitleMask: str = element()
+    rty_CanonicalTitleMask: Optional[str] = element(default=None)
+    rty_Plural: Optional[str] = element(default=None)
+    rty_Status: Literal["reserved", "approved", "pending", "open"] = element()
+    rty_OriginatingDBID: Optional[int] = element(default=None)
+    rty_NameInOriginatingDB: Optional[str] = element(default=None)
+    rty_IDInOriginatingDB: Optional[int] = element(default=None)
+    rty_NonOwnerVisibility: Literal["hidden", "viewable", "public", "pending"] = (
+        element()
+    )
+    rty_ShowInLists: bool = element()
+    rty_RecTypeGroupID: int = element()
+    rty_RecTypeModelIDs: str = element(default=None)
+    rty_FlagAsFieldset: bool = element(default=None)
+    rty_ReferenceURL: Optional[str] = element(default=None)
+    rty_AlternativeRecEditor: Optional[str] = element(default=None)
+    rty_Type: Literal["normal", "relationship", "dummy"] = element()
+    rty_ShowURLOnEditForm: bool = element()
+    rty_ShowDescriptionOnEditForm: bool = element()
+    rty_Modified: datetime = element()
+    rty_LocallyModified: bool = element()

heurist/models/structural/trm.py

@@ -0,0 +1,34 @@
+from datetime import datetime
+from typing import Literal, Optional
+
+from pydantic_xml import BaseXmlModel, element
+
+
+class TRM(BaseXmlModel, tag="trm", search_mode="unordered"):
+    """Dataclass to model one of the database's vocabulary terms.
+
+    When possible, the attribute descriptions are taken from Heurist's source code.
+    """
+
+    trm_ID: int = element()
+    trm_Label: str = element()
+    trm_InverseTermId: Optional[int] = element(default=None)
+    trm_Description: Optional[str] = element(default=None)
+    trm_Status: Literal["open", "approved", "reserved"] = element()
+    trm_OriginatingDBID: int = element()
+    trm_NameInOriginatingDB: Optional[str] = element(default=None)
+    trm_IDInOriginatingDB: Optional[int] = element(default=None)
+    trm_AddedByImport: bool = element()
+    trm_IsLocalExtension: bool = element()
+    trm_Domain: Literal["relation", "enum"] = element()
+    trm_OntID: int = element()
+    trm_ChildCount: int = element()
+    trm_ParentTermID: Optional[int] = element(default=None)
+    trm_Depth: int = element()
+    trm_Modified: datetime = element()
+    trm_LocallyModified: bool = element()
+    trm_Code: Optional[str] = element(default=None)
+    trm_SemanticReferenceURL: Optional[str] = element(default=None)
+    trm_IllustrationURL: Optional[str] = element(default=None)
+    trm_VocabularyGroupID: Optional[int] = element(default=None)
+    trm_OrderInBranch: Optional[int] = element(default=None)

heurist/models/structural/utils.py

@@ -0,0 +1,53 @@
+"""Module for utilities commonly used by XML parsers in schemas."""
+
+import json
+
+
+def split_ids(input: str) -> list:
+    """Function for converting a string representation of a list of quoted integers \
+        into a Python list object.
+
+    Examples:
+        >>> s = "3001,3110,3113,3288"
+        >>> split_ids(s)
+        [3001, 3110, 3113, 3288]
+        >>> s = '[\\"3001\\",\\"3110\\",\\"3113\\",\\"3288\\"]'
+        >>> split_ids(s)
+        [3001, 3110, 3113, 3288]
+        >>> l = ['[\\"3001\\",\\"3110\\",\\"3113\\",\\"3288\\"]']
+        >>> split_ids(l)
+        [3001, 3110, 3113, 3288]
+        >>> s = '[]'
+        >>> split_ids(s)
+        []
+
+    Args:
+        input (str|Any): List of integers.
+
+    Returns:
+        list: _description_
+    """
+
+    # Handle input of potentially malformatted JSON list
+    if isinstance(input, list) or "[" in input:
+        if not isinstance(input, str):
+            s = json.dumps(input)
+            if not isinstance(s, str):
+                print(input)
+                raise TypeError("Integer list was not converted to string.")
+        else:
+            s = input
+
+        # Remove the JSON string escape characters
+        s = s.replace("\\", "")
+        s = s.replace('"', "")
+        s = s.replace("[", "")
+        s = s.replace("]", "")
+
+        input_string = s
+
+    else:
+        input_string = input
+
+    # Split and recast regular string
+    return [int(i) for i in input_string.split(",") if i != ""]

heurist/schema/__init__.py

@@ -0,0 +1,27 @@
+import json
+from datetime import date
+from pathlib import Path
+
+import duckdb
+from heurist.schema.rel_to_dict import convert_rty_description
+from heurist.sql.sql_safety import SafeSQLName
+
+
+def output_csv(dir: Path, descriptions: list[duckdb.DuckDBPyRelation]) -> None:
+    for rel in descriptions:
+        name = rel.select("rty_Name").limit(1).fetchone()[0]
+        safe_name = SafeSQLName().create_table_name(name)
+        fp = dir.joinpath(safe_name).with_suffix(".csv")
+        rel.write_csv(file_name=str(fp), header=True)
+
+
+def output_json(descriptions: list[duckdb.DuckDBPyRelation], fp: Path) -> None:
+    date_string = date.today().isoformat()
+    data = {"lastModified": date_string, "items": []}
+    for desc in descriptions:
+        kv_dict = convert_rty_description(description=desc)
+        for id, metadata in kv_dict.items():
+            d = {"id": id} | metadata
+            data["items"].append(d)
+    with open(fp, "w", encoding="utf-8") as f:
+        json.dump(data, f, indent=4, ensure_ascii=False)

heurist/schema/models.py

@@ -0,0 +1,70 @@
+from typing import List, Optional
+
+from pydantic import BaseModel
+from pydantic.functional_validators import BeforeValidator
+from typing_extensions import Annotated
+
+
+def convert_vocab_map_to_list(vocab_map: dict | None) -> list[dict]:
+    """
+    Convert map generated in the SQL query to a list of vocab dictionary objects.
+
+    See the SQL query in the sql/ directory. The relevant selection is:
+        map(list(trm_Label), list(
+            {
+                "description": trm_Description,
+                "url": trm_SemanticReferenceURL,
+                "id": trm_ID
+            })
+        ) AS terms
+
+    Examples:
+        >>> vocab0 = {'perg': {'description': 'Parchment', 'url': None, 'id': 9782}}
+        >>> vocab1 = {'chart': {'description': 'Paper', 'url': None, 'id': 9783}}
+        >>> vocab2 = {'mixed': {'description': None, 'url': None, 'id': 9785}}
+        >>> map = vocab0 | vocab1 | vocab2
+        >>> terms = convert_vocab_map_to_list(map)
+        >>> len(terms)
+        3
+        >>> terms[0]
+        {'label': 'perg', 'description': 'Parchment', 'url': None, 'id': 9782}
+
+    Args:
+        vocab_map (dict | None): Map created in SQL query from aggregation function.
+
+    Returns:
+        list[dict]: List of vocabulary term metadata in dictionary objects.
+    """
+
+    vocab_terms = []
+    if vocab_map:
+        for k, v in vocab_map.items():
+            nd = {"label": k} | v
+            vocab_terms.append(nd)
+    return vocab_terms
+
+
+VocabTerms = Annotated[list, BeforeValidator(convert_vocab_map_to_list)]
+
+
+class DTY(BaseModel):
+    rst_DisplayName: str
+    rst_DisplayHelpText: str
+    dty_ID: int
+    dty_Type: str
+    dty_PtrTargetRectypeIDs: Optional[List[int]]
+    dty_SemanticReferenceURL: Optional[str]
+    trm_TreeID: Optional[int]
+    trm_Label: Optional[str]
+    trm_Description: Optional[str]
+    rst_RequirementType: str
+    rst_MaxValues: int
+    vocabTerms: Optional[VocabTerms]
+
+
+class RTY(BaseModel):
+    rty_ID: int
+    rty_Name: str
+    rty_Description: str
+    rty_TitleMask: str
+    rty_ReferenceURL: Optional[str]

heurist/schema/rel_to_dict.py

@@ -0,0 +1,39 @@
+import duckdb
+from heurist.schema.models import DTY, RTY
+from heurist.utils.rel_to_dict_array import rel_to_dict_array
+
+
+def convert_rty_description(description: duckdb.DuckDBPyRelation) -> dict:
+    """
+    Convert the SQL result of the joined record type schema description into \
+    a Python dictionary.
+
+    Args:
+        description (duckdb.DuckDBPyRelation): Relation from SQL query.
+
+    Returns:
+        dict: Dictionary representation of a record's schema.
+    """
+
+    rel = description.filter("dty_Type not like 'separator'").order(
+        "group_id asc, rst_DisplayOrder asc"
+    )
+
+    sections = {}
+
+    for field in rel_to_dict_array(rel):
+        section_id = field["group_id"]
+        section_name = field["sec"]
+        if not sections.get(section_id):
+            sections.update({section_id: {"sectionName": section_name, "fields": []}})
+        field_model = DTY.model_validate(field).model_dump()
+        sections[section_id]["fields"].append(field_model)
+
+    section_list = list(sections.values())
+
+    rty_rel = rel.limit(1)
+    rty_data = rel_to_dict_array(rty_rel)[0]
+    rty = RTY.model_validate(rty_data)
+
+    output = {rty.rty_ID: {"metadata": rty.model_dump(), "sections": section_list}}
+    return output

heurist/sql/__init__.py

@@ -0,0 +1,21 @@
+from pathlib import Path
+
+file_path_record_type_schema = Path(__file__).parent.joinpath(
+    "selectRecordTypeSchema.sql"
+)
+file_path_record_type_metadata_by_group_type = Path(__file__).parent.joinpath(
+    "joinRecordTypeIDNameByGroupType.sql"
+)
+file_path_fully_joined_record_type_metadata = Path(__file__).parent.joinpath(
+    "joinRecordTypeMetadata.sql"
+)
+
+
+with open(file_path_record_type_schema) as f:
+    RECORD_TYPE_SCHEMA = f.read()
+
+with open(file_path_record_type_metadata_by_group_type) as f:
+    RECORD_BY_GROUP_TYPE = f.read()
+
+with open(file_path_fully_joined_record_type_metadata) as f:
+    RECORD_TYPE_METADATA = f.read()

heurist/sql/joinRecordTypeIDNameByGroupType.sql

@@ -0,0 +1,10 @@
+/* Select the ID and name of record types that are in
+targeted record type groups.
+
+This query should be appended with 1 or more conditions
+of "rtg.rtg_Name" = '<target group name>'. */
+SELECT
+    rty.rty_ID,
+    rty.rty_Name
+FROM rty
+INNER JOIN rtg ON rty.rty_RecTypeGroupID = rtg.rtg_ID

heurist/sql/joinRecordTypeMetadata.sql

@@ -0,0 +1,17 @@
+/* Join the tables Record Structure (rst), Detail Type (dty),
+and Record Type (rty) to get all the relevant information
+about a record type's data fields.
+
+This query requires a parameter: the record type ID. */
+SELECT
+    dty_ID,
+    rst_DisplayName,
+    dty_Type,
+    rst_MaxValues
+FROM rst
+INNER JOIN rty ON rst.rst_RecTypeID = rty.rty_ID
+INNER JOIN dty ON rst.rst_DetailTypeID = dty.dty_ID
+WHERE rty.rty_ID = ?
+AND dty.dty_Type NOT LIKE 'separator'
+AND dty.dty_Type NOT LIKE 'relmarker'
+ORDER BY rst.rst_DisplayOrder

heurist/sql/selectRecordTypeSchema.sql

@@ -0,0 +1,51 @@
+/* Build a selection of data fields for a record type that
+groups the fields by their groups in Heurist's interface,
+as defined by the "separator" field Heurist adds between
+fields of two different groups.
+
+This query requires a parameter: the record type ID. */
+SELECT
+	CASE
+		WHEN group_id != 0 THEN FIRST_VALUE(rst_DisplayName) OVER (PARTITION BY group_id)
+		ELSE NULL
+	END
+	AS sec,
+	CASE
+		WHEN group_id !=0 THEN FIRST_VALUE(rst_DisplayHelpText) OVER (PARTITION BY group_id)
+		ELSE NULL
+	END
+	AS secHelpText
+	, *
+FROM (
+SELECT *
+	FROM (
+			SELECT
+				COUNT(
+					CASE WHEN dty_type LIKE 'separator' THEN rst_DisplayName ELSE NULL end
+				) OVER (ORDER BY rst_DisplayOrder) AS group_id,
+				*
+			FROM rst
+			JOIN rty ON rst_RecTypeID = rty.rty_ID
+			JOIN dty ON rst_DetailTypeID = dty.dty_ID
+			WHERE rty_ID = ?
+	)
+	LEFT JOIN (
+		SELECT
+				a.vocab_id as trm_TreeID,
+				b.trm_Label,
+				b.trm_Description,
+				a.term_count as n_vocabTerms,
+				a.terms as vocabTerms
+			FROM (
+			SELECT
+				trm_ParentTermID AS vocab_id,
+				count(*) AS term_count,
+				map(list(trm_Label), list({"description": trm_Description, "url": trm_SemanticReferenceURL, "id": trm_ID})) AS terms
+			FROM trm
+			GROUP BY trm_ParentTermID
+			) a
+			LEFT JOIN trm b ON a.vocab_id = b.trm_ID
+	) c ON c.trm_TreeID = dty_JsonTermIDTree
+    ORDER BY rst_DisplayOrder
+)
+ORDER BY rst_DisplayOrder