OASIS Open Data Protocol (OData) TCIcon indicating the project type

OASIS Open Data Protocol (OData) TC

Uploaded image for project: 'OASIS Open Data Protocol (OData) TC'
  1. OASIS Open Data Protocol (OData) TC
  2. ODATA-1459

Clarify representation of property paths in groupby with leading segments being null

    Details

    • Type: Improvement
    • Status: Closed
    • Priority: Major
    • Resolution: Fixed
    • Affects Version/s: V4.0_CS02
    • Fix Version/s: V4.0_CSD04
    • Component/s: Data Aggregation
    • Labels:
      None
    • Environment:

      Applied

    • Proposal:
      Hide

      Rephrase the beginning of section 3.10 as follows (insertions are indented or italicized.)

      3.10 Transformation groupby

      The groupby transformation takes one or two parameters where the second is a list of set transformations, separated by forward slashes to express that they are consecutively applied.

      3.10.1 Simple Grouping

      In its simplest form the first parameter of groupby specifies the grouping properties, a comma-separated list of one or more single-valued property paths that is enclosed in parentheses. A path may consist of a sequence of single-valued navigation and complex properties. The same property path SHOULD NOT appear more than once; redundant property paths MAY be considered valid, but MUST NOT alter the meaning of the request. If the property path leads to a single-valued navigation property, this means grouping by the entity-id of the related entities. Other navigation properties specified in grouping property paths are expanded by default.

      The output set is constructed in five steps:

      1. For each instance in the input set:
        1. Create a projection of the instance with all related entities included that are reached via navigation properties that occur in the grouping properties.
        2. Remove from the projection all structural and navigation properties that are not traversed by any grouping property.
      2. The input set is split into subsets where two instances are in the same subset if their projections are the same with null considered different from absent.
      3. The set transformations from the second parameter are applied to each subset, resulting in a new set of potentially different structure and cardinality. If the second parameter is absent, each subset is transformed into a set consisting of a single instance without properties. Transformations may take into account the grouping properties for producing their result, e.g. aggregate removes properties that are used neither for grouping nor for aggregation.
      4. In each set resulting from the previous step, each entity and complex type, including nested complex and navigation properties, are augmented if necessary to include all primitive property values of the corresponding projection.
      5. The output set is the union of the augmented sets of the previous step.

      If the service is unable to group by same values for any of the specified properties, it MUST reject the request with an error response. It MUST NOT apply any implicit rules to group instances indirectly by another property related to it in some way.

       

      Show
      Rephrase the beginning of section 3.10 as follows (insertions are indented or italicized.) 3.10 Transformation groupby The groupby transformation takes one or two parameters where the second is a list of set transformations, separated by forward slashes to express that they are consecutively applied. 3.10.1 Simple Grouping In its simplest form the first parameter of groupby  specifies the grouping properties , a comma-separated list of one or more single-valued property paths that is enclosed in parentheses. A path may consist of a sequence of single-valued navigation and complex properties. The same property path SHOULD NOT appear more than once; redundant property paths MAY be considered valid, but MUST NOT alter the meaning of the request. If the property path leads to a single-valued navigation property, this means grouping by the entity-id of the related entities. Other navigation properties specified in grouping property paths are expanded by default. The output set is constructed in five steps: For each instance in the input set: Create a projection of the instance with all related entities included that are reached via navigation properties that occur in the grouping properties. Remove from the projection all structural and navigation properties that are not traversed by any grouping property. The input set is split into subsets where two instances are in the same subset if their projections are the same with null considered different from absent. The set transformations from the second parameter are applied to each subset, resulting in a new set of potentially different structure and cardinality. If the second parameter is absent, each subset is transformed into a set consisting of a single instance without properties. Transformations may take into account the grouping properties for producing their result, e.g. aggregate removes properties that are used neither for grouping nor for aggregation. In each set resulting from the previous step, each entity and complex type, including nested complex and navigation properties, are augmented if necessary to include all primitive property values of the corresponding projection. The output set is the union of the augmented sets of the previous step. If the service is unable to group by same values for any of the specified properties, it MUST reject the request with an error response. It MUST NOT apply any implicit rules to group instances indirectly by another property related to it in some way.  
    • Resolution:
      Hide

      https://www.oasis-open.org/apps/org/workgroup/odata/download.php/69519/odata-data-aggregation-ext-v4.0-wd05.docx

      Show
      https://www.oasis-open.org/apps/org/workgroup/odata/download.php/69519/odata-data-aggregation-ext-v4.0-wd05.docx

      Description

      The specification text contains an example for tranformation outerjoin whose result is applied to a subsequent groupby transformation:

      Example 66:

      GET ~/Customers?$apply=outerjoin(Sales as ProductSales)
                       /groupby((Country,ProductSales/Product/Name))

      returning

      {
  "@odata.context":"$metadata#Customers(Country,ProductSales(Product(Name)))",
  "value": [
     { "Country": "Netherlands",
      "ProductSales": { "Product": { "Name": "Paper"  } } },
     { "Country": "Netherlands",
      "ProductSales": { "Product": { "Name": "Sugar"  } } },
     { "Country": "USA",
      "ProductSales": { "Product": { "Name": "Coffee" } } },
     { "Country": "USA",
      "ProductSales": { "Product": { "Name": "Paper"  } } },
     { "Country": "USA",
      "ProductSales": { "Product": { "Name": "Sugar"  } } },
    { "Country": "France", "ProductSales": null }
  ]
}

      —

      Looking at the first step, outerjoin returns combinations of customer instances and the related sales instances:

      [
  { 'ID': 'C1', 'Name': 'Joe', 'Country': 'USA', 'ProductSales': { 'ID': '1', … } },
  { 'ID': 'C1', 'Name': 'Joe', 'Country': 'USA', 'ProductSales': { 'ID': '2', … } },
  …
  { 'ID': 'C4', 'Name': Luc', 'Country': France', 'ProductSales': null }
]

      The following groupby operates on two grouping properties: Country and ProductSales/Product/Name.

      The latter property path is not defined for the last instance returned by outerjoin. Intuition says its value should be null.

      It should be clarified

      1. that the value for such a property path is clearly defined in some specification, when a leading segment is already null
      2. how the groupby result should look like for the last instance returned by outerjoin:
        1. like shown above:
          'ProductSales': null
        2. returning the complete structure of the grouping property:
          {{ 'ProductSales':
          Unknown macro: { 'Product'}

          }

       

       

       

        Attachments

          Activity

          Ascending order - Click to sort in descending order
          gerald.krause1 Gerald Krause created issue -
          gerald.krause1 Gerald Krause made changes -
          Field Original Value New Value
          Description The specification text contains an example for tranformation {{outerjoin}} whose result is applied to a subsequent {{groupby}} transformation:

          Example 66:
          {code:java}
          GET ~/Customers?$apply=outerjoin(Sales as ProductSales)
                                 /groupby((Country,ProductSales/Product/Name))
          {code}
          returning
          {code:java}
          {
            "@odata.context":"$metadata#Customers(Country,ProductSales(Product(Name)))",
            "value": [
               { "Country": "Netherlands",
                "ProductSales": { "Product": { "Name": "Paper"  } },
               { "Country": "Netherlands",
                "ProductSales": { "Product": { "Name": "Sugar"  } },
               { "Country": "USA",
                "ProductSales": { "Product": { "Name": "Coffee" } },
               { "Country": "USA",
                "ProductSales": { "Product": { "Name": "Paper"  } },
               { "Country": "USA",
                "ProductSales": { "Product": { "Name": "Sugar"  } },
              { "Country": "France", "ProductSales": null }
            ]
          }
          {code}
          ---

          Looking at the first step, {{outerjoin}} returns combinations of customer instances and the related sales instances:
          {code:java}
          [
            { 'ID': 'C1', 'Name': 'Joe', 'Country': 'USA', 'ProductSales': { 'ID': '1', … } },
            { 'ID': 'C1', 'Name': 'Joe', 'Country': 'USA', 'ProductSales': { 'ID': '2', … } },
            …
            { 'ID': 'C4', 'Name': Luc', 'Country': France', 'ProductSales': null }
          ]
          {code}
          The following {{groupby}} operates on two grouping properties: {{Country}} and {{ProductSales/Product/Name}}.

          The latter property path is not defined for the last instance returned by {{outerjoin}}. Intuition says its value should be null.

          It should be clarified
           # that the value for such a property path is clearly defined in some specification, when a leading segment is already null
           # how the {{groupby}} result should look like for the last instance returned by {{outerjoin}}:
           ## like shown above:
           {{'ProductSales': null}}
           ## returning the complete structure of the grouping property:
           {{'ProductSales': \{ 'Product': { 'Name': null } } }}

           

           

                      		The specification text contains an example for tranformation {{outerjoin}} whose result is applied to a subsequent {{groupby}} transformation:

          Example 66:
          {code:java}
          GET ~/Customers?$apply=outerjoin(Sales as ProductSales)
                                 /groupby((Country,ProductSales/Product/Name))
          {code}
          returning
          {code:java}
          {
            "@odata.context":"$metadata#Customers(Country,ProductSales(Product(Name)))",
            "value": [
               { "Country": "Netherlands",
                "ProductSales": { "Product": { "Name": "Paper"  } },
               { "Country": "Netherlands",
                "ProductSales": { "Product": { "Name": "Sugar"  } },
               { "Country": "USA",
                "ProductSales": { "Product": { "Name": "Coffee" } },
               { "Country": "USA",
                "ProductSales": { "Product": { "Name": "Paper"  } },
               { "Country": "USA",
                "ProductSales": { "Product": { "Name": "Sugar"  } },
              { "Country": "France", "ProductSales": null }
            ]
          }
          {code}
          —

          Looking at the first step, {{outerjoin}} returns combinations of customer instances and the related sales instances:
          {code:java}
          [
            { 'ID': 'C1', 'Name': 'Joe', 'Country': 'USA', 'ProductSales': { 'ID': '1', … } },
            { 'ID': 'C1', 'Name': 'Joe', 'Country': 'USA', 'ProductSales': { 'ID': '2', … } },
            …
            { 'ID': 'C4', 'Name': Luc', 'Country': France', 'ProductSales': null }
          ]
          {code}
          The following {{groupby}} operates on two grouping properties: {{Country}} and {{ProductSales/Product/Name}}.

          The latter property path is not defined for the last instance returned by {{outerjoin}}. Intuition says its value should be null.

          It should be clarified
           # that the value for such a property path is clearly defined in some specification, when a leading segment is already null
           # how the {{groupby}} result should look like for the last instance returned by {{outerjoin}}:
           ## like shown above:
           {{'ProductSales': null}}
           ## returning the complete structure of the grouping property:
          {{ 'ProductSales': \{ 'Product': { 'Name': null } }}}

           

           

           
          gerald.krause1 Gerald Krause made changes -
          Summary Clarify representation of property paths with leading segments being null Clarify representation of property paths in groupby with leading segments being null
          heiko.theissen Heiko Theissen made changes -
          Status New [ 10000 ] Open [ 1 ]
          gerald.krause1 Gerald Krause made changes -
          Proposal [5.1.1.15 Path Expressions|https://docs.oasis-open.org/odata/odata/v4.01/os/part2-url-conventions/odata-v4.01-os-part2-url-conventions.html#sec_PathExpressions] states that a property path has value {{null}}, if one if its complex properties is null, or no entity is related. Hence, all of the following possible input entities will be grouped under the same value {{null}} for the requested {{Name}} property:
          {code:java}
          [ {"ProductSales": null},
            {"ProductSales": {"Product": null}},
            {"ProductSales": {"Product": { "Name": null }}} ]
          {code}
           Therefore, the result of the {{groupby }}in example 66 includes a {{null}} value for the last instance.:
          {code:java}
          { "Country": "France",
                "ProductSales": { "Product": { "Name": null  } } }
          {code}
          The specification text needs to be fixed accordingly.
          Description The specification text contains an example for tranformation {{outerjoin}} whose result is applied to a subsequent {{groupby}} transformation:

          Example 66:
          {code:java}
          GET ~/Customers?$apply=outerjoin(Sales as ProductSales)
                                 /groupby((Country,ProductSales/Product/Name))
          {code}
          returning
          {code:java}
          {
            "@odata.context":"$metadata#Customers(Country,ProductSales(Product(Name)))",
            "value": [
               { "Country": "Netherlands",
                "ProductSales": { "Product": { "Name": "Paper"  } },
               { "Country": "Netherlands",
                "ProductSales": { "Product": { "Name": "Sugar"  } },
               { "Country": "USA",
                "ProductSales": { "Product": { "Name": "Coffee" } },
               { "Country": "USA",
                "ProductSales": { "Product": { "Name": "Paper"  } },
               { "Country": "USA",
                "ProductSales": { "Product": { "Name": "Sugar"  } },
              { "Country": "France", "ProductSales": null }
            ]
          }
          {code}
          —

          Looking at the first step, {{outerjoin}} returns combinations of customer instances and the related sales instances:
          {code:java}
          [
            { 'ID': 'C1', 'Name': 'Joe', 'Country': 'USA', 'ProductSales': { 'ID': '1', … } },
            { 'ID': 'C1', 'Name': 'Joe', 'Country': 'USA', 'ProductSales': { 'ID': '2', … } },
            …
            { 'ID': 'C4', 'Name': Luc', 'Country': France', 'ProductSales': null }
          ]
          {code}
          The following {{groupby}} operates on two grouping properties: {{Country}} and {{ProductSales/Product/Name}}.

          The latter property path is not defined for the last instance returned by {{outerjoin}}. Intuition says its value should be null.

          It should be clarified
           # that the value for such a property path is clearly defined in some specification, when a leading segment is already null
           # how the {{groupby}} result should look like for the last instance returned by {{outerjoin}}:
           ## like shown above:
           {{'ProductSales': null}}
           ## returning the complete structure of the grouping property:
          {{ 'ProductSales': \{ 'Product': { 'Name': null } }}}

           

           

                      		The specification text contains an example for tranformation {{outerjoin}} whose result is applied to a subsequent {{groupby}} transformation:

          Example 66:
          {code:java}
          GET ~/Customers?$apply=outerjoin(Sales as ProductSales)
                                 /groupby((Country,ProductSales/Product/Name))
          {code}
          returning
          {code:java}
          {
            "@odata.context":"$metadata#Customers(Country,ProductSales(Product(Name)))",
            "value": [
               { "Country": "Netherlands",
                "ProductSales": { "Product": { "Name": "Paper"  } } },
               { "Country": "Netherlands",
                "ProductSales": { "Product": { "Name": "Sugar"  } } },
               { "Country": "USA",
                "ProductSales": { "Product": { "Name": "Coffee" } } },
               { "Country": "USA",
                "ProductSales": { "Product": { "Name": "Paper"  } } },
               { "Country": "USA",
                "ProductSales": { "Product": { "Name": "Sugar"  } } },
              { "Country": "France", "ProductSales": null }
            ]
          }
          {code}
          —

          Looking at the first step, {{outerjoin}} returns combinations of customer instances and the related sales instances:
          {code:java}
          [
            { 'ID': 'C1', 'Name': 'Joe', 'Country': 'USA', 'ProductSales': { 'ID': '1', … } },
            { 'ID': 'C1', 'Name': 'Joe', 'Country': 'USA', 'ProductSales': { 'ID': '2', … } },
            …
            { 'ID': 'C4', 'Name': Luc', 'Country': France', 'ProductSales': null }
          ]
          {code}
          The following {{groupby}} operates on two grouping properties: {{Country}} and {{ProductSales/Product/Name}}.

          The latter property path is not defined for the last instance returned by {{outerjoin}}. Intuition says its value should be null.

          It should be clarified
           # that the value for such a property path is clearly defined in some specification, when a leading segment is already null
           # how the {{groupby}} result should look like for the last instance returned by {{outerjoin}}:
           ## like shown above:
           {{'ProductSales': null}}
           ## returning the complete structure of the grouping property:
           \{{ 'ProductSales': { 'Product': { 'Name': null }
          }}}

           

           

           
          gerald.krause1 Gerald Krause made changes -
          Environment Proposed
          gerald.krause1 Gerald Krause made changes -
          Proposal [5.1.1.15 Path Expressions|https://docs.oasis-open.org/odata/odata/v4.01/os/part2-url-conventions/odata-v4.01-os-part2-url-conventions.html#sec_PathExpressions] states that a property path has value {{null}}, if one if its complex properties is null, or no entity is related. Hence, all of the following possible input entities will be grouped under the same value {{null}} for the requested {{Name}} property:
          {code:java}
          [ {"ProductSales": null},
            {"ProductSales": {"Product": null}},
            {"ProductSales": {"Product": { "Name": null }}} ]
          {code}
           Therefore, the result of the {{groupby }}in example 66 includes a {{null}} value for the last instance.:
          {code:java}
          { "Country": "France",
                "ProductSales": { "Product": { "Name": null  } } }
          {code}
          The specification text needs to be fixed accordingly.           		  See discussion and proposal in [this document|https://www.oasis-open.org/apps/org/workgroup/odata/download.php/69403/ODATA-1459.docx]
          gerald.krause1 Gerald Krause made changes -
          Proposal   See discussion and proposal in [this document|https://www.oasis-open.org/apps/org/workgroup/odata/download.php/69403/ODATA-1459.docx]   See discussion and proposal in [this document|https://www.oasis-open.org/apps/org/workgroup/odata/download.php/69409/ODATA-1459.docx]
          gerald.krause1 Gerald Krause made changes -
          Proposal   See discussion and proposal in [this document|https://www.oasis-open.org/apps/org/workgroup/odata/download.php/69409/ODATA-1459.docx]   See discussion and proposal in [this document|https://www.oasis-open.org/apps/org/workgroup/odata/download.php/69410/ODATA-1459.docx]
          gerald.krause1 Gerald Krause made changes -
          Proposal   See discussion and proposal in [this document|https://www.oasis-open.org/apps/org/workgroup/odata/download.php/69410/ODATA-1459.docx]   See discussion and proposal in [this document|https://www.oasis-open.org/apps/org/workgroup/odata/download.php/69428/ODATA-1459.docx]
          heiko.theissen Heiko Theissen made changes -
          Proposal   See discussion and proposal in [this document|https://www.oasis-open.org/apps/org/workgroup/odata/download.php/69428/ODATA-1459.docx] See discussion and proposal in [this document|https://www.oasis-open.org/apps/org/workgroup/odata/download.php/69428/ODATA-1459.docx]

          Rephrase the beginning of section 3.10 as follows:

          h2. 3.10 [Transformation groupby|#sec_Transformationgroupby]

          The {{groupby}} transformation takes one or two parameters _where the second is a list of set transformations, separated by forward slashes to express that they are consecutively applied._

          h3. 3.10.1 [Simple Grouping|#sec_SimpleGrouping]

          In its simplest form the first parameter of groupby specifies the _grouping properties_, a comma-separated list of one or more that is enclosed in parentheses. A path may consist of a sequence of single-valued navigation and complex properties. The same property path SHOULD NOT appear more than once; redundant property paths MAY be considered valid, but MUST NOT alter the meaning of the request. If the property path leads to a single-valued navigation property, this means grouping by the entity-id of the related entities. Other navigation properties specified in grouping property paths are expanded by default.

          {quote}The output set is constructed in four steps:
          # For each instance in the input set, its _group key_ is constructed as follows:
          ## Include in the instance all related entities that are reached via navigation properties that occur in the grouping properties specified in the first parameter.
          ## Remove from the resulting object tree all nodes that are not traversed by any grouping property.
          # The input set is split into subsets according to the group keys. Group keys are compared as instances where instances are the same if
          ## they have the same primitive properties with the same values and
          ## they have the same complex properties whose values are the same as instances.
          # The set transformations from the second parameter are applies to each subset, resulting in a new set of potentially different structure and cardinality. If the second parameter is absent, {{groupby}} transforms each subset into a set consisting of a single instance without properties. -Transformations may take into account the grouping properties for producing their result, e.g. aggregate removes properties that are used neither for grouping nor for aggregation.-
          # In each output set of the previous step, augment every instance if necessary so that it comprises the group key of its subset.
          # Concatenate the output sets of the previous step into one output set.
          {quote}

          Merge [PR #176|https://github.com/oasis-tcs/odata-vocabularies/pull/176].
          heiko.theissen Heiko Theissen made changes -
          Proposal See discussion and proposal in [this document|https://www.oasis-open.org/apps/org/workgroup/odata/download.php/69428/ODATA-1459.docx]

          Rephrase the beginning of section 3.10 as follows:

          h2. 3.10 [Transformation groupby|#sec_Transformationgroupby]

          The {{groupby}} transformation takes one or two parameters _where the second is a list of set transformations, separated by forward slashes to express that they are consecutively applied._

          h3. 3.10.1 [Simple Grouping|#sec_SimpleGrouping]

          In its simplest form the first parameter of groupby specifies the _grouping properties_, a comma-separated list of one or more that is enclosed in parentheses. A path may consist of a sequence of single-valued navigation and complex properties. The same property path SHOULD NOT appear more than once; redundant property paths MAY be considered valid, but MUST NOT alter the meaning of the request. If the property path leads to a single-valued navigation property, this means grouping by the entity-id of the related entities. Other navigation properties specified in grouping property paths are expanded by default.

          {quote}The output set is constructed in four steps:
          # For each instance in the input set, its _group key_ is constructed as follows:
          ## Include in the instance all related entities that are reached via navigation properties that occur in the grouping properties specified in the first parameter.
          ## Remove from the resulting object tree all nodes that are not traversed by any grouping property.
          # The input set is split into subsets according to the group keys. Group keys are compared as instances where instances are the same if
          ## they have the same primitive properties with the same values and
          ## they have the same complex properties whose values are the same as instances.
          # The set transformations from the second parameter are applies to each subset, resulting in a new set of potentially different structure and cardinality. If the second parameter is absent, {{groupby}} transforms each subset into a set consisting of a single instance without properties. -Transformations may take into account the grouping properties for producing their result, e.g. aggregate removes properties that are used neither for grouping nor for aggregation.-
          # In each output set of the previous step, augment every instance if necessary so that it comprises the group key of its subset.
          # Concatenate the output sets of the previous step into one output set.
          {quote}

          Merge [PR #176|https://github.com/oasis-tcs/odata-vocabularies/pull/176].           		See discussion and proposal in [this document|https://www.oasis-open.org/apps/org/workgroup/odata/download.php/69428/ODATA-1459.docx]

          Rephrase the beginning of section 3.10 as follows:
          h2. 3.10 [Transformation groupby|#sec_Transformationgroupby]

          The {{groupby}} transformation takes one or two parameters _where the second is a list of set transformations, separated by forward slashes to express that they are consecutively applied._
          h3. 3.10.1 [Simple Grouping|#sec_SimpleGrouping]

          In its simplest form the first parameter of groupby specifies the _grouping properties_, a comma-separated list of one or more that is enclosed in parentheses. A path may consist of a sequence of single-valued navigation and complex properties. The same property path SHOULD NOT appear more than once; redundant property paths MAY be considered valid, but MUST NOT alter the meaning of the request. If the property path leads to a single-valued navigation property, this means grouping by the entity-id of the related entities. Other navigation properties specified in grouping property paths are expanded by default.
          {quote}The output set is constructed in five steps:
           # For each instance in the input set, its _group key_ is constructed as follows:
           ## Include in the instance all related entities that are reached via navigation properties that occur in the grouping properties specified in the first parameter.
           ## Remove from the resulting object tree all nodes that are not traversed by any grouping property.
           # The input set is split into subsets according to the group keys. Group keys are compared as instances where instances are the same if
           ## they have the same primitive properties with the same values and
           ## they have the same complex properties whose values are the same as instances.
           # The set transformations from the second parameter are applies to each subset, resulting in a new set of potentially different structure and cardinality. If the second parameter is absent, {{groupby}} transforms each subset into a set consisting of a single instance without properties. -Transformations may take into account the grouping properties for producing their result, e.g. aggregate removes properties that are used neither for grouping nor for aggregation.-
           # In each output set of the previous step, augment every instance if necessary so that it comprises the group key of its subset.
           # Concatenate the output sets of the previous step into one output set.{quote}
          Merge [PR #176|https://github.com/oasis-tcs/odata-vocabularies/pull/176].
          heiko.theissen Heiko Theissen made changes -
          Proposal See discussion and proposal in [this document|https://www.oasis-open.org/apps/org/workgroup/odata/download.php/69428/ODATA-1459.docx]

          Rephrase the beginning of section 3.10 as follows:
          h2. 3.10 [Transformation groupby|#sec_Transformationgroupby]

          The {{groupby}} transformation takes one or two parameters _where the second is a list of set transformations, separated by forward slashes to express that they are consecutively applied._
          h3. 3.10.1 [Simple Grouping|#sec_SimpleGrouping]

          In its simplest form the first parameter of groupby specifies the _grouping properties_, a comma-separated list of one or more that is enclosed in parentheses. A path may consist of a sequence of single-valued navigation and complex properties. The same property path SHOULD NOT appear more than once; redundant property paths MAY be considered valid, but MUST NOT alter the meaning of the request. If the property path leads to a single-valued navigation property, this means grouping by the entity-id of the related entities. Other navigation properties specified in grouping property paths are expanded by default.
          {quote}The output set is constructed in five steps:
           # For each instance in the input set, its _group key_ is constructed as follows:
           ## Include in the instance all related entities that are reached via navigation properties that occur in the grouping properties specified in the first parameter.
           ## Remove from the resulting object tree all nodes that are not traversed by any grouping property.
           # The input set is split into subsets according to the group keys. Group keys are compared as instances where instances are the same if
           ## they have the same primitive properties with the same values and
           ## they have the same complex properties whose values are the same as instances.
           # The set transformations from the second parameter are applies to each subset, resulting in a new set of potentially different structure and cardinality. If the second parameter is absent, {{groupby}} transforms each subset into a set consisting of a single instance without properties. -Transformations may take into account the grouping properties for producing their result, e.g. aggregate removes properties that are used neither for grouping nor for aggregation.-
           # In each output set of the previous step, augment every instance if necessary so that it comprises the group key of its subset.
           # Concatenate the output sets of the previous step into one output set.{quote}
          Merge [PR #176|https://github.com/oasis-tcs/odata-vocabularies/pull/176].           		See discussion and proposal in [this document|https://www.oasis-open.org/apps/org/workgroup/odata/download.php/69428/ODATA-1459.docx]

          Rephrase the beginning of section 3.10 as follows (insertions are indented or italicized.)
          h2. 3.10 [Transformation groupby|#sec_Transformationgroupby]

          The {{groupby}} transformation takes one or two parameters _where the second is a list of set transformations, separated by forward slashes to express that they are consecutively applied._
          h3. 3.10.1 [Simple Grouping|#sec_SimpleGrouping]

          In its simplest form the first parameter of groupby specifies the _grouping properties_, a comma-separated list of one or more that is enclosed in parentheses. A path may consist of a sequence of single-valued navigation and complex properties. The same property path SHOULD NOT appear more than once; redundant property paths MAY be considered valid, but MUST NOT alter the meaning of the request. If the property path leads to a single-valued navigation property, this means grouping by the entity-id of the related entities. Other navigation properties specified in grouping property paths are expanded by default.
          {quote}The output set is constructed in five steps:
           # For each instance in the input set, its _group key_ is constructed as follows:
           ## Include in the instance all related entities that are reached via navigation properties that occur in the grouping properties specified in the first parameter.
           ## Remove from the resulting object tree all nodes that are not traversed by any grouping property.
           # The input set is split into subsets according to the group keys. Group keys are compared as instances where instances are the same if
           ## they have the same primitive properties with the same values and
           ## they have the same complex properties whose values are the same as instances.
           # The set transformations from the second parameter are applied to each subset, resulting in a new set of potentially different structure and cardinality. If the second parameter is absent, each subset is transformed into a set consisting of a single instance without properties. -Transformations may take into account the grouping properties for producing their result, e.g. aggregate removes properties that are used neither for grouping nor for aggregation.-
           # In each output set of the previous step, every instance is augmented if necessary so that it comprises the group key of its subset.
           # The output sets of the previous step are concatenated into one output set.{quote}
          (Step 5 ensures that the grouping properties appear consecutively in the output set. Is this always intended?)

          Merge [PR #176|https://github.com/oasis-tcs/odata-vocabularies/pull/176].
          heiko.theissen Heiko Theissen made changes -
          Proposal See discussion and proposal in [this document|https://www.oasis-open.org/apps/org/workgroup/odata/download.php/69428/ODATA-1459.docx]

          Rephrase the beginning of section 3.10 as follows (insertions are indented or italicized.)
          h2. 3.10 [Transformation groupby|#sec_Transformationgroupby]

          The {{groupby}} transformation takes one or two parameters _where the second is a list of set transformations, separated by forward slashes to express that they are consecutively applied._
          h3. 3.10.1 [Simple Grouping|#sec_SimpleGrouping]

          In its simplest form the first parameter of groupby specifies the _grouping properties_, a comma-separated list of one or more that is enclosed in parentheses. A path may consist of a sequence of single-valued navigation and complex properties. The same property path SHOULD NOT appear more than once; redundant property paths MAY be considered valid, but MUST NOT alter the meaning of the request. If the property path leads to a single-valued navigation property, this means grouping by the entity-id of the related entities. Other navigation properties specified in grouping property paths are expanded by default.
          {quote}The output set is constructed in five steps:
           # For each instance in the input set, its _group key_ is constructed as follows:
           ## Include in the instance all related entities that are reached via navigation properties that occur in the grouping properties specified in the first parameter.
           ## Remove from the resulting object tree all nodes that are not traversed by any grouping property.
           # The input set is split into subsets according to the group keys. Group keys are compared as instances where instances are the same if
           ## they have the same primitive properties with the same values and
           ## they have the same complex properties whose values are the same as instances.
           # The set transformations from the second parameter are applied to each subset, resulting in a new set of potentially different structure and cardinality. If the second parameter is absent, each subset is transformed into a set consisting of a single instance without properties. -Transformations may take into account the grouping properties for producing their result, e.g. aggregate removes properties that are used neither for grouping nor for aggregation.-
           # In each output set of the previous step, every instance is augmented if necessary so that it comprises the group key of its subset.
           # The output sets of the previous step are concatenated into one output set.{quote}
          (Step 5 ensures that the grouping properties appear consecutively in the output set. Is this always intended?)

          Merge [PR #176|https://github.com/oasis-tcs/odata-vocabularies/pull/176].           		See discussion and proposal in [this document|https://www.oasis-open.org/apps/org/workgroup/odata/download.php/69428/ODATA-1459.docx]

          Rephrase the beginning of section 3.10 as follows (insertions are indented or italicized.)
          h2. 3.10 [Transformation groupby|#sec_Transformationgroupby]

          The {{groupby}} transformation takes one or two parameters _where the second is a list of set transformations, separated by forward slashes to express that they are consecutively applied._
          h3. 3.10.1 [Simple Grouping|#sec_SimpleGrouping]

          In its simplest form the first parameter of groupby specifies the _grouping properties_, a comma-separated list of one or more that is enclosed in parentheses. A path may consist of a sequence of single-valued navigation and complex properties. The same property path SHOULD NOT appear more than once; redundant property paths MAY be considered valid, but MUST NOT alter the meaning of the request. If the property path leads to a single-valued navigation property, this means grouping by the entity-id of the related entities. Other navigation properties specified in grouping property paths are expanded by default.
          {quote}The output set is constructed in five steps:
           # For each instance in the input set, its _group key_ is constructed as follows:
           ## Include in the instance all related entities that are reached via navigation properties that occur in the grouping properties specified in the first parameter.
           ## Remove from the resulting object tree all nodes that are not traversed by any grouping property.
           # The input set is split into subsets according to the group keys. Group keys are compared as instances where instances are the same if
           ## they have the same primitive properties with the same values and
           ## they have the same complex properties whose values are the same as instances.
           # The set transformations from the second parameter are applied to each subset, resulting in a new set of potentially different structure and cardinality. If the second parameter is absent, each subset is transformed into a set consisting of a single instance without properties. -Transformations may take into account the grouping properties for producing their result, e.g. aggregate removes properties that are used neither for grouping nor for aggregation.-
           # In each output set of the previous step, every instance is augmented if necessary so that it comprises the group key of its subset.
           # The output sets of the previous step are concatenated into one output set.{quote}
          If the service is unable to group by same values for any of the specified properties, …

          (Step 5 ensures that the grouping properties appear consecutively in the output set. Is this always intended?)

          Merge [PR #176|https://github.com/oasis-tcs/odata-vocabularies/pull/176].
          heiko.theissen Heiko Theissen made changes -
          Proposal See discussion and proposal in [this document|https://www.oasis-open.org/apps/org/workgroup/odata/download.php/69428/ODATA-1459.docx]

          Rephrase the beginning of section 3.10 as follows (insertions are indented or italicized.)
          h2. 3.10 [Transformation groupby|#sec_Transformationgroupby]

          The {{groupby}} transformation takes one or two parameters _where the second is a list of set transformations, separated by forward slashes to express that they are consecutively applied._
          h3. 3.10.1 [Simple Grouping|#sec_SimpleGrouping]

          In its simplest form the first parameter of groupby specifies the _grouping properties_, a comma-separated list of one or more that is enclosed in parentheses. A path may consist of a sequence of single-valued navigation and complex properties. The same property path SHOULD NOT appear more than once; redundant property paths MAY be considered valid, but MUST NOT alter the meaning of the request. If the property path leads to a single-valued navigation property, this means grouping by the entity-id of the related entities. Other navigation properties specified in grouping property paths are expanded by default.
          {quote}The output set is constructed in five steps:
           # For each instance in the input set, its _group key_ is constructed as follows:
           ## Include in the instance all related entities that are reached via navigation properties that occur in the grouping properties specified in the first parameter.
           ## Remove from the resulting object tree all nodes that are not traversed by any grouping property.
           # The input set is split into subsets according to the group keys. Group keys are compared as instances where instances are the same if
           ## they have the same primitive properties with the same values and
           ## they have the same complex properties whose values are the same as instances.
           # The set transformations from the second parameter are applied to each subset, resulting in a new set of potentially different structure and cardinality. If the second parameter is absent, each subset is transformed into a set consisting of a single instance without properties. -Transformations may take into account the grouping properties for producing their result, e.g. aggregate removes properties that are used neither for grouping nor for aggregation.-
           # In each output set of the previous step, every instance is augmented if necessary so that it comprises the group key of its subset.
           # The output sets of the previous step are concatenated into one output set.{quote}
          If the service is unable to group by same values for any of the specified properties, …

          (Step 5 ensures that the grouping properties appear consecutively in the output set. Is this always intended?)

          Merge [PR #176|https://github.com/oasis-tcs/odata-vocabularies/pull/176].           		See discussion and proposal in [this document|https://www.oasis-open.org/apps/org/workgroup/odata/download.php/69428/ODATA-1459.docx]

          Rephrase the beginning of section 3.10 as follows (insertions are indented or italicized.)
          h2. 3.10 [Transformation groupby|#sec_Transformationgroupby]

          The {{groupby}} transformation takes one or two parameters _where the second is a list of set transformations, separated by forward slashes to express that they are consecutively applied._
          h3. 3.10.1 [Simple Grouping|#sec_SimpleGrouping]

          In its simplest form the first parameter of groupby specifies the _grouping properties_, a comma-separated list of one or more that is enclosed in parentheses. A path may consist of a sequence of single-valued navigation and complex properties. The same property path SHOULD NOT appear more than once; redundant property paths MAY be considered valid, but MUST NOT alter the meaning of the request. If the property path leads to a single-valued navigation property, this means grouping by the entity-id of the related entities. Other navigation properties specified in grouping property paths are expanded by default.
          {quote}The output set is constructed in five steps:
           # For each instance in the input set, its _group key_ is constructed as follows:
           ## Include in the instance all related entities that are reached via navigation properties that occur in the grouping properties.
           ## Remove from the resulting object tree all nodes that are not traversed by any grouping property.
           # The input set is split into subsets according to the group keys. Group keys are compared as instances where instances are the same if
           ## they have the same primitive properties with the same values and
           ## they have the same complex properties whose values are the same as instances.
           # The set transformations from the second parameter are applied to each subset, resulting in a new set of potentially different structure and cardinality. If the second parameter is absent, each subset is transformed into a set consisting of a single instance without properties. -Transformations may take into account the grouping properties for producing their result, e.g. aggregate removes properties that are used neither for grouping nor for aggregation.-
           # In each output set of the previous step, every instance is augmented if necessary so that it comprises the group key of its subset.
           # The output sets of the previous step are concatenated into one output set.{quote}
          If the service is unable to group by same values for any of the specified properties, …

          (Step 5 ensures that the grouping properties appear consecutively in the output set. Is this always intended?)

          Merge [PR #176|https://github.com/oasis-tcs/odata-vocabularies/pull/176].
          heiko.theissen Heiko Theissen made changes -
          Proposal See discussion and proposal in [this document|https://www.oasis-open.org/apps/org/workgroup/odata/download.php/69428/ODATA-1459.docx]

          Rephrase the beginning of section 3.10 as follows (insertions are indented or italicized.)
          h2. 3.10 [Transformation groupby|#sec_Transformationgroupby]

          The {{groupby}} transformation takes one or two parameters _where the second is a list of set transformations, separated by forward slashes to express that they are consecutively applied._
          h3. 3.10.1 [Simple Grouping|#sec_SimpleGrouping]

          In its simplest form the first parameter of groupby specifies the _grouping properties_, a comma-separated list of one or more that is enclosed in parentheses. A path may consist of a sequence of single-valued navigation and complex properties. The same property path SHOULD NOT appear more than once; redundant property paths MAY be considered valid, but MUST NOT alter the meaning of the request. If the property path leads to a single-valued navigation property, this means grouping by the entity-id of the related entities. Other navigation properties specified in grouping property paths are expanded by default.
          {quote}The output set is constructed in five steps:
           # For each instance in the input set, its _group key_ is constructed as follows:
           ## Include in the instance all related entities that are reached via navigation properties that occur in the grouping properties.
           ## Remove from the resulting object tree all nodes that are not traversed by any grouping property.
           # The input set is split into subsets according to the group keys. Group keys are compared as instances where instances are the same if
           ## they have the same primitive properties with the same values and
           ## they have the same complex properties whose values are the same as instances.
           # The set transformations from the second parameter are applied to each subset, resulting in a new set of potentially different structure and cardinality. If the second parameter is absent, each subset is transformed into a set consisting of a single instance without properties. -Transformations may take into account the grouping properties for producing their result, e.g. aggregate removes properties that are used neither for grouping nor for aggregation.-
           # In each output set of the previous step, every instance is augmented if necessary so that it comprises the group key of its subset.
           # The output sets of the previous step are concatenated into one output set.{quote}
          If the service is unable to group by same values for any of the specified properties, …

          (Step 5 ensures that the grouping properties appear consecutively in the output set. Is this always intended?)

          Merge [PR #176|https://github.com/oasis-tcs/odata-vocabularies/pull/176].           		See discussion and proposal in [this document|https://www.oasis-open.org/apps/org/workgroup/odata/download.php/69428/ODATA-1459.docx]

          Rephrase the beginning of section 3.10 as follows (insertions are indented or italicized.)
          h2. 3.10 [Transformation groupby|#sec_Transformationgroupby]

          The {{groupby}} transformation takes one or two parameters _where the second is a list of set transformations, separated by forward slashes to express that they are consecutively applied._
          h3. 3.10.1 [Simple Grouping|#sec_SimpleGrouping]

          In its simplest form the first parameter of {{groupby}} specifies the _grouping properties_, a comma-separated list of one or more single-valued property paths that is enclosed in parentheses. A path may consist of a sequence of single-valued navigation and complex properties. The same property path SHOULD NOT appear more than once; redundant property paths MAY be considered valid, but MUST NOT alter the meaning of the request. If the property path leads to a single-valued navigation property, this means grouping by the entity-id of the related entities. Other navigation properties specified in grouping property paths are expanded by default.
          {quote}The output set is constructed in five steps:
           # For each instance in the input set, its _group key_ is constructed as follows:
           ## Include in the instance all related entities that are reached via navigation properties that occur in the grouping properties.
           ## Remove from the resulting object tree all nodes that are not traversed by any grouping property.
           # The input set is split into subsets according to the group keys. Group keys are compared as instances where instances are the same if
           ## they have the same primitive properties with the same values and
           ## they have the same complex properties whose values are the same as instances.
           # The set transformations from the second parameter are applied to each subset, resulting in a new set of potentially different structure and cardinality. If the second parameter is absent, each subset is transformed into a set consisting of a single instance without properties. -Transformations may take into account the grouping properties for producing their result, e.g. aggregate removes properties that are used neither for grouping nor for aggregation.-
           # In each output set of the previous step, every instance is augmented if necessary so that it comprises the group key of its subset.
           # The output sets of the previous step are concatenated into one output set.{quote}
          If the service is unable to group by same values for any of the specified properties, …

          (Step 5 ensures that the grouping properties appear consecutively in the output set. Is this always intended?)

          Merge [PR #176|https://github.com/oasis-tcs/odata-vocabularies/pull/176].
          heiko.theissen Heiko Theissen made changes -
          Proposal See discussion and proposal in [this document|https://www.oasis-open.org/apps/org/workgroup/odata/download.php/69428/ODATA-1459.docx]

          Rephrase the beginning of section 3.10 as follows (insertions are indented or italicized.)
          h2. 3.10 [Transformation groupby|#sec_Transformationgroupby]

          The {{groupby}} transformation takes one or two parameters _where the second is a list of set transformations, separated by forward slashes to express that they are consecutively applied._
          h3. 3.10.1 [Simple Grouping|#sec_SimpleGrouping]

          In its simplest form the first parameter of {{groupby}} specifies the _grouping properties_, a comma-separated list of one or more single-valued property paths that is enclosed in parentheses. A path may consist of a sequence of single-valued navigation and complex properties. The same property path SHOULD NOT appear more than once; redundant property paths MAY be considered valid, but MUST NOT alter the meaning of the request. If the property path leads to a single-valued navigation property, this means grouping by the entity-id of the related entities. Other navigation properties specified in grouping property paths are expanded by default.
          {quote}The output set is constructed in five steps:
           # For each instance in the input set, its _group key_ is constructed as follows:
           ## Include in the instance all related entities that are reached via navigation properties that occur in the grouping properties.
           ## Remove from the resulting object tree all nodes that are not traversed by any grouping property.
           # The input set is split into subsets according to the group keys. Group keys are compared as instances where instances are the same if
           ## they have the same primitive properties with the same values and
           ## they have the same complex properties whose values are the same as instances.
           # The set transformations from the second parameter are applied to each subset, resulting in a new set of potentially different structure and cardinality. If the second parameter is absent, each subset is transformed into a set consisting of a single instance without properties. -Transformations may take into account the grouping properties for producing their result, e.g. aggregate removes properties that are used neither for grouping nor for aggregation.-
           # In each output set of the previous step, every instance is augmented if necessary so that it comprises the group key of its subset.
           # The output sets of the previous step are concatenated into one output set.{quote}
          If the service is unable to group by same values for any of the specified properties, …

          (Step 5 ensures that the grouping properties appear consecutively in the output set. Is this always intended?)

          Merge [PR #176|https://github.com/oasis-tcs/odata-vocabularies/pull/176].           		See discussion and proposal in [this document|https://www.oasis-open.org/apps/org/workgroup/odata/download.php/69428/ODATA-1459.docx]

          Rephrase the beginning of section 3.10 as follows (insertions are indented or italicized.)
          h2. 3.10 [Transformation groupby|#sec_Transformationgroupby]

          The {{groupby}} transformation takes one or two parameters _where the second is a list of set transformations, separated by forward slashes to express that they are consecutively applied._
          h3. 3.10.1 [Simple Grouping|#sec_SimpleGrouping]

          In its simplest form the first parameter of {{groupby}} specifies the _grouping properties_, a comma-separated list of one or more single-valued property paths that is enclosed in parentheses. A path may consist of a sequence of single-valued navigation and complex properties. The same property path SHOULD NOT appear more than once; redundant property paths MAY be considered valid, but MUST NOT alter the meaning of the request. If the property path leads to a single-valued navigation property, this means grouping by the entity-id of the related entities. Other navigation properties specified in grouping property paths are expanded by default.
          {quote}The output set is constructed in five steps:
           # For each instance in the input set, its _group key_ is constructed as follows:
           ## Include in the instance all related entities that are reached via navigation properties that occur in the grouping properties.
           ## Remove from the resulting object tree all nodes that are not traversed by any grouping property.
           # The input set is split into subsets according to the group keys. Group keys are compared as instances where instances are the same if
           ## they have the same primitive properties with the same values and
           ## they have the same complex properties whose values are the same as instances.
           # The set transformations from the second parameter are applied to each subset, resulting in a new set of potentially different structure and cardinality. If the second parameter is absent, each subset is transformed into a set consisting of a single instance without properties. -Transformations may take into account the grouping properties for producing their result, e.g. aggregate removes properties that are used neither for grouping nor for aggregation.-
           # In each output set of the previous step, every instance is augmented if necessary so that it comprises the group key of its subset.
           # The output sets of the previous step are concatenated into one output set.{quote}
          If the service is unable to group by same values for any of the specified properties, it MUST reject the request with an error response. It MUST NOT apply any implicit rules to group instances indirectly by another property related to it in some way. _(How can this happen?)_

          (Step 5 ensures that the grouping properties appear consecutively in the output set. Is this always intended?)

          Merge [PR #176|https://github.com/oasis-tcs/odata-vocabularies/pull/176].
          heiko.theissen Heiko Theissen made changes -
          Proposal See discussion and proposal in [this document|https://www.oasis-open.org/apps/org/workgroup/odata/download.php/69428/ODATA-1459.docx]

          Rephrase the beginning of section 3.10 as follows (insertions are indented or italicized.)
          h2. 3.10 [Transformation groupby|#sec_Transformationgroupby]

          The {{groupby}} transformation takes one or two parameters _where the second is a list of set transformations, separated by forward slashes to express that they are consecutively applied._
          h3. 3.10.1 [Simple Grouping|#sec_SimpleGrouping]

          In its simplest form the first parameter of {{groupby}} specifies the _grouping properties_, a comma-separated list of one or more single-valued property paths that is enclosed in parentheses. A path may consist of a sequence of single-valued navigation and complex properties. The same property path SHOULD NOT appear more than once; redundant property paths MAY be considered valid, but MUST NOT alter the meaning of the request. If the property path leads to a single-valued navigation property, this means grouping by the entity-id of the related entities. Other navigation properties specified in grouping property paths are expanded by default.
          {quote}The output set is constructed in five steps:
           # For each instance in the input set, its _group key_ is constructed as follows:
           ## Include in the instance all related entities that are reached via navigation properties that occur in the grouping properties.
           ## Remove from the resulting object tree all nodes that are not traversed by any grouping property.
           # The input set is split into subsets according to the group keys. Group keys are compared as instances where instances are the same if
           ## they have the same primitive properties with the same values and
           ## they have the same complex properties whose values are the same as instances.
           # The set transformations from the second parameter are applied to each subset, resulting in a new set of potentially different structure and cardinality. If the second parameter is absent, each subset is transformed into a set consisting of a single instance without properties. -Transformations may take into account the grouping properties for producing their result, e.g. aggregate removes properties that are used neither for grouping nor for aggregation.-
           # In each output set of the previous step, every instance is augmented if necessary so that it comprises the group key of its subset.
           # The output sets of the previous step are concatenated into one output set.{quote}
          If the service is unable to group by same values for any of the specified properties, it MUST reject the request with an error response. It MUST NOT apply any implicit rules to group instances indirectly by another property related to it in some way. _(How can this happen?)_

          (Step 5 ensures that the grouping properties appear consecutively in the output set. Is this always intended?)

          Merge [PR #176|https://github.com/oasis-tcs/odata-vocabularies/pull/176].           		See discussion and proposal in [this document|https://www.oasis-open.org/apps/org/workgroup/odata/download.php/69428/ODATA-1459.docx]

          Rephrase the beginning of section 3.10 as follows (insertions are indented or italicized.)
          h2. 3.10 [Transformation groupby|#sec_Transformationgroupby]

          The {{groupby}} transformation takes one or two parameters _where the second is a list of set transformations, separated by forward slashes to express that they are consecutively applied._
          h3. 3.10.1 [Simple Grouping|#sec_SimpleGrouping]

          In its simplest form the first parameter of {{groupby}} specifies the _grouping properties_, a comma-separated list of one or more single-valued property paths that is enclosed in parentheses. A path may consist of a sequence of single-valued navigation and complex properties. The same property path SHOULD NOT appear more than once; redundant property paths MAY be considered valid, but MUST NOT alter the meaning of the request. If the property path leads to a single-valued navigation property, this means grouping by the entity-id of the related entities. Other navigation properties specified in grouping property paths are expanded by default.
          {quote}The output set is constructed in five steps:
           # For each instance in the input set, its _group key_ is constructed as follows:
           ## Include in the instance all related entities that are reached via navigation properties that occur in the grouping properties.
           ## Remove from the resulting object tree all nodes that are not traversed by any grouping property.
           # The input set is split into subsets according to the group keys. Group keys are compared as instances where instances are the same if
           ## they have the same primitive properties with the same values and
           ## they have the same complex properties whose values are the same as instances.
           # The set transformations from the second parameter are applied to each subset, resulting in a new set of potentially different structure and cardinality. If the second parameter is absent, each subset is transformed into a set consisting of a single instance without properties. -Transformations may take into account the grouping properties for producing their result, e.g. aggregate removes properties that are used neither for grouping nor for aggregation.-
           # In each output set of the previous step, every instance is augmented if necessary so that it comprises the group key of its subset.
           # The augmented output sets of the previous step are concatenated into one output set.{quote}
          If the service is unable to group by same values for any of the specified properties, it MUST reject the request with an error response. It MUST NOT apply any implicit rules to group instances indirectly by another property related to it in some way. _(How can this happen?)_

          (Step 5 ensures that the grouping properties appear consecutively in the output set. Is this always intended?)

          Merge [PR #176|https://github.com/oasis-tcs/odata-vocabularies/pull/176].
          heiko.theissen Heiko Theissen made changes -
          Proposal See discussion and proposal in [this document|https://www.oasis-open.org/apps/org/workgroup/odata/download.php/69428/ODATA-1459.docx]

          Rephrase the beginning of section 3.10 as follows (insertions are indented or italicized.)
          h2. 3.10 [Transformation groupby|#sec_Transformationgroupby]

          The {{groupby}} transformation takes one or two parameters _where the second is a list of set transformations, separated by forward slashes to express that they are consecutively applied._
          h3. 3.10.1 [Simple Grouping|#sec_SimpleGrouping]

          In its simplest form the first parameter of {{groupby}} specifies the _grouping properties_, a comma-separated list of one or more single-valued property paths that is enclosed in parentheses. A path may consist of a sequence of single-valued navigation and complex properties. The same property path SHOULD NOT appear more than once; redundant property paths MAY be considered valid, but MUST NOT alter the meaning of the request. If the property path leads to a single-valued navigation property, this means grouping by the entity-id of the related entities. Other navigation properties specified in grouping property paths are expanded by default.
          {quote}The output set is constructed in five steps:
           # For each instance in the input set, its _group key_ is constructed as follows:
           ## Include in the instance all related entities that are reached via navigation properties that occur in the grouping properties.
           ## Remove from the resulting object tree all nodes that are not traversed by any grouping property.
           # The input set is split into subsets according to the group keys. Group keys are compared as instances where instances are the same if
           ## they have the same primitive properties with the same values and
           ## they have the same complex properties whose values are the same as instances.
           # The set transformations from the second parameter are applied to each subset, resulting in a new set of potentially different structure and cardinality. If the second parameter is absent, each subset is transformed into a set consisting of a single instance without properties. -Transformations may take into account the grouping properties for producing their result, e.g. aggregate removes properties that are used neither for grouping nor for aggregation.-
           # In each output set of the previous step, every instance is augmented if necessary so that it comprises the group key of its subset.
           # The augmented output sets of the previous step are concatenated into one output set.{quote}
          If the service is unable to group by same values for any of the specified properties, it MUST reject the request with an error response. It MUST NOT apply any implicit rules to group instances indirectly by another property related to it in some way. _(How can this happen?)_

          (Step 5 ensures that the grouping properties appear consecutively in the output set. Is this always intended?)

          Merge [PR #176|https://github.com/oasis-tcs/odata-vocabularies/pull/176].           		See discussion and proposal in [this document|https://www.oasis-open.org/apps/org/workgroup/odata/download.php/69428/ODATA-1459.docx]

          Rephrase the beginning of section 3.10 as follows (insertions are indented or italicized.)
          h2. 3.10 [Transformation groupby|#sec_Transformationgroupby]

          The {{groupby}} transformation takes one or two parameters _where the second is a list of set transformations, separated by forward slashes to express that they are consecutively applied._
          h3. 3.10.1 [Simple Grouping|#sec_SimpleGrouping]

          In its simplest form the first parameter of {{groupby}} specifies the _grouping properties_, a comma-separated list of one or more single-valued property paths that is enclosed in parentheses. A path may consist of a sequence of single-valued navigation and complex properties. The same property path SHOULD NOT appear more than once; redundant property paths MAY be considered valid, but MUST NOT alter the meaning of the request. If the property path leads to a single-valued navigation property, this means grouping by the entity-id of the related entities. Other navigation properties specified in grouping property paths are expanded by default.
          {quote}The output set is constructed in five steps:
           # For each instance in the input set, its _group key_ is constructed as follows:
           ## Include in the instance all related entities that are reached via navigation properties that occur in the grouping properties.
           ## Remove from the resulting object tree all nodes that are not traversed by any grouping property.
           # The input set is split into subsets according to the group keys. Group keys are compared as instances where instances are the same if
           ## they have the same primitive properties with the same values and
           ## they have the same complex structural or navigation properties whose values are the same as instances.
           # The set transformations from the second parameter are applied to each subset, resulting in a new set of potentially different structure and cardinality. If the second parameter is absent, each subset is transformed into a set consisting of a single instance without properties. -Transformations may take into account the grouping properties for producing their result, e.g. aggregate removes properties that are used neither for grouping nor for aggregation.-
           # In each output set of the previous step, every instance is augmented if necessary so that it comprises the group key of its subset.
           # The augmented output sets of the previous step are concatenated into one output set.{quote}
          If the service is unable to group by same values for any of the specified properties, it MUST reject the request with an error response. It MUST NOT apply any implicit rules to group instances indirectly by another property related to it in some way. _(How can this happen?)_

          (Step 5 ensures that the grouping properties appear consecutively in the output set. Is this always intended?)

          Merge [PR #176|https://github.com/oasis-tcs/odata-vocabularies/pull/176].
          heiko.theissen Heiko Theissen made changes -
          Proposal See discussion and proposal in [this document|https://www.oasis-open.org/apps/org/workgroup/odata/download.php/69428/ODATA-1459.docx]

          Rephrase the beginning of section 3.10 as follows (insertions are indented or italicized.)
          h2. 3.10 [Transformation groupby|#sec_Transformationgroupby]

          The {{groupby}} transformation takes one or two parameters _where the second is a list of set transformations, separated by forward slashes to express that they are consecutively applied._
          h3. 3.10.1 [Simple Grouping|#sec_SimpleGrouping]

          In its simplest form the first parameter of {{groupby}} specifies the _grouping properties_, a comma-separated list of one or more single-valued property paths that is enclosed in parentheses. A path may consist of a sequence of single-valued navigation and complex properties. The same property path SHOULD NOT appear more than once; redundant property paths MAY be considered valid, but MUST NOT alter the meaning of the request. If the property path leads to a single-valued navigation property, this means grouping by the entity-id of the related entities. Other navigation properties specified in grouping property paths are expanded by default.
          {quote}The output set is constructed in five steps:
           # For each instance in the input set, its _group key_ is constructed as follows:
           ## Include in the instance all related entities that are reached via navigation properties that occur in the grouping properties.
           ## Remove from the resulting object tree all nodes that are not traversed by any grouping property.
           # The input set is split into subsets according to the group keys. Group keys are compared as instances where instances are the same if
           ## they have the same primitive properties with the same values and
           ## they have the same complex structural or navigation properties whose values are the same as instances.
           # The set transformations from the second parameter are applied to each subset, resulting in a new set of potentially different structure and cardinality. If the second parameter is absent, each subset is transformed into a set consisting of a single instance without properties. -Transformations may take into account the grouping properties for producing their result, e.g. aggregate removes properties that are used neither for grouping nor for aggregation.-
           # In each output set of the previous step, every instance is augmented if necessary so that it comprises the group key of its subset.
           # The augmented output sets of the previous step are concatenated into one output set.{quote}
          If the service is unable to group by same values for any of the specified properties, it MUST reject the request with an error response. It MUST NOT apply any implicit rules to group instances indirectly by another property related to it in some way. _(How can this happen?)_

          (Step 5 ensures that the grouping properties appear consecutively in the output set. Is this always intended?)

          Merge [PR #176|https://github.com/oasis-tcs/odata-vocabularies/pull/176].           		See discussion and proposal in [this document|https://www.oasis-open.org/apps/org/workgroup/odata/download.php/69428/ODATA-1459.docx]

          Rephrase the beginning of section 3.10 as follows (insertions are indented or italicized.)
          h2. 3.10 [Transformation groupby|#sec_Transformationgroupby]

          The {{groupby}} transformation takes one or two parameters _where the second is a list of set transformations, separated by forward slashes to express that they are consecutively applied._
          h3. 3.10.1 [Simple Grouping|#sec_SimpleGrouping]

          In its simplest form the first parameter of {{groupby}} specifies the _grouping properties_, a comma-separated list of one or more single-valued property paths that is enclosed in parentheses. A path may consist of a sequence of single-valued navigation and complex properties. The same property path SHOULD NOT appear more than once; redundant property paths MAY be considered valid, but MUST NOT alter the meaning of the request. If the property path leads to a single-valued navigation property, this means grouping by the entity-id of the related entities. Other navigation properties specified in grouping property paths are expanded by default.
          {quote}The output set is constructed in five steps:
           # For each instance in the input set, its _group key_ is constructed as follows:
           ## Include in the instance all related entities that are reached via navigation properties that occur in the grouping properties.
           ## Remove from the resulting object tree all  structural and navigation properties that are not traversed by any grouping property.
           # The input set is split into subsets according to the group keys. Group keys are compared as instances where instances are the same if
           ## they have the same primitive properties with the same values and
           ## they have the same complex structural or navigation properties whose values are the same as instances.
           # The set transformations from the second parameter are applied to each subset, resulting in a new set of potentially different structure and cardinality. If the second parameter is absent, each subset is transformed into a set consisting of a single instance without properties. -Transformations may take into account the grouping properties for producing their result, e.g. aggregate removes properties that are used neither for grouping nor for aggregation.-
           # In each set resulting from the previous step, every instance is augmented if necessary so that it comprises the corresponding group key.
           # The augmented sets of the previous step are concatenated into one output set.{quote}
          If the service is unable to group by same values for any of the specified properties, it MUST reject the request with an error response. It MUST NOT apply any implicit rules to group instances indirectly by another property related to it in some way. _(How can this happen?)_

          (Step 5 ensures that the grouping properties appear consecutively in the output set. Is this always intended?)

          Merge [PR #176|https://github.com/oasis-tcs/odata-vocabularies/pull/176].
          heiko.theissen Heiko Theissen made changes -
          Proposal See discussion and proposal in [this document|https://www.oasis-open.org/apps/org/workgroup/odata/download.php/69428/ODATA-1459.docx]

          Rephrase the beginning of section 3.10 as follows (insertions are indented or italicized.)
          h2. 3.10 [Transformation groupby|#sec_Transformationgroupby]

          The {{groupby}} transformation takes one or two parameters _where the second is a list of set transformations, separated by forward slashes to express that they are consecutively applied._
          h3. 3.10.1 [Simple Grouping|#sec_SimpleGrouping]

          In its simplest form the first parameter of {{groupby}} specifies the _grouping properties_, a comma-separated list of one or more single-valued property paths that is enclosed in parentheses. A path may consist of a sequence of single-valued navigation and complex properties. The same property path SHOULD NOT appear more than once; redundant property paths MAY be considered valid, but MUST NOT alter the meaning of the request. If the property path leads to a single-valued navigation property, this means grouping by the entity-id of the related entities. Other navigation properties specified in grouping property paths are expanded by default.
          {quote}The output set is constructed in five steps:
           # For each instance in the input set, its _group key_ is constructed as follows:
           ## Include in the instance all related entities that are reached via navigation properties that occur in the grouping properties.
           ## Remove from the resulting object tree all  structural and navigation properties that are not traversed by any grouping property.
           # The input set is split into subsets according to the group keys. Group keys are compared as instances where instances are the same if
           ## they have the same primitive properties with the same values and
           ## they have the same complex structural or navigation properties whose values are the same as instances.
           # The set transformations from the second parameter are applied to each subset, resulting in a new set of potentially different structure and cardinality. If the second parameter is absent, each subset is transformed into a set consisting of a single instance without properties. -Transformations may take into account the grouping properties for producing their result, e.g. aggregate removes properties that are used neither for grouping nor for aggregation.-
           # In each set resulting from the previous step, every instance is augmented if necessary so that it comprises the corresponding group key.
           # The augmented sets of the previous step are concatenated into one output set.{quote}
          If the service is unable to group by same values for any of the specified properties, it MUST reject the request with an error response. It MUST NOT apply any implicit rules to group instances indirectly by another property related to it in some way. _(How can this happen?)_

          (Step 5 ensures that the grouping properties appear consecutively in the output set. Is this always intended?)

          Merge [PR #176|https://github.com/oasis-tcs/odata-vocabularies/pull/176].           		See discussion and proposal in [this document|https://www.oasis-open.org/apps/org/workgroup/odata/download.php/69428/ODATA-1459.docx]

          Rephrase the beginning of sections 3.10 and 4 as follows (insertions are indented or italicized.) Merge [PR #176|https://github.com/oasis-tcs/odata-vocabularies/pull/176].
          h2. 3.10 [Transformation groupby|#sec_Transformationgroupby]

          The {{groupby}} transformation takes one or two parameters _where the second is a list of set transformations, separated by forward slashes to express that they are consecutively applied._
          h3. 3.10.1 [Simple Grouping|#sec_SimpleGrouping]

          In its simplest form the first parameter of {{groupby}} specifies the _grouping properties_, a comma-separated list of one or more single-valued property paths that is enclosed in parentheses. A path may consist of a sequence of single-valued navigation and complex properties. The same property path SHOULD NOT appear more than once; redundant property paths MAY be considered valid, but MUST NOT alter the meaning of the request. If the property path leads to a single-valued navigation property, this means grouping by the entity-id of the related entities. Other navigation properties specified in grouping property paths are expanded by default.
          {quote}The output set is constructed in five steps:
           # For each instance in the input set, its _group key_ is constructed as follows:
           ## Include in the instance all related entities that are reached via navigation properties that occur in the grouping properties.
           ## Remove from the resulting object tree all  structural and navigation properties that are not traversed by any grouping property.
           # The input set is split into subsets according to the group keys. Group keys are compared as instances where instances are the same if
           ## they have the same primitive properties with the same values and
           ## they have the same complex structural or navigation properties whose values are the same as instances.
           # The set transformations from the second parameter are applied to each subset, resulting in a new set of potentially different structure and cardinality. If the second parameter is absent, each subset is transformed into a set consisting of a single instance without properties. -Transformations may take into account the grouping properties for producing their result, e.g. aggregate removes properties that are used neither for grouping nor for aggregation.-
           # In each set resulting from the previous step, every instance is augmented if necessary so that it comprises the corresponding group key.
           # The augmented sets of the previous step are concatenated into one output set.{quote}
          If the service is unable to group by same values for any of the specified properties, it MUST reject the request with an error response. It MUST NOT apply any implicit rules to group instances indirectly by another property related to it in some way. _(How can this happen?)_

          (Step 5 ensures that the grouping properties appear consecutively in the output set. Is this always intended?)
          h1. 4. Representation of aggregated instances

          ...
           Properties that have been aggregated away are -not- represented -at all- in the aggregated instances _by an {{Aggregation.rolledup}} instance annotation_.
          heiko.theissen Heiko Theissen made changes -
          Proposal See discussion and proposal in [this document|https://www.oasis-open.org/apps/org/workgroup/odata/download.php/69428/ODATA-1459.docx]

          Rephrase the beginning of sections 3.10 and 4 as follows (insertions are indented or italicized.) Merge [PR #176|https://github.com/oasis-tcs/odata-vocabularies/pull/176].
          h2. 3.10 [Transformation groupby|#sec_Transformationgroupby]

          The {{groupby}} transformation takes one or two parameters _where the second is a list of set transformations, separated by forward slashes to express that they are consecutively applied._
          h3. 3.10.1 [Simple Grouping|#sec_SimpleGrouping]

          In its simplest form the first parameter of {{groupby}} specifies the _grouping properties_, a comma-separated list of one or more single-valued property paths that is enclosed in parentheses. A path may consist of a sequence of single-valued navigation and complex properties. The same property path SHOULD NOT appear more than once; redundant property paths MAY be considered valid, but MUST NOT alter the meaning of the request. If the property path leads to a single-valued navigation property, this means grouping by the entity-id of the related entities. Other navigation properties specified in grouping property paths are expanded by default.
          {quote}The output set is constructed in five steps:
           # For each instance in the input set, its _group key_ is constructed as follows:
           ## Include in the instance all related entities that are reached via navigation properties that occur in the grouping properties.
           ## Remove from the resulting object tree all  structural and navigation properties that are not traversed by any grouping property.
           # The input set is split into subsets according to the group keys. Group keys are compared as instances where instances are the same if
           ## they have the same primitive properties with the same values and
           ## they have the same complex structural or navigation properties whose values are the same as instances.
           # The set transformations from the second parameter are applied to each subset, resulting in a new set of potentially different structure and cardinality. If the second parameter is absent, each subset is transformed into a set consisting of a single instance without properties. -Transformations may take into account the grouping properties for producing their result, e.g. aggregate removes properties that are used neither for grouping nor for aggregation.-
           # In each set resulting from the previous step, every instance is augmented if necessary so that it comprises the corresponding group key.
           # The augmented sets of the previous step are concatenated into one output set.{quote}
          If the service is unable to group by same values for any of the specified properties, it MUST reject the request with an error response. It MUST NOT apply any implicit rules to group instances indirectly by another property related to it in some way. _(How can this happen?)_

          (Step 5 ensures that the grouping properties appear consecutively in the output set. Is this always intended?)
          h1. 4. Representation of aggregated instances

          ...
           Properties that have been aggregated away are -not- represented -at all- in the aggregated instances _by an {{Aggregation.rolledup}} instance annotation_.           		See discussion and proposal in [this document|https://www.oasis-open.org/apps/org/workgroup/odata/download.php/69428/ODATA-1459.docx]

          Rephrase the beginning of sections 3.10 and 4 as follows (insertions are indented or italicized.) Merge [PR #176|https://github.com/oasis-tcs/odata-vocabularies/pull/176].
          h2. 3.10 [Transformation groupby|#sec_Transformationgroupby]

          The {{groupby}} transformation takes one or two parameters _where the second is a list of set transformations, separated by forward slashes to express that they are consecutively applied._
          h3. 3.10.1 [Simple Grouping|#sec_SimpleGrouping]

          In its simplest form the first parameter of {{groupby}} specifies the _grouping properties_, a comma-separated list of one or more single-valued property paths that is enclosed in parentheses. A path may consist of a sequence of single-valued navigation and complex properties. The same property path SHOULD NOT appear more than once; redundant property paths MAY be considered valid, but MUST NOT alter the meaning of the request. If the property path leads to a single-valued navigation property, this means grouping by the entity-id of the related entities. Other navigation properties specified in grouping property paths are expanded by default.
          {quote}The output set is constructed in five steps:
           # For each instance in the input set, its _group identifier_ is constructed as follows:
           ## Create a tuple key copy of the instance with all related entities included that are reached via navigation properties that occur in the grouping properties.
           ## Remove from the resulting object tree all  structural and navigation properties that are not traversed by any grouping property.
           # The input set is split into subsets according to the group keys. Group keys are compared as instances where instances are the same if
           ## they have the same primitive properties with the same values and
           ## they have the same complex structural or navigation properties whose values are the same as instances.
           # The set transformations from the second parameter are applied to each subset, resulting in a new set of potentially different structure and cardinality. If the second parameter is absent, each subset is transformed into a set consisting of a single instance without properties. -Transformations may take into account the grouping properties for producing their result, e.g. aggregate removes properties that are used neither for grouping nor for aggregation.-
           # In each set resulting from the previous step, every instance is augmented if necessary so that it comprises the corresponding group key.
           # The augmented sets of the previous step are concatenated into one output set.{quote}
          If the service is unable to group by same values for any of the specified properties, it MUST reject the request with an error response. It MUST NOT apply any implicit rules to group instances indirectly by another property related to it in some way. _(How can this happen?)_

          (Step 5 ensures that the grouping properties appear consecutively in the output set. Is this always intended?)
          h1. 4. Representation of aggregated instances

          ...
           Properties that have been aggregated away are -not- represented -at all- in the aggregated instances _by an {{Aggregation.rolledup}} instance annotation_.
          heiko.theissen Heiko Theissen made changes -
          Proposal See discussion and proposal in [this document|https://www.oasis-open.org/apps/org/workgroup/odata/download.php/69428/ODATA-1459.docx]

          Rephrase the beginning of sections 3.10 and 4 as follows (insertions are indented or italicized.) Merge [PR #176|https://github.com/oasis-tcs/odata-vocabularies/pull/176].
          h2. 3.10 [Transformation groupby|#sec_Transformationgroupby]

          The {{groupby}} transformation takes one or two parameters _where the second is a list of set transformations, separated by forward slashes to express that they are consecutively applied._
          h3. 3.10.1 [Simple Grouping|#sec_SimpleGrouping]

          In its simplest form the first parameter of {{groupby}} specifies the _grouping properties_, a comma-separated list of one or more single-valued property paths that is enclosed in parentheses. A path may consist of a sequence of single-valued navigation and complex properties. The same property path SHOULD NOT appear more than once; redundant property paths MAY be considered valid, but MUST NOT alter the meaning of the request. If the property path leads to a single-valued navigation property, this means grouping by the entity-id of the related entities. Other navigation properties specified in grouping property paths are expanded by default.
          {quote}The output set is constructed in five steps:
           # For each instance in the input set, its _group identifier_ is constructed as follows:
           ## Create a tuple key copy of the instance with all related entities included that are reached via navigation properties that occur in the grouping properties.
           ## Remove from the resulting object tree all  structural and navigation properties that are not traversed by any grouping property.
           # The input set is split into subsets according to the group keys. Group keys are compared as instances where instances are the same if
           ## they have the same primitive properties with the same values and
           ## they have the same complex structural or navigation properties whose values are the same as instances.
           # The set transformations from the second parameter are applied to each subset, resulting in a new set of potentially different structure and cardinality. If the second parameter is absent, each subset is transformed into a set consisting of a single instance without properties. -Transformations may take into account the grouping properties for producing their result, e.g. aggregate removes properties that are used neither for grouping nor for aggregation.-
           # In each set resulting from the previous step, every instance is augmented if necessary so that it comprises the corresponding group key.
           # The augmented sets of the previous step are concatenated into one output set.{quote}
          If the service is unable to group by same values for any of the specified properties, it MUST reject the request with an error response. It MUST NOT apply any implicit rules to group instances indirectly by another property related to it in some way. _(How can this happen?)_

          (Step 5 ensures that the grouping properties appear consecutively in the output set. Is this always intended?)
          h1. 4. Representation of aggregated instances

          ...
           Properties that have been aggregated away are -not- represented -at all- in the aggregated instances _by an {{Aggregation.rolledup}} instance annotation_.           		See discussion and proposal in [this document|https://www.oasis-open.org/apps/org/workgroup/odata/download.php/69428/ODATA-1459.docx]

          Rephrase the beginning of sections 3.10 and 4 as follows (insertions are indented or italicized.) Merge [PR #176|https://github.com/oasis-tcs/odata-vocabularies/pull/176].
          h2. 3.10 [Transformation groupby|#sec_Transformationgroupby]

          The {{groupby}} transformation takes one or two parameters _where the second is a list of set transformations, separated by forward slashes to express that they are consecutively applied._
          h3. 3.10.1 [Simple Grouping|#sec_SimpleGrouping]

          In its simplest form the first parameter of {{groupby}} specifies the _grouping properties_, a comma-separated list of one or more single-valued property paths that is enclosed in parentheses. A path may consist of a sequence of single-valued navigation and complex properties. The same property path SHOULD NOT appear more than once; redundant property paths MAY be considered valid, but MUST NOT alter the meaning of the request. If the property path leads to a single-valued navigation property, this means grouping by the entity-id of the related entities. Other navigation properties specified in grouping property paths are expanded by default.
          {quote}The output set is constructed in five steps:
           # For each instance in the input set, its _group identifier_ is constructed as follows:
           ## Create a projection of the instance with all related entities included that are reached via navigation properties that occur in the grouping properties.
           ## Remove from the projection all structural and navigation properties that are not traversed by any grouping property.
           # The input set is split into subsets according to the group keys. Group keys are compared as instances where instances are the same if
           ## they have the same primitive properties with the same values and
           ## they have the same complex structural or navigation properties whose values are the same as instances.
           # The set transformations from the second parameter are applied to each subset, resulting in a new set of potentially different structure and cardinality. If the second parameter is absent, each subset is transformed into a set consisting of a single instance without properties. -Transformations may take into account the grouping properties for producing their result, e.g. aggregate removes properties that are used neither for grouping nor for aggregation.-
           # In each set resulting from the previous step, every instance is augmented if necessary so that it comprises the corresponding group key.
           # The augmented sets of the previous step are concatenated into one output set.{quote}
          If the service is unable to group by same values for any of the specified properties, it MUST reject the request with an error response. It MUST NOT apply any implicit rules to group instances indirectly by another property related to it in some way. _(How can this happen?)_

          (Step 5 ensures that the grouping properties appear consecutively in the output set. Is this always intended?)
          h1. 4. Representation of aggregated instances

          ...
           Properties that have been aggregated away are -not- represented -at all- in the aggregated instances _by an {{Aggregation.rolledup}} instance annotation_.
          heiko.theissen Heiko Theissen made changes -
          Proposal See discussion and proposal in [this document|https://www.oasis-open.org/apps/org/workgroup/odata/download.php/69428/ODATA-1459.docx]

          Rephrase the beginning of sections 3.10 and 4 as follows (insertions are indented or italicized.) Merge [PR #176|https://github.com/oasis-tcs/odata-vocabularies/pull/176].
          h2. 3.10 [Transformation groupby|#sec_Transformationgroupby]

          The {{groupby}} transformation takes one or two parameters _where the second is a list of set transformations, separated by forward slashes to express that they are consecutively applied._
          h3. 3.10.1 [Simple Grouping|#sec_SimpleGrouping]

          In its simplest form the first parameter of {{groupby}} specifies the _grouping properties_, a comma-separated list of one or more single-valued property paths that is enclosed in parentheses. A path may consist of a sequence of single-valued navigation and complex properties. The same property path SHOULD NOT appear more than once; redundant property paths MAY be considered valid, but MUST NOT alter the meaning of the request. If the property path leads to a single-valued navigation property, this means grouping by the entity-id of the related entities. Other navigation properties specified in grouping property paths are expanded by default.
          {quote}The output set is constructed in five steps:
           # For each instance in the input set, its _group identifier_ is constructed as follows:
           ## Create a projection of the instance with all related entities included that are reached via navigation properties that occur in the grouping properties.
           ## Remove from the projection all structural and navigation properties that are not traversed by any grouping property.
           # The input set is split into subsets according to the group keys. Group keys are compared as instances where instances are the same if
           ## they have the same primitive properties with the same values and
           ## they have the same complex structural or navigation properties whose values are the same as instances.
           # The set transformations from the second parameter are applied to each subset, resulting in a new set of potentially different structure and cardinality. If the second parameter is absent, each subset is transformed into a set consisting of a single instance without properties. -Transformations may take into account the grouping properties for producing their result, e.g. aggregate removes properties that are used neither for grouping nor for aggregation.-
           # In each set resulting from the previous step, every instance is augmented if necessary so that it comprises the corresponding group key.
           # The augmented sets of the previous step are concatenated into one output set.{quote}
          If the service is unable to group by same values for any of the specified properties, it MUST reject the request with an error response. It MUST NOT apply any implicit rules to group instances indirectly by another property related to it in some way. _(How can this happen?)_

          (Step 5 ensures that the grouping properties appear consecutively in the output set. Is this always intended?)
          h1. 4. Representation of aggregated instances

          ...
           Properties that have been aggregated away are -not- represented -at all- in the aggregated instances _by an {{Aggregation.rolledup}} instance annotation_.           		See discussion and proposal in [this document|https://www.oasis-open.org/apps/org/workgroup/odata/download.php/69428/ODATA-1459.docx]

          Rephrase the beginning of sections 3.10 and 4 as follows (insertions are indented or italicized.) Merge [PR #176|https://github.com/oasis-tcs/odata-vocabularies/pull/176].
          h2. 3.10 [Transformation groupby|#sec_Transformationgroupby]

          The {{groupby}} transformation takes one or two parameters _where the second is a list of set transformations, separated by forward slashes to express that they are consecutively applied._
          h3. 3.10.1 [Simple Grouping|#sec_SimpleGrouping]

          In its simplest form the first parameter of {{groupby}} specifies the _grouping properties_, a comma-separated list of one or more single-valued property paths that is enclosed in parentheses. A path may consist of a sequence of single-valued navigation and complex properties. The same property path SHOULD NOT appear more than once; redundant property paths MAY be considered valid, but MUST NOT alter the meaning of the request. If the property path leads to a single-valued navigation property, this means grouping by the entity-id of the related entities. Other navigation properties specified in grouping property paths are expanded by default.
          {quote}The output set is constructed in five steps:
           # For each instance in the input set:
           ## Create a projection of the instance with all related entities included that are reached via navigation properties that occur in the grouping properties.
           ## Remove from the projection all structural and navigation properties that are not traversed by any grouping property.
           # The input set is split into subsets where two instances are in the same subset if their projections are the same.
           # The set transformations from the second parameter are applied to each subset, resulting in a new set of potentially different structure and cardinality. If the second parameter is absent, each subset is transformed into a set consisting of a single instance without properties. -Transformations may take into account the grouping properties for producing their result, e.g. aggregate removes properties that are used neither for grouping nor for aggregation.-
           # In each set resulting from the previous step, every instance is augmented if necessary to include all properties of the corresponding projection.
           # The augmented sets of the previous step are added to the output set.{quote}
          -If the service is unable to group by same values for any of the specified properties, it MUST reject the request with an error response. It MUST NOT apply any implicit rules to group instances indirectly by another property related to it in some way.-
          h1. 4. Representation of aggregated instances

          ...
           Properties that have been aggregated away are -not- represented -at all- in the aggregated instances _by an {{Aggregation.rolledup}} instance annotation_.
          heiko.theissen Heiko Theissen made changes -
          Proposal See discussion and proposal in [this document|https://www.oasis-open.org/apps/org/workgroup/odata/download.php/69428/ODATA-1459.docx]

          Rephrase the beginning of sections 3.10 and 4 as follows (insertions are indented or italicized.) Merge [PR #176|https://github.com/oasis-tcs/odata-vocabularies/pull/176].
          h2. 3.10 [Transformation groupby|#sec_Transformationgroupby]

          The {{groupby}} transformation takes one or two parameters _where the second is a list of set transformations, separated by forward slashes to express that they are consecutively applied._
          h3. 3.10.1 [Simple Grouping|#sec_SimpleGrouping]

          In its simplest form the first parameter of {{groupby}} specifies the _grouping properties_, a comma-separated list of one or more single-valued property paths that is enclosed in parentheses. A path may consist of a sequence of single-valued navigation and complex properties. The same property path SHOULD NOT appear more than once; redundant property paths MAY be considered valid, but MUST NOT alter the meaning of the request. If the property path leads to a single-valued navigation property, this means grouping by the entity-id of the related entities. Other navigation properties specified in grouping property paths are expanded by default.
          {quote}The output set is constructed in five steps:
           # For each instance in the input set:
           ## Create a projection of the instance with all related entities included that are reached via navigation properties that occur in the grouping properties.
           ## Remove from the projection all structural and navigation properties that are not traversed by any grouping property.
           # The input set is split into subsets where two instances are in the same subset if their projections are the same.
           # The set transformations from the second parameter are applied to each subset, resulting in a new set of potentially different structure and cardinality. If the second parameter is absent, each subset is transformed into a set consisting of a single instance without properties. -Transformations may take into account the grouping properties for producing their result, e.g. aggregate removes properties that are used neither for grouping nor for aggregation.-
           # In each set resulting from the previous step, every instance is augmented if necessary to include all properties of the corresponding projection.
           # The augmented sets of the previous step are added to the output set.{quote}
          -If the service is unable to group by same values for any of the specified properties, it MUST reject the request with an error response. It MUST NOT apply any implicit rules to group instances indirectly by another property related to it in some way.-
          h1. 4. Representation of aggregated instances

          ...
           Properties that have been aggregated away are -not- represented -at all- in the aggregated instances _by an {{Aggregation.rolledup}} instance annotation_.           		See discussion and proposal in [this document|https://www.oasis-open.org/apps/org/workgroup/odata/download.php/69428/ODATA-1459.docx]

          Rephrase the beginning of sections 3.10 and 4 as follows (insertions are indented or italicized.) Merge [PR #176|https://github.com/oasis-tcs/odata-vocabularies/pull/176].
          h2. 3.10 [Transformation groupby|#sec_Transformationgroupby]

          The {{groupby}} transformation takes one or two parameters _where the second is a list of set transformations, separated by forward slashes to express that they are consecutively applied._
          h3. 3.10.1 [Simple Grouping|#sec_SimpleGrouping]

          In its simplest form the first parameter of {{groupby}} specifies the _grouping properties_, a comma-separated list of one or more single-valued property paths that is enclosed in parentheses. A path may consist of a sequence of single-valued navigation and complex properties. The same property path SHOULD NOT appear more than once; redundant property paths MAY be considered valid, but MUST NOT alter the meaning of the request. If the property path leads to a single-valued navigation property, this means grouping by the entity-id of the related entities. Other navigation properties specified in grouping property paths are expanded by default.
          {quote}The output set is constructed in five steps:
           # For each instance in the input set:
           ## Create a projection of the instance with all related entities included that are reached via navigation properties that occur in the grouping properties.
           ## Remove from the projection all structural and navigation properties that are not traversed by any grouping property.
           # The input set is split into subsets where two instances are in the same subset if their projections are the same _(with null considered different from undefined)_.
           # The set transformations from the second parameter are applied to each subset, resulting in a new set of potentially different structure and cardinality. If the second parameter is absent, each subset is transformed into a set consisting of a single instance without properties. -Transformations may take into account the grouping properties for producing their result, e.g. aggregate removes properties that are used neither for grouping nor for aggregation.-
           # In each set resulting from the previous step, every instance is augmented if necessary to include all properties of the corresponding projection.
           # The augmented sets of the previous step are added to the output set.{quote}
          -If the service is unable to group by same values for any of the specified properties, it MUST reject the request with an error response. It MUST NOT apply any implicit rules to group instances indirectly by another property related to it in some way.-
          h1. 4. Representation of aggregated instances

          ...
           Properties that have been aggregated away are -not- represented -at all- in the aggregated instances _by an {{Aggregation.rolledup}} instance annotation_.
          heiko.theissen Heiko Theissen made changes -
          Proposal See discussion and proposal in [this document|https://www.oasis-open.org/apps/org/workgroup/odata/download.php/69428/ODATA-1459.docx]

          Rephrase the beginning of sections 3.10 and 4 as follows (insertions are indented or italicized.) Merge [PR #176|https://github.com/oasis-tcs/odata-vocabularies/pull/176].
          h2. 3.10 [Transformation groupby|#sec_Transformationgroupby]

          The {{groupby}} transformation takes one or two parameters _where the second is a list of set transformations, separated by forward slashes to express that they are consecutively applied._
          h3. 3.10.1 [Simple Grouping|#sec_SimpleGrouping]

          In its simplest form the first parameter of {{groupby}} specifies the _grouping properties_, a comma-separated list of one or more single-valued property paths that is enclosed in parentheses. A path may consist of a sequence of single-valued navigation and complex properties. The same property path SHOULD NOT appear more than once; redundant property paths MAY be considered valid, but MUST NOT alter the meaning of the request. If the property path leads to a single-valued navigation property, this means grouping by the entity-id of the related entities. Other navigation properties specified in grouping property paths are expanded by default.
          {quote}The output set is constructed in five steps:
           # For each instance in the input set:
           ## Create a projection of the instance with all related entities included that are reached via navigation properties that occur in the grouping properties.
           ## Remove from the projection all structural and navigation properties that are not traversed by any grouping property.
           # The input set is split into subsets where two instances are in the same subset if their projections are the same _(with null considered different from undefined)_.
           # The set transformations from the second parameter are applied to each subset, resulting in a new set of potentially different structure and cardinality. If the second parameter is absent, each subset is transformed into a set consisting of a single instance without properties. -Transformations may take into account the grouping properties for producing their result, e.g. aggregate removes properties that are used neither for grouping nor for aggregation.-
           # In each set resulting from the previous step, every instance is augmented if necessary to include all properties of the corresponding projection.
           # The augmented sets of the previous step are added to the output set.{quote}
          -If the service is unable to group by same values for any of the specified properties, it MUST reject the request with an error response. It MUST NOT apply any implicit rules to group instances indirectly by another property related to it in some way.-
          h1. 4. Representation of aggregated instances

          ...
           Properties that have been aggregated away are -not- represented -at all- in the aggregated instances _by an {{Aggregation.rolledup}} instance annotation_.           		See discussion and proposal in [this document|https://www.oasis-open.org/apps/org/workgroup/odata/download.php/69428/ODATA-1459.docx]

          Rephrase the beginning of sections 3.10 and 4 as follows (insertions are indented or italicized.) Merge [PR #176|https://github.com/oasis-tcs/odata-vocabularies/pull/176].
          h2. 3.10 [Transformation groupby|#sec_Transformationgroupby]

          The {{groupby}} transformation takes one or two parameters _where the second is a list of set transformations, separated by forward slashes to express that they are consecutively applied._
          h3. 3.10.1 [Simple Grouping|#sec_SimpleGrouping]

          In its simplest form the first parameter of {{groupby}} specifies the _grouping properties_, a comma-separated list of one or more single-valued property paths that is enclosed in parentheses. A path may consist of a sequence of single-valued navigation and complex properties. The same property path SHOULD NOT appear more than once; redundant property paths MAY be considered valid, but MUST NOT alter the meaning of the request. If the property path leads to a single-valued navigation property, this means grouping by the entity-id of the related entities. Other navigation properties specified in grouping property paths are expanded by default.
          {quote}The output set is constructed in five steps:
           # For each instance in the input set:
           ## Create a projection of the instance with all related entities included that are reached via navigation properties that occur in the grouping properties.
           ## Remove from the projection all structural and navigation properties that are not traversed by any grouping property.
           # The input set is split into subsets where two instances are in the same subset if their projections are the same _(with null considered different from absent)_.
           # The set transformations from the second parameter are applied to each subset, resulting in a new set of potentially different structure and cardinality. If the second parameter is absent, each subset is transformed into a set consisting of a single instance without properties. -Transformations may take into account the grouping properties for producing their result, e.g. aggregate removes properties that are used neither for grouping nor for aggregation.-
           # In each set resulting from the previous step, every instance is augmented if necessary to include all _primitive property values_ of the corresponding projection _and its nested complex properties_. {color:#de350b}(In other words: Primitive values are overwritten from the projection, complex values are merged.){color}
           # The augmented sets of the previous step are added to the output set.{quote}
          -If the service is unable to group by same values for any of the specified properties, it MUST reject the request with an error response. It MUST NOT apply any implicit rules to group instances indirectly by another property related to it in some way.-
          h1. 4. Representation of aggregated instances

          ...
           Properties that have been aggregated away are -not- represented -at all- in the aggregated instances _by an {{Aggregation.rolledup}} instance annotation_.
          heiko.theissen Heiko Theissen made changes -
          Proposal See discussion and proposal in [this document|https://www.oasis-open.org/apps/org/workgroup/odata/download.php/69428/ODATA-1459.docx]

          Rephrase the beginning of sections 3.10 and 4 as follows (insertions are indented or italicized.) Merge [PR #176|https://github.com/oasis-tcs/odata-vocabularies/pull/176].
          h2. 3.10 [Transformation groupby|#sec_Transformationgroupby]

          The {{groupby}} transformation takes one or two parameters _where the second is a list of set transformations, separated by forward slashes to express that they are consecutively applied._
          h3. 3.10.1 [Simple Grouping|#sec_SimpleGrouping]

          In its simplest form the first parameter of {{groupby}} specifies the _grouping properties_, a comma-separated list of one or more single-valued property paths that is enclosed in parentheses. A path may consist of a sequence of single-valued navigation and complex properties. The same property path SHOULD NOT appear more than once; redundant property paths MAY be considered valid, but MUST NOT alter the meaning of the request. If the property path leads to a single-valued navigation property, this means grouping by the entity-id of the related entities. Other navigation properties specified in grouping property paths are expanded by default.
          {quote}The output set is constructed in five steps:
           # For each instance in the input set:
           ## Create a projection of the instance with all related entities included that are reached via navigation properties that occur in the grouping properties.
           ## Remove from the projection all structural and navigation properties that are not traversed by any grouping property.
           # The input set is split into subsets where two instances are in the same subset if their projections are the same _(with null considered different from absent)_.
           # The set transformations from the second parameter are applied to each subset, resulting in a new set of potentially different structure and cardinality. If the second parameter is absent, each subset is transformed into a set consisting of a single instance without properties. -Transformations may take into account the grouping properties for producing their result, e.g. aggregate removes properties that are used neither for grouping nor for aggregation.-
           # In each set resulting from the previous step, every instance is augmented if necessary to include all _primitive property values_ of the corresponding projection _and its nested complex properties_. {color:#de350b}(In other words: Primitive values are overwritten from the projection, complex values are merged.){color}
           # The augmented sets of the previous step are added to the output set.{quote}
          -If the service is unable to group by same values for any of the specified properties, it MUST reject the request with an error response. It MUST NOT apply any implicit rules to group instances indirectly by another property related to it in some way.-
          h1. 4. Representation of aggregated instances

          ...
           Properties that have been aggregated away are -not- represented -at all- in the aggregated instances _by an {{Aggregation.rolledup}} instance annotation_.           		See discussion and proposal in [this document|https://www.oasis-open.org/apps/org/workgroup/odata/download.php/69428/ODATA-1459.docx]

          Rephrase the beginning of section 3.10 as follows (insertions are indented or italicized.) Merge [PR #176|https://github.com/oasis-tcs/odata-vocabularies/pull/176].
          h2. 3.10 [Transformation groupby|#sec_Transformationgroupby]

          The {{groupby}} transformation takes one or two parameters _where the second is a list of set transformations, separated by forward slashes to express that they are consecutively applied._
          h3. 3.10.1 [Simple Grouping|#sec_SimpleGrouping]

          In its simplest form the first parameter of {{groupby}} specifies the _grouping properties_, a comma-separated list of one or more single-valued property paths that is enclosed in parentheses. A path may consist of a sequence of single-valued navigation and complex properties. The same property path SHOULD NOT appear more than once; redundant property paths MAY be considered valid, but MUST NOT alter the meaning of the request. If the property path leads to a single-valued navigation property, this means grouping by the entity-id of the related entities. Other navigation properties specified in grouping property paths are expanded by default.
          {quote}The output set is constructed in five steps:
           # For each instance in the input set:
           ## Create a projection of the instance with all related entities included that are reached via navigation properties that occur in the grouping properties.
           ## Remove from the projection all structural and navigation properties that are not traversed by any grouping property.
           # The input set is split into subsets where two instances are in the same subset if their projections are the same _(with null considered different from absent)_.
           # The set transformations from the second parameter are applied to each subset, resulting in a new set of potentially different structure and cardinality. If the second parameter is absent, each subset is transformed into a set consisting of a single instance without properties. -Transformations may take into account the grouping properties for producing their result, e.g. aggregate removes properties that are used neither for grouping nor for aggregation.-
           # In each set resulting from the previous step, every instance is augmented if necessary to include all _primitive property values_ of the corresponding projection _and its nested complex or navigation properties_. {color:#de350b}(In other words: Primitive values are overwritten from the projection, complex values are merged.){color}
           # The augmented sets of the previous step are added to the output set.{quote}
          -If the service is unable to group by same values for any of the specified properties, it MUST reject the request with an error response. It MUST NOT apply any implicit rules to group instances indirectly by another property related to it in some way.-

           
          heiko.theissen Heiko Theissen made changes -
          Proposal See discussion and proposal in [this document|https://www.oasis-open.org/apps/org/workgroup/odata/download.php/69428/ODATA-1459.docx]

          Rephrase the beginning of section 3.10 as follows (insertions are indented or italicized.) Merge [PR #176|https://github.com/oasis-tcs/odata-vocabularies/pull/176].
          h2. 3.10 [Transformation groupby|#sec_Transformationgroupby]

          The {{groupby}} transformation takes one or two parameters _where the second is a list of set transformations, separated by forward slashes to express that they are consecutively applied._
          h3. 3.10.1 [Simple Grouping|#sec_SimpleGrouping]

          In its simplest form the first parameter of {{groupby}} specifies the _grouping properties_, a comma-separated list of one or more single-valued property paths that is enclosed in parentheses. A path may consist of a sequence of single-valued navigation and complex properties. The same property path SHOULD NOT appear more than once; redundant property paths MAY be considered valid, but MUST NOT alter the meaning of the request. If the property path leads to a single-valued navigation property, this means grouping by the entity-id of the related entities. Other navigation properties specified in grouping property paths are expanded by default.
          {quote}The output set is constructed in five steps:
           # For each instance in the input set:
           ## Create a projection of the instance with all related entities included that are reached via navigation properties that occur in the grouping properties.
           ## Remove from the projection all structural and navigation properties that are not traversed by any grouping property.
           # The input set is split into subsets where two instances are in the same subset if their projections are the same _(with null considered different from absent)_.
           # The set transformations from the second parameter are applied to each subset, resulting in a new set of potentially different structure and cardinality. If the second parameter is absent, each subset is transformed into a set consisting of a single instance without properties. -Transformations may take into account the grouping properties for producing their result, e.g. aggregate removes properties that are used neither for grouping nor for aggregation.-
           # In each set resulting from the previous step, every instance is augmented if necessary to include all _primitive property values_ of the corresponding projection _and its nested complex or navigation properties_. {color:#de350b}(In other words: Primitive values are overwritten from the projection, complex values are merged.){color}
           # The augmented sets of the previous step are added to the output set.{quote}
          -If the service is unable to group by same values for any of the specified properties, it MUST reject the request with an error response. It MUST NOT apply any implicit rules to group instances indirectly by another property related to it in some way.-

                      		See discussion and proposal in [this document|https://www.oasis-open.org/apps/org/workgroup/odata/download.php/69428/ODATA-1459.docx]

          Rephrase the beginning of section 3.10 as follows (insertions are indented or italicized.)
          h2. 3.10 [Transformation groupby|#sec_Transformationgroupby]

          The {{groupby}} transformation takes one or two parameters _where the second is a list of set transformations, separated by forward slashes to express that they are consecutively applied._
          h3. 3.10.1 [Simple Grouping|#sec_SimpleGrouping]

          In its simplest form the first parameter of {{groupby}} specifies the _grouping properties_, a comma-separated list of one or more single-valued property paths that is enclosed in parentheses. A path may consist of a sequence of single-valued navigation and complex properties. The same property path SHOULD NOT appear more than once; redundant property paths MAY be considered valid, but MUST NOT alter the meaning of the request. If the property path leads to a single-valued navigation property, this means grouping by the entity-id of the related entities. Other navigation properties specified in grouping property paths are expanded by default.
          {quote}The output set is constructed in five steps:
           # For each instance in the input set:
           ## Create a projection of the instance with all related entities included that are reached via navigation properties that occur in the grouping properties.
           ## Remove from the projection all structural and navigation properties that are not traversed by any grouping property.
           # The input set is split into subsets where two instances are in the same subset if their projections are the same _(with null considered different from absent)_.
           # The set transformations from the second parameter are applied to each subset, resulting in a new set of potentially different structure and cardinality. If the second parameter is absent, each subset is transformed into a set consisting of a single instance without properties. -Transformations may take into account the grouping properties for producing their result, e.g. aggregate removes properties that are used neither for grouping nor for aggregation.-
           # In each set resulting from the previous step, every instance is augmented if necessary to include all _primitive property values_ of the corresponding projection _and its nested complex or navigation properties_. {color:#de350b}(In other words: Primitive values are overwritten from the projection, complex values are merged.){color}
           # The augmented sets of the previous step are added to the output set.{quote}
          -If the service is unable to group by same values for any of the specified properties, it MUST reject the request with an error response. It MUST NOT apply any implicit rules to group instances indirectly by another property related to it in some way.-

           
          heiko.theissen Heiko Theissen made changes -
          Proposal See discussion and proposal in [this document|https://www.oasis-open.org/apps/org/workgroup/odata/download.php/69428/ODATA-1459.docx]

          Rephrase the beginning of section 3.10 as follows (insertions are indented or italicized.)
          h2. 3.10 [Transformation groupby|#sec_Transformationgroupby]

          The {{groupby}} transformation takes one or two parameters _where the second is a list of set transformations, separated by forward slashes to express that they are consecutively applied._
          h3. 3.10.1 [Simple Grouping|#sec_SimpleGrouping]

          In its simplest form the first parameter of {{groupby}} specifies the _grouping properties_, a comma-separated list of one or more single-valued property paths that is enclosed in parentheses. A path may consist of a sequence of single-valued navigation and complex properties. The same property path SHOULD NOT appear more than once; redundant property paths MAY be considered valid, but MUST NOT alter the meaning of the request. If the property path leads to a single-valued navigation property, this means grouping by the entity-id of the related entities. Other navigation properties specified in grouping property paths are expanded by default.
          {quote}The output set is constructed in five steps:
           # For each instance in the input set:
           ## Create a projection of the instance with all related entities included that are reached via navigation properties that occur in the grouping properties.
           ## Remove from the projection all structural and navigation properties that are not traversed by any grouping property.
           # The input set is split into subsets where two instances are in the same subset if their projections are the same _(with null considered different from absent)_.
           # The set transformations from the second parameter are applied to each subset, resulting in a new set of potentially different structure and cardinality. If the second parameter is absent, each subset is transformed into a set consisting of a single instance without properties. -Transformations may take into account the grouping properties for producing their result, e.g. aggregate removes properties that are used neither for grouping nor for aggregation.-
           # In each set resulting from the previous step, every instance is augmented if necessary to include all _primitive property values_ of the corresponding projection _and its nested complex or navigation properties_. {color:#de350b}(In other words: Primitive values are overwritten from the projection, complex values are merged.){color}
           # The augmented sets of the previous step are added to the output set.{quote}
          -If the service is unable to group by same values for any of the specified properties, it MUST reject the request with an error response. It MUST NOT apply any implicit rules to group instances indirectly by another property related to it in some way.-

                      		See discussion and proposal in [this document|https://www.oasis-open.org/apps/org/workgroup/odata/download.php/69428/ODATA-1459.docx]

          Rephrase the beginning of section 3.10 as follows (insertions are indented or italicized.)
          h2. 3.10 [Transformation groupby|#sec_Transformationgroupby]

          The {{groupby}} transformation takes one or two parameters _where the second is a list of set transformations, separated by forward slashes to express that they are consecutively applied._
          h3. 3.10.1 [Simple Grouping|#sec_SimpleGrouping]

          In its simplest form the first parameter of {{groupby}} specifies the _grouping properties_, a comma-separated list of one or more single-valued property paths that is enclosed in parentheses. A path may consist of a sequence of single-valued navigation and complex properties. The same property path SHOULD NOT appear more than once; redundant property paths MAY be considered valid, but MUST NOT alter the meaning of the request. If the property path leads to a single-valued navigation property, this means grouping by the entity-id of the related entities. Other navigation properties specified in grouping property paths are expanded by default.
          {quote}The output set is constructed in five steps:
           # For each instance in the input set:
           ## Create a projection of the instance with all related entities included that are reached via navigation properties that occur in the grouping properties.
           ## Remove from the projection all structural and navigation properties that are not traversed by any grouping property.
           # The input set is split into subsets where two instances are in the same subset if their projections are the same _(_with null considered different from absent_)_.
           # The set transformations from the second parameter are applied to each subset, resulting in a new set of potentially different structure and cardinality. If the second parameter is absent, each subset is transformed into a set consisting of a single instance without properties. -Transformations may take into account the grouping properties for producing their result, e.g. aggregate removes properties that are used neither for grouping nor for aggregation.-
           # In each set resulting from the previous step, each entity and complex type, including nested complex and navigation properties, are augmented if necessary to include all primitive property values of the corresponding projection.
           # The output set is the union of the augmented sets of the previous step.{quote}
          -If the service is unable to group by same values for any of the specified properties, it MUST reject the request with an error response. It MUST NOT apply any implicit rules to group instances indirectly by another property related to it in some way.-

           
          heiko.theissen Heiko Theissen made changes -
          Proposal See discussion and proposal in [this document|https://www.oasis-open.org/apps/org/workgroup/odata/download.php/69428/ODATA-1459.docx]

          Rephrase the beginning of section 3.10 as follows (insertions are indented or italicized.)
          h2. 3.10 [Transformation groupby|#sec_Transformationgroupby]

          The {{groupby}} transformation takes one or two parameters _where the second is a list of set transformations, separated by forward slashes to express that they are consecutively applied._
          h3. 3.10.1 [Simple Grouping|#sec_SimpleGrouping]

          In its simplest form the first parameter of {{groupby}} specifies the _grouping properties_, a comma-separated list of one or more single-valued property paths that is enclosed in parentheses. A path may consist of a sequence of single-valued navigation and complex properties. The same property path SHOULD NOT appear more than once; redundant property paths MAY be considered valid, but MUST NOT alter the meaning of the request. If the property path leads to a single-valued navigation property, this means grouping by the entity-id of the related entities. Other navigation properties specified in grouping property paths are expanded by default.
          {quote}The output set is constructed in five steps:
           # For each instance in the input set:
           ## Create a projection of the instance with all related entities included that are reached via navigation properties that occur in the grouping properties.
           ## Remove from the projection all structural and navigation properties that are not traversed by any grouping property.
           # The input set is split into subsets where two instances are in the same subset if their projections are the same _(_with null considered different from absent_)_.
           # The set transformations from the second parameter are applied to each subset, resulting in a new set of potentially different structure and cardinality. If the second parameter is absent, each subset is transformed into a set consisting of a single instance without properties. -Transformations may take into account the grouping properties for producing their result, e.g. aggregate removes properties that are used neither for grouping nor for aggregation.-
           # In each set resulting from the previous step, each entity and complex type, including nested complex and navigation properties, are augmented if necessary to include all primitive property values of the corresponding projection.
           # The output set is the union of the augmented sets of the previous step.{quote}
          -If the service is unable to group by same values for any of the specified properties, it MUST reject the request with an error response. It MUST NOT apply any implicit rules to group instances indirectly by another property related to it in some way.-

                      		Rephrase the beginning of section 3.10 as follows (insertions are indented or italicized.)
          h2. 3.10 [Transformation groupby|#sec_Transformationgroupby]

          The {{groupby}} transformation takes one or two parameters _where the second is a list of set transformations, separated by forward slashes to express that they are consecutively applied._
          h3. 3.10.1 [Simple Grouping|#sec_SimpleGrouping]

          In its simplest form the first parameter of {{groupby}} specifies the _grouping properties_, a comma-separated list of one or more single-valued property paths that is enclosed in parentheses. A path may consist of a sequence of single-valued navigation and complex properties. The same property path SHOULD NOT appear more than once; redundant property paths MAY be considered valid, but MUST NOT alter the meaning of the request. If the property path leads to a single-valued navigation property, this means grouping by the entity-id of the related entities. Other navigation properties specified in grouping property paths are expanded by default.
          {quote}The output set is constructed in five steps:
           # For each instance in the input set:
           ## Create a projection of the instance with all related entities included that are reached via navigation properties that occur in the grouping properties.
           ## Remove from the projection all structural and navigation properties that are not traversed by any grouping property.
           # The input set is split into subsets where two instances are in the same subset if their projections are the same _(_with null considered different from absent_)_.
           # The set transformations from the second parameter are applied to each subset, resulting in a new set of potentially different structure and cardinality. If the second parameter is absent, each subset is transformed into a set consisting of a single instance without properties. -Transformations may take into account the grouping properties for producing their result, e.g. aggregate removes properties that are used neither for grouping nor for aggregation.-
           # In each set resulting from the previous step, each entity and complex type, including nested complex and navigation properties, are augmented if necessary to include all primitive property values of the corresponding projection.
           # The output set is the union of the augmented sets of the previous step.{quote}
          -If the service is unable to group by same values for any of the specified properties, it MUST reject the request with an error response. It MUST NOT apply any implicit rules to group instances indirectly by another property related to it in some way.-

           
          heiko.theissen Heiko Theissen made changes -
          Resolution Fixed [ 1 ]
          Status Open [ 1 ] Resolved [ 5 ]
          heiko.theissen Heiko Theissen made changes -
          Proposal Rephrase the beginning of section 3.10 as follows (insertions are indented or italicized.)
          h2. 3.10 [Transformation groupby|#sec_Transformationgroupby]

          The {{groupby}} transformation takes one or two parameters _where the second is a list of set transformations, separated by forward slashes to express that they are consecutively applied._
          h3. 3.10.1 [Simple Grouping|#sec_SimpleGrouping]

          In its simplest form the first parameter of {{groupby}} specifies the _grouping properties_, a comma-separated list of one or more single-valued property paths that is enclosed in parentheses. A path may consist of a sequence of single-valued navigation and complex properties. The same property path SHOULD NOT appear more than once; redundant property paths MAY be considered valid, but MUST NOT alter the meaning of the request. If the property path leads to a single-valued navigation property, this means grouping by the entity-id of the related entities. Other navigation properties specified in grouping property paths are expanded by default.
          {quote}The output set is constructed in five steps:
           # For each instance in the input set:
           ## Create a projection of the instance with all related entities included that are reached via navigation properties that occur in the grouping properties.
           ## Remove from the projection all structural and navigation properties that are not traversed by any grouping property.
           # The input set is split into subsets where two instances are in the same subset if their projections are the same _(_with null considered different from absent_)_.
           # The set transformations from the second parameter are applied to each subset, resulting in a new set of potentially different structure and cardinality. If the second parameter is absent, each subset is transformed into a set consisting of a single instance without properties. -Transformations may take into account the grouping properties for producing their result, e.g. aggregate removes properties that are used neither for grouping nor for aggregation.-
           # In each set resulting from the previous step, each entity and complex type, including nested complex and navigation properties, are augmented if necessary to include all primitive property values of the corresponding projection.
           # The output set is the union of the augmented sets of the previous step.{quote}
          -If the service is unable to group by same values for any of the specified properties, it MUST reject the request with an error response. It MUST NOT apply any implicit rules to group instances indirectly by another property related to it in some way.-

                      		Rephrase the beginning of section 3.10 as follows (insertions are indented or italicized.)
          h2. 3.10 [Transformation groupby|#sec_Transformationgroupby]

          The {{groupby}} transformation takes one or two parameters _where the second is a list of set transformations, separated by forward slashes to express that they are consecutively applied._
          h3. 3.10.1 [Simple Grouping|#sec_SimpleGrouping]

          In its simplest form the first parameter of {{groupby}} specifies the _grouping properties_, a comma-separated list of one or more single-valued property paths that is enclosed in parentheses. A path may consist of a sequence of single-valued navigation and complex properties. The same property path SHOULD NOT appear more than once; redundant property paths MAY be considered valid, but MUST NOT alter the meaning of the request. If the property path leads to a single-valued navigation property, this means grouping by the entity-id of the related entities. Other navigation properties specified in grouping property paths are expanded by default.
          {quote}The output set is constructed in five steps:
           # For each instance in the input set:
           ## Create a projection of the instance with all related entities included that are reached via navigation properties that occur in the grouping properties.
           ## Remove from the projection all structural and navigation properties that are not traversed by any grouping property.
           # The input set is split into subsets where two instances are in the same subset if their projections are the same (with null considered different from absent).
           # The set transformations from the second parameter are applied to each subset, resulting in a new set of potentially different structure and cardinality. If the second parameter is absent, each subset is transformed into a set consisting of a single instance without properties. -Transformations may take into account the grouping properties for producing their result, e.g. aggregate removes properties that are used neither for grouping nor for aggregation.-
           # In each set resulting from the previous step, each entity and complex type, including nested complex and navigation properties, are augmented if necessary to include all primitive property values of the corresponding projection.
           # The output set is the union of the augmented sets of the previous step.{quote}
          -If the service is unable to group by same values for any of the specified properties, it MUST reject the request with an error response. It MUST NOT apply any implicit rules to group instances indirectly by another property related to it in some way.-

           
          heiko.theissen Heiko Theissen made changes -
          Proposal Rephrase the beginning of section 3.10 as follows (insertions are indented or italicized.)
          h2. 3.10 [Transformation groupby|#sec_Transformationgroupby]

          The {{groupby}} transformation takes one or two parameters _where the second is a list of set transformations, separated by forward slashes to express that they are consecutively applied._
          h3. 3.10.1 [Simple Grouping|#sec_SimpleGrouping]

          In its simplest form the first parameter of {{groupby}} specifies the _grouping properties_, a comma-separated list of one or more single-valued property paths that is enclosed in parentheses. A path may consist of a sequence of single-valued navigation and complex properties. The same property path SHOULD NOT appear more than once; redundant property paths MAY be considered valid, but MUST NOT alter the meaning of the request. If the property path leads to a single-valued navigation property, this means grouping by the entity-id of the related entities. Other navigation properties specified in grouping property paths are expanded by default.
          {quote}The output set is constructed in five steps:
           # For each instance in the input set:
           ## Create a projection of the instance with all related entities included that are reached via navigation properties that occur in the grouping properties.
           ## Remove from the projection all structural and navigation properties that are not traversed by any grouping property.
           # The input set is split into subsets where two instances are in the same subset if their projections are the same (with null considered different from absent).
           # The set transformations from the second parameter are applied to each subset, resulting in a new set of potentially different structure and cardinality. If the second parameter is absent, each subset is transformed into a set consisting of a single instance without properties. -Transformations may take into account the grouping properties for producing their result, e.g. aggregate removes properties that are used neither for grouping nor for aggregation.-
           # In each set resulting from the previous step, each entity and complex type, including nested complex and navigation properties, are augmented if necessary to include all primitive property values of the corresponding projection.
           # The output set is the union of the augmented sets of the previous step.{quote}
          -If the service is unable to group by same values for any of the specified properties, it MUST reject the request with an error response. It MUST NOT apply any implicit rules to group instances indirectly by another property related to it in some way.-

                      		Rephrase the beginning of section 3.10 as follows (insertions are indented or italicized.)
          h2. 3.10 [Transformation groupby|#sec_Transformationgroupby]

          The {{groupby}} transformation takes one or two parameters _where the second is a list of set transformations, separated by forward slashes to express that they are consecutively applied._
          h3. 3.10.1 [Simple Grouping|#sec_SimpleGrouping]

          In its simplest form the first parameter of {{groupby}} specifies the _grouping properties_, a comma-separated list of one or more single-valued property paths that is enclosed in parentheses. A path may consist of a sequence of single-valued navigation and complex properties. The same property path SHOULD NOT appear more than once; redundant property paths MAY be considered valid, but MUST NOT alter the meaning of the request. If the property path leads to a single-valued navigation property, this means grouping by the entity-id of the related entities. Other navigation properties specified in grouping property paths are expanded by default.
          {quote}The output set is constructed in five steps:
           # For each instance in the input set:
           ## Create a projection of the instance with all related entities included that are reached via navigation properties that occur in the grouping properties.
           ## Remove from the projection all structural and navigation properties that are not traversed by any grouping property.
           # The input set is split into subsets where two instances are in the same subset if their projections are the same with null considered different from absent.
           # The set transformations from the second parameter are applied to each subset, resulting in a new set of potentially different structure and cardinality. If the second parameter is absent, each subset is transformed into a set consisting of a single instance without properties. -Transformations may take into account the grouping properties for producing their result, e.g. aggregate removes properties that are used neither for grouping nor for aggregation.-
           # In each set resulting from the previous step, each entity and complex type, including nested complex and navigation properties, are augmented if necessary to include all primitive property values of the corresponding projection.
           # The output set is the union of the augmented sets of the previous step.{quote}
          -If the service is unable to group by same values for any of the specified properties, it MUST reject the request with an error response. It MUST NOT apply any implicit rules to group instances indirectly by another property related to it in some way.-

           
          handl Ralf Handl made changes -
          Status Resolved [ 5 ] Applied [ 10002 ]
          heiko.theissen Heiko Theissen made changes -
          Status Applied [ 10002 ] Closed [ 6 ]

            People

            • Assignee:
              Unassigned
              Reporter:
              gerald.krause1 Gerald Krause
            • Watchers:
              2 Start watching this issue

              Dates

              • Created:
                Updated:
                Resolved: