Link to the eCQI Resource Center. 

Yes, the PowerPoint and recording for all sessions are posted on the eCQI Resource Center eCQM Standards Education page. Please check back frequently for this and other news and event information related to electronic clinical quality improvement.

Please visit the eCQI Resource Center CQL page to register for upcoming CQL sessions.

Please visit the eCQI Resource Center CQL page to register for upcoming CQL sessions. Education announcements will also be sent through the various email lists. The CQL page also lists several workgroups where CQL is discussed.

Many of the acronyms are found on the eCQI Resource Center Glossary of eCQI Terms. We will be updating and adding new terms such as CQL in the near future.

It is available on the CQL Educational Resources page on the eCQI Resource Center.

Yes, the slides are posted on the eCQI Resource Center. You can access them at the eCQM Standards Education page or from the CQL Educational Resources page. 

The link to the Wiki is on the CQL page.

On the eCQI Resource Center Educational Resources, specifically, the Clinical Quality Language Measure Implementers session.

There are currently no in-person classes available. However, presentations will be provided in conferences such as the CMS Quality Conference and there is a scheduled interoperability course that will include a CQL session in February 2019. More details will be posted to the eCQI Resource Center.

Yes. The Clinical Reasoning track regularly runs CQL for both decision support and quality measurement scenarios at the connectathons.

CQL has dedicated constructs for the clinical domain, native support for intervals, and high level phrasing around temporal relationships. This allows for as close to natural language expressions as possible without ambiguity.

Yes, CQL supports both the open- and closed-world assumptions because this is really an aspect of the model being used and interpretation of the results of any given query.

DROOLS is a production rule language, whereas CQL is a functional language designed for expressing queries. Translators have been written to translate CQL to DROOLS, but they are not open source. Tooling exists to aid the translation of CQL to any target format in both the Java and .NET platforms.

The library is a text document containing CQL. Here you can reference other logic libraries to incorporate. A measure will have an associated library to reference and the HQMF can point to expressions within that.

Accuracy, ability to share between decision support rule and quality measures, and easier to build language processing applications.

The query in question is:

define "Emergency Department Encounters":                 ["Encounter, Performed": "Emergency Department Visit"] ED                                 with "Inpatient Encounters" E                                                 such that ED.dischargeDateTime 1 hour or less before E.admissionDateTime

The “with” and “without” operations in CQL do not change the result type of the query, so it remains "Encounter, Performed". These operators only filter the results based on the presence or absence of a related record (using the “such that” criteria to determine existence). They are equivalent to “semijoin” and “semiminus” in a relational query language.

Yes, libraries can be used to organize CQL logic so that it can be reused in multiple places.

The Clinical Quality Language Specification, available from HL7, has a complete description of all the operations and functions available in CQL. For the temporal operators specifically, section 2.5.5 of the Clinical Quality Language Specification provides a discussion of the available operators, and sections 9.8 and 9.9 of the reference define detailed semantics.

Agreed, there are several potential clashes with other technologies that will need to be addressed, the glossary page would be a good starting point for that.

Thank you for this good feedback. The upcoming Cooking with CQL series will address this by taking measures under development through the various logic phrases. First session will be held on April 28th and a whiteboard session will be available for questions. There will be additional CQL education sessions in the future. Visit the CQL page calendar on the eCQI Resource Center for more information. You can request CQL space membership and receive notifications when updates are made to the page.

Yes, it's part of the CQL specification available on the HL7 site.

Not only for reusability, but also for ease in implementation. The goal was to build modularity for CQL to have libraries that enable sharing between different measures and provide same language for data from different models.

Assuming that the conversion is referring to the change to move logic out of QDM, then it depends on the degree to which vendor’s existing code is tied up with evaluating that logic. In QDM, the data elements and the logic to write queries with them are specified together, making a clean separation between those two functions difficult, and preventing them from evolving at different rates. A primary design goal of CQL was to enable that separation at the specification level, and the reason for the approach taken of moving only the logic portion to CQL while retaining the QDM data model representation was to allow vendors to pivot their architectures as well. If a given architecture already drew a line between the data access layer and the logic evaluation, that architecture will be less impacted by this change than one that implemented the logic and retrieval together.

Yes, the comments will be included in the updated examples.

Functions take arguments passed to them and return a value. In the case of a hospitalization function:
define “Hospitalization” (Encounter “Encounter, Performed”) singleton from ( [“Encounter, Performed”: “Emergency Department Visit SNOMEDCT Value Set”] EDVisit where EDVisit ends 1 hour or less before start of Encounter ) X  return if X is null then Encounter.relevantPeriod else Interval[start of X.relevantPeriod, end of Encounter.relevantPeriod]
Computation is done with a value of type encounter to find an encounter that ends before the ED visit and if it’s not there, return the encounter as a relevant period; otherwise return an interval constructed from the start of the emergency department period to the end of the encounter’s relevant period.

authorDatetime is a single timestamp, the time when the record was authored.

It depends whether you are asking for a before or after relationship. If you say, “timestamp before period”, then it’s based on the start of the period, but if you say, “timestamp after period”, then it’s based on the end of the period.

The encounter is passed as an argument to the function, so the logic operates on whatever encounter is passed in.

There are no publicly available examples. However, a pilot in the Clinical Quality Framework initiative built a translator from CQL to Drools.

Yes, there is a process to translate an arbitrary QDM expression into CQL. However, one of the primary design goals of CQL was to make it easier to express complex relationships that were difficult or impossible to express in QDM. As a result, it is often the case that the best approach will be a manual translation of the intent of any given query, rather than an automated translation.

No, the approach to representing negation with CQL and QDM has changed based on feedback from and discussion with the CQL community. The negationRationale null check is no longer required. Instead, a “Not” modifier is used as part of the QDM data element description within the CQL retrieve. If this modifier is present, the result will be negated data elements, otherwise, only positive data elements will be returned.

For example:

define "Antithrombotic Administered":

  ["Medication, Administered": "Antithrombotic Therapy"]

The above expression will return all Antithrombotic Therapy Medication Administrations that were performed. To retrieve medications that were not administered, use the “Not” modifier:

define "Antithrombotic Not Administered":

    ["Medication, Not Administered": "Antithrombotic Therapy"] NotAdministered

        where NotAdministered.negationRationale in "Medical Reason"

Note that this is a negative assertion; results will only be returned if the reporting systems actually record these types of assertions (that a particular medication was not administered). There is no expectation that reporting systems would be required to infer that a given medication was not administered in order to return results from a query such as the above.

For a more detailed discussion of the representation of negation in CQL with QDM, refer to the following page: https://github.com/esacinc/CQL-Formatting-and-Usage-Wiki/wiki/Negation-in-QDM.

The using declaration within a CQL library specifies the version of the data model being used. For example, using QDM version 4.2.

The data model for QDM specification will specify that information. For more information, visit the QDM page on the eCQI Resource Center.

Yes, it’s on the timeline. The 5.0 is still draft and going through the various processes to get it in place, but there are specific changes that have been made as a result of wanting to take advantage of some of the functionality that is provided in CQL as well as trying to make sure there is a smooth transition. Authors that are familiar with 4.2 will be very comfortable seeing the way it is represented within 5.0 and in CQL.

Yes. This change was made to support the fact that a single encounter may have multiple diagnoses associated with it. Note that the “Principal Diagnosis” attribute is still singular.

1) When using observations with different dates

2) For an episode of care

3) When using the same encounter from two different expressions.

Yes, this will be covered in the next CQL training session and in the Cooking with CQL sessions beginning on April 28th.

Yes, we have many example measures and are working to develop more. Examples are posted on the CQL Formatting and Usage Wiki: Example Measures.

We have several measures that we have expressed with CQL. There are numerous examples posted with the specification on the HL7 CQL page and the CQL Formatting and Usage Wiki: Example Measures.

HQMF specifies the population criteria, but instead of defining that within the HQMF as previously executed, it points to CQL. Refer to the CQL-based HQMF IG for examples and the CQL Formatting and Usage Wiki: Specifying Population Criteria.

The CQL specification itself does not define how measures are to be expressed, it only provides a mechanism to describe logic related to the quality domains of decision support and quality measurement. Additional guidance describing how CQL is used to create measures is provided in the CQL-Based HQMF IG, as well as the currently under-development CQF-on-FHIR IG.

Benefits of CQL discussed at HIMSS included; modularity, computability, flexible data model, robust logic expression and reduced duplicative work for vendors and developers. From now through fall 2017, CMS and contracting partners will work with measure developers, implementers, vendors and owners of the various eCQM tools to test, develop and evolve the CQL standard to be most effective with eCQMs. Visit the eCQI Resource Center for more information and to sign up for workgroup sessions.

The ANTLR parse tree will be a direct representation of the input CQL. You will have to do type verification and type inference and operator resolution in order to support that type verification. You would also have to do the implicit conversions and generic type extension. There are a lot of things that the CQL supports, higher level constructs like timing phrases that are translated into a representation in ELM that is focused on implementation so that you don’t have to worry about those pieces within ELM. There is nothing that says you couldn’t do all that yourself but for implementation, using ELM takes each of those pieces off an implementer’s plate. Individually each of those aren’t terribly difficult but when you put them all together and add them all up, together with the fact that it’s maintained as a part of this whole infrastructure, it’s a significant advantage to be able to use the ELM directly rather than have to start directly from a parser.

Yes, it is possible and we do provide a CQL ANTLR grammar just like on the previous question. The ANTLR tooling is great. It provides easy to use generated visitor and/or listener code depending on which mode you use it in. In fact the CQL-ELM translator is implemented using a generated ANTLR visitor. The advantages are those uses that I’ve mentioned, you’ve got the ELM representation that’s focused on implementation. Rather than CQL representation, which is focused on high level representation that’s human readable and natural language expression of timing, and clinical concepts.

Yes, the human readable that’s currently part of the HTML for each measure and uses QDM, will actually use CQL now. There are examples within the CQL formatting and usage Wiki that show some of that. That’s our current approach.

That depends on the target of the sharing. I agree that if your intent is to share between clinicians or human readers or even eventually integrators, if the readers are human CQL would be a better way to share that, but if the intent is to automate sharing of that measure definition, then CQL introduces another level of functionality and the ELM that is underneath provides an easy way to get to that more machine friendly representation. There is nothing that says you couldn’t share at the CQL level even for integration, it’s a formal language and it supports accurate and computable representation of the measure logic. It’s just that the CQL to ELM translator and that representation provides an easy way to get past all of those traditional hurdles of building a new compiler or interpreter.

There is a release 1.2 of HQMF that extends this standard in a very simple way to be able to reference an external document. And the way that the CQL based HQMF IG then uses that extension for HQMF is to specify that the logic for the criteria expressed within the HQMF is actually specified in the ELM document. That document is a library just like the example we showed in the ELM library that actually contains the logic and then the HQMF will be the criteria that will actually point to an expression to find in that ELM document. So no, it won’t be nested inside the HQMF, it will just be referenced as a separate document and then each criteria will point to specific expressions within the ELM.

eCQMs will still be distributed using HQMF, but the logic involved will be contained in separate CQL and ELM documents distributed along with the HQMF, and the criteria in the HQMF document will reference expressions defined in the CQL/ELM library.

There are lots of examples in the Formatting and Usage wiki.

Potentially no. A more clinically relevant example can use ordered during the encounter relevant period if that element is available.

By specifying configurations and running it through the CQL to ELM translator, which is a Java Package available through the Maven Repository. Right now, you can use command-line or call it directly from Java.

Yes, in the new version of CQL 1.2, distinctions will not be necessary because duplicates will be automatically eliminated.

Yes, it could reference an episode of care where the exclusions were associated with any encounter in that episode of care.

["Encounter, Performed": "Encounter Inpatient" ] Encounter without "Newborn Hearing Screening Left" Left such that Left.relevantPeriod during Encounter.relevantPeriod without "Newborn Hearing Screening Right" Right such that Right.relevantPeriod during Encounter.relevantPeriod where "Encounter.dischargeDisposition" in "Patient Expired"

// behavior of with/without is additive ["Encounter, Performed": "Encounter Inpatient"] Encounter without "Newborn Hearing Screening Left" Left such that Left.relevantPeriod during Encounter.relevantPeriod without "Newborn Hearing Screening Right" Right such that Right.relevantPeriod during Encounter.relevantPeriod where Encounter.dischargeDisposition in "Patient Expired" The second problem is that because without clauses are additive in a query, the encounter will only be returned if it has neither a left nor a right screening, which isn’t the intent of the measure. Instead, define them separately and use a union to combine them: define "Encounters Without Left": ["Encounter, Performed": "Encounter Inpatient"] Encounter without "Newborn Hearing Screening Left" Left such that Left.relevantPeriod during Encounter.relevantPeriod define "Encounters Without Right": ["Encounter, Performed": "Encounter Inpatient"] Encounter without "Newborn Hearing Screening Right" Right such that Right.relevantPeriod during Encounter.relevantPeriod define "Encounters Without Screening": "Encounters Without Left" union "Encounters Without Right"
*Note – Don’t put double quotes around the whole qualified identifier, it will not find the identifier. E.g., use Encounter.dischargeDisposition and not “Encounter.dischargeDisposition”.

Yes.

Yes, time durations in CQL are always in terms of a single duration. If it was necessary to say 32 weeks and 1 day, you would define it in days (or use addition to add 32 weeks + 1 day).

In this expression, it is entered as a definition, but you could also define a gestational age at birth function. define "Estimated Due Date": Last( ["Physical Exam, Performed": Vx."Estimated Due Date"] Exam sort by start of relevantPeriod ).result as DateTime
define "Gestational Age in Days at Birth": (280 - (duration in days between "Estimated Due Date" and "Birth Date")) div 7

Each “with” needs a “such that” to describe the relationship of the “with” source to the “primary” source.

Because the timing phrase in 1.1 doesn’t have a way to say, “less than 30 days”, only “29 days or less”. The 1.2 version of CQL will introduce the ability to say, “less than 30 days”.

a) Define “Encounter With ED Visit Less Than Two Days”: “Encounter with Ischemic Stroke” E with “ED visit” ED And b) Define “ED Visit Less Than Two Days”: “ED Visit” ED with “Encounter With Ischemic Stroke” E

Query (a) is returning the inpatient encounters, not the ED visits. What should be counted in this measure is inpatient encounters. We are interested in a case where there was a prior ED visit to consider as part of the encounter. Query (b) is returning the ED visits immediately following an inpatient encounter.

Yes, and it depends on whether we are defining a patient-based or encounter-based measure. For an encounter based measure, what we are returning from all the criteria are lists of encounters. In a patient-based measure, what we are returning from all the criteria is true or false. So, in a patient-based measure you use exist to get a list to be true or false. In an episode-based measure, we are returning lists, so we don’t use exist.

That’s correct, it’s better to use “AMI Encounter” because it has all the necessary criteria.

The Intersect operator takes two lists and returns only those elements that are in both lists, so the lists should have the same kinds of values, such as lists of encounters. You cannot intersect encounters and orders.

Because length of stay is an attribute of the encounter, it doesn’t work for defining the overall length of stay in the case where we want to consider the encounter immediately prior to the emergency department visit. Using the CQL expression is more general and it allows you to handle that case transparently. The length of stay attribute of Encounter, performed can be used to define the time from admission to discharge for a specific encounter. However, if the measure developer needs to express the time from admission to a previous, but related encounter (i.e., an Emergency Department visit), the length of stay attribute would not be sufficient and a CQL expression provides such ability. Note, that to determine the arrival time at the previous Emergency Department visit, the measure needs to address the Encounter, Performed location attribute.

The hospitalization function has been considered as an approach to identifying an encounter plus the time immediately prior to the emergency department visit. In a lot of the current hospital measures, they are looking for that pattern because there is an inpatient encounter with an immediately prior ED visit. In previous logic, those cases had to be considered independently. The hospitalization function gives us the duration, the interval from the start to the end of either the encounter or the immediately prior ED visit. It collapses that logic for determining what the overall duration of the hospitalization is, and by using this function, then we pass an encounter and it tells us from admission to discharge. Note, to determine arrival time within the hospitalization function requires use of the Encounter, Performed location attribute.

Yes.

The QDM supports the description of an allergy/intolerance to provide more detailed information than is available in a Diagnosis alone. However, this flexibility means there is the potential for underlying systems to provide the data as both a Diagnosis or as an Allergy/Intolerance. Measure authors can express the allergy in both ways to cover this possibility. For example, to address the type of reaction that meets the measure criteria, the measure can indicate “Diagnosis: Anaphylactic reaction to penicillin” using a precoordinated SNOMED CT concept, or use a post-coordinated approach “Allergy/Intolerance: Penicillin (type: anaphylaxis).” The latter approach may be more consistent with the way an allergy or intolerance is managed using non-measure transactions in HL7 V2, V3, and FHIR, except that FHIR uses the metadata element “reaction” to address the QDM attribute “type.”

Each diagnosis should be described separately. The expression using union won’t work because it will produce results if either one or both diagnoses are present. If the use case requires both, then the “and” expression is required.

define 'Single Live Birth Encounter or Gestational Diabetes':

    'Inpatient-Encounter” Encounter

           where exists (Encounter.diagnoses Diagnosis

                 where Diagnosis in 'Single Live Birth'

                       or Diagnosis in Gestational Diabetes'

)

A. No because it indicates you want any diagnosis in the inpatient encounter that has a diagnosis code of “Single Live Birth” and “Gestational Diabetes”. The single code cannot satisfy both those requirements at the same time.

     Interval

     [

         First(Encounter.facilityLocations Location

                Return start of Location.locationPeriod sort ascending),

        Last(Encounter.facilityLocations location

                Return end of Location.locationPeriod sort ascending)

    ]

A. The interval would return a full Datetime, e.g., the first return would be locationPeriod: 10:30..11:21

If there is a need to distinguish different results that have the same types of values, then yes, there would need to be some way to map that content from the source system. However, for cases that do not need to distinguish different results (e.g., because the result values are precoordinated, so no two components could have the same result value), then the code layer can be ignored. It depends on the use case. The structure and logic support both approaches.

Yes, within 60 days can be before or after. 

Parameters are external values that are provided when the measure is evaluated, whereas definitions are used to organize criteria within the measure.

Yes, the age criteria is independent of the other conditions here, so it could be moved to a separate definition, especially if the intent was to reuse that component in other definitions.

Review the full expression in the CQL Formatting and Usage Wiki.

A. CQL takes a different approach to representing what specific occurrences were achieving, namely identifying a specific instance and associating criteria with that instance. Because CQL can describe queries and their results, and then use those results in subsequent operations, specific occurrences are not required to tie the different appearances of a data element together throughout the measure definition. Rather, with CQL, additional criteria are applied to specific instances of a data element by referencing the same expressions. For more information and examples, see the Specific Occurrences topic in the Formatting and Usage Wiki.

It is a definition. Value set declarations are defined in the CQL header and are local identifiers for value sets stored in a terminology service like the Value Set Authority Center. Definitions are defined in the body of the CQL library and specify chunks of logic that can be used throughout the library or within the measure as population criteria.

Coalesce is used when the attributes differ to give preference to a particular value if it is present. For Procedure, Performed, we have both an authorDatetime and a relevantPeriod, but for Immunization, Administered, we only have an authorDatetime, so the Coalesce in this case is saying “Use the start of the relevantPeriod if it’s present, otherwise use the authorDatetime.”

It depends how often the definition needs to be used in subsequent logic. If the definition is used often, and the Coalesce pattern is required for each usage, then it makes sense to change the definition so that it returns the same kinds of tuples, so that subsequent references can just reference a single attribute and not have to use the Coalesce pattern.

We will add this as a topic for a future Cooking with CQL session.

If you need to reference only a subset of the codes from an existing value set, this can be done two ways; 1) define another value set with only that code in it or, 2) reference a specific code. In general, if the use case clearly identifies a specific code to reference, you can use it as a direct reference code. However, if there are multiple codes necessary, a new value set is needed. 

Note that although CQL does provide set operations that could be used to compute the subset of a value set using some expressive criteria, performing calculations involving value sets is not recommended for several reasons:

1. Terminology operations, such as membership, are communicated in the machine-readable file in specific ways that enable implementations to make use of terminology servers. Performing calculations on value sets requires the use of expansion, which is not required for membership testing when that testing is done by the terminology server. As a result, using value sets in calculation would impose an additional implementation burden on vendors consuming the measure.
2. The definition of terminology is by design a separate aspect of quality measure development. This separation of concerns has multiple benefits, including that the maintenance and governance of value sets can be performed independent of the maintenance and governance of the measures.
3. Value set definition often involves operations that are specific to the terminologies involved, so there is a great deal of variability in the way that these expressions are represented.

No, whether a boundary is closed or open is an aspect of the value, not the type. The systems providing the information indicate whether they are giving an interval that has closed or open boundaries.

let procedure: (

        “Total Hip Total Knee Procedure” (QualifyingEncounters) P

        where P.ordinality in “Principal”

       )

A. No, the “where” clause in a query will not change the result type of the query.

No, it is true for both patient-based and non-patient based measures. However, for non-patient based measures, because the criteria expression has to return the same type as the rest of the measure population criteria, it is often easiest to just reference the “Initial Population”.

Yes, not only into the Measure Authoring Tool, but also various tools used to create electronic specifications such as Bonnie for test cases.

CQL is available now as a draft. The timeline for incorporating it in specifications is in process.

Currently HQMF uses CDA templates based on QDM and also defines logic. CQL does not describe the structure of a measure or data model involved. The CQL-based HQMF IG is using CQL to express the logic portions but still referencing QDM for the data element and HQMF to represent the structure of the measure and metadata involved.

No, the specification has been in DSTU for over a year, and has undergone very little change. There is a 1.1 release in process, but after working with CQL to express a broad array of measures, the language has proven to be an effective platform for the expression of quality-related logic.

The Measure Authoring Tool (MAT) will be available to use in a test environment in the fall of 2016 for users that want to test and try creating measures using CQL. No firm date has been established. Please refer to “Proposed Timeline For Updating Standards” on slide 6 of the Clinical Quality Language (CQL) for Measure Developers presentation.

They will be available for testing as per the detailed timeline when tools are ready. Please see the “Proposed Timeline For Updating Standards” on slide 6 of the Clinical Quality Language (CQL) for Measure Developers presentation.

It will depend on when the tools are ready.

Yes, the transition to CQL is mentioned in the FY 2017 IPPS Proposed Rule.

Yes, there is collaboration with multiple organizations to help with the synergy of HEDIS measures. 

Testing eCQM using CQL-QDM-HQMF 2.1, will be the final testing phase before implementation of CQL. It will have the final draft of CQL with tools updated and the full measure entered into the measure authoring tool.

Please refer to the CQL page on the eCQI Resource Center for more information about signing up for CQL workgroups that will go over the timeline planning process and where you can provide testing feedback. This fluid process will involve reviewing CQL measure standards measure specifications as they are developed. The workgroups meet on Fridays.

This will involve a coordinated effort between the various groups producing CQL tooling (MAT, Bonnie, additional tooling) to test that measures produced from the MAT can be evaluated within Bonnie against patient data produced there. In addition, the effort will involve pilot implementations with measure evaluation vendors (including EHRs and reporting providers) to ensure the measure calculation can be performed correctly.

Yes, there are Bonnie branches that are able to evaluate CQL expressions. 

The plan at this point is to release a user acceptance test version of MAT that’s putting out bare bone CQL-HQMF around October 2016 when measure developers and others who are part of that UAT cycle can start crafting their measures and seeing how things operate and work within that particular environment. As the timeline shows on slide 6, the plan at this point is to at some point within fall 2017 have a version of MAT that will be available in a production environment that users could create their CQL logic in.

You must be registered in VSAC as an author in order to create a new value set. Go to the Author Registration Section when logged in and search for the concepts you want in the terminology. Then identify and create a value set. Once the value set is defined in VSAC, you can use Retrieve by OID to access it in the MAT.

CQL only defines the notion of a value set and code system so that it can be referenced from within the logic.

Yes, within CQL, a “value set” is just a local identifier and can be any string. It is up to the evaluation and authoring environments to define the format and interpretation of that string.

There is currently tooling to support parsing and validation of CQL and development of tooling to support authoring and execution is in progress. Please visit the eCQI Resource Center CQL page for upcoming CQL sessions which will cover more on this and other CQL topics.

Yes, available at the GitHub tooling repository.

CQL is translatable to different environments with system engines that support its execution such as .NET, Java, and JavaScript. The open source tooling provides reference implementations that can be used as-is, or as a starting point for a custom implementation.

CQL is intended to provide a means to accurately and easily share the logic involved, and can be used with any technology platform. Open source tooling exists to facilitate usage in Java, .NET, and Java-Script.

Yes, there is a JavaScript engine at the GitHub tooling repository.

Yes, as part of the effort to support CQL, the MAT tool is being updated to allow measure authors to write logic using CQL.

Yes, they can write text documents using the CQL library. MAT tools provide the structure to make writing easy beyond having a text document. The MAT tools help with available operations and acceptable attributes from the QDM element.

Yes, the process of getting CQL into the MAT and having the tooling available to help a measure author describe and build a measure in CQL is in progress as outlined on the proposed timeline slides.

Yes, CQL is both a high level syntax expressed in text, as well as an equivalent lower level representation of the logic involved focused on language processing application. This lower-level format is defined as a schema and can be rendered in XML or JSON. There is tooling in the repository link to translate from the text representation of CQL to this lower-level representation (Expression Logical Model, or ELM) for XML or JSON rendering.In addition, the repository currently has an engine that can evaluate ELM expressions, there is a JavaScript engine that can run ELM representation.

If a user creates CQL statements freeform in MAT then the user is required to know the syntax but it is possible validations will occur if it is not correct.   If the user is using advanced functionality in MAT to create the intervals then the tool will insert the CQL logic with appropriate syntax and styling.

Yes, we plan on allowing users to export both the CQL and ELM files. MAT packages will be provided, there is a file for each export artifact.

About reusability, there will be at some future point the ability to share libraries and reuse the definitions within. We are targeting a future release that will have that functionality but at this point and time, there has not been a decision made as to when that functionality will be available. It will definitely be available for the fall 2017 timeframe but we cannot commit at this point that it will be available for the first UAT cycle.

CQL is designed to allow logic to be written against any data model. The specification defines an abstract data access layer that is responsible for retrieving data from the underlying systems, and that layer can provide access via a traditional relational database system, or JSON flat files, whatever is appropriate for the environment. For more information, refer to the CQL presentation Training for Measure Implementers about the implementation and design of CQL, and how it enables use of the same language across different models and platforms at the eCQI Resource Center Educational Resources.

Unfortunately the .NET reference implementation tooling for CQL is lagging so that code is viable, but would need to be updated. The SQL implementation path provided is to translate the CQL to SQL. Here’s a link to the HeD schema framework which works with CQL 1.0.

Measures in the Measure Library can only be shared by the owner. However, users of the MAT can see all shared measures and look them up by title or CMS ID.

Yes, it is. Specifically,  https://github.com/esacinc/CQL-Formatting-and-Usage-Wiki/blob/master/Source/Cooking%20With%20CQL/14/22_CMS72_HospitalizationApproach.cql#L58In addition, the function is available as part of the MAT Global Common Functions library in the MAT.

The ability to do this is currently in the MAT by creating a standalone CQL library and include this function within it and call it out as needed.

This editor is called Atom, a desktop general purpose editor. We built a syntax highlighter editor for it. It works well, does not give validations, but the MAT has that functionality embedded.

Measure developers maintain and publish terminologies to the Value Set Authority Center (VSAC). They are distributed with measure definitions as part of the overall process. Those value sets are updated not just when the measures are published, but also periodically to capture additional terminology changes.

The VSAC maintains the value set definitions including codes involved and versions of the terminology those codes came from, hence extensions are determined with versioning in mind.

The CQL specification defines the high level CQL grammar as well as the schema for Expression Logical Model (ELM). For source code, we have reference implementations in production use in the Measure Authoring Tool and Bonnie testing tool. The source code for the translator from CQL to ELM is available in the Clinical Quality Framework GitHub repository . For evaluation, a JavaScript CQL interpreter is used to evaluate the measures within the Bonnie testing tool. There is also a .NET-based framework that was built as part of the Heath eDecisions initiative. It is a little outdated but provides a general framework for language processing applications for ELM.

The Clinical Reasoning Moduleprovides guidance on using CQL with FHIR in general, as well as how to use the quality-related resources (Measure, PlanDefinition, ActivityDefinition) to express, share, and evalute quality-improvement artifacts in FHIR.

CQL is currently a standalone specification. It was designed form the start to be independent of any data model. We want to make sure that we preserve that and think it’s an important part of being able to share logic and be able to keep those touch points between the data model and the terminology as independent as possible and to define clear interfaces between those touchpoints. So the different pieces of architecture can change at different rates.

We support using the generic structural definition provided by the model info and we support the use of FHIR directly within CQL. There is a FHIR 1.4 model info in the DSTU update branch of the Clinical Quality Language repository and that lets you write directly against FHIR but there is a caveat in that the FHIR structures are exposed as is. So when you have an integer element for example in a FHIR resource, the integer element itself has a “value” attribute that is the actual integer. Within FHIR that approach enables functionality like extending on primitives, so there are good reasons for the way it is built, but those are all going to be exposed directly so that if you had say a Patient in FHIR, to get to the gender, you have to say patient.gender.value. Within HL7 there’s a project to look at how to smooth out some of those rough edges so that CQL can be used even more effectively with FHIR.