[CONNECT C++] Using a WhereCriterion to filter out schemas

RE: [CONNECT C++] Using a WhereCriterion to filter out schemas

Yongan.Fu — Mon, 11 Nov 2019 02:27:48 GMT

Hi Bruce,

If you only want to find a specific [ECShema:ECClass] on an element, I think it doesn't need to use WhereCriterion. Below is an example which can get [BaseElementSchema:MstnVolume] on an element.

void getVolumeByEC(WCharCP unparsed)
{
	ElementId id = wcstol(unparsed, NULL, 10);
	ElementHandle eh(id, ACTIVEMODEL);
	if (!eh.IsValid())
	{
		mdlDialog_dmsgsPrint(L"invalid element handle");
		return;
	}
	DgnFileP dgnFile = ISessionMgr::GetActiveDgnFile();
	SchemaInfo schemaInfo(ECN::SchemaKey(L"BaseElementSchema", 1, 0), *dgnFile);
	DgnECManagerR ecMan = DgnECManager::GetManager();
	ECN::ECSchemaPtr pSchema = ecMan.LocateSchemaInDgnFile(schemaInfo, ECN::SchemaMatchType::SCHEMAMATCHTYPE_LatestCompatible);
	if (pSchema.IsNull())
	{
		mdlDialog_dmsgsPrint(L"Can't find BaseElementSchema schema");
		return;
	}
	ECN::ECClassCP pVolClass = pSchema->GetClassCP(L"MstnVolume");
	DgnElementECInstancePtr pInstance = ecMan.FindInstanceOnElement(eh, *pVolClass, true); //polymorphic=true is important
	if (pInstance.IsNull())
	{
		mdlDialog_dmsgsPrint(L"pInstance is null");
		return;
	}
	WString strVal;
	pInstance->GetValueAsString(strVal, L"SurfaceArea", false, 1);
	mdlDialog_dmsgsPrint(strVal.GetWCharCP());
	pInstance->GetValueAsString(strVal, L"Volume", false, 1);
	mdlDialog_dmsgsPrint(strVal.GetWCharCP());
}

An example of using WhereCriterion is as below:

WhereCriterionPtr wh = WhereCriterion::CreatePropertyComparison(propertyName, WhereCriterion::EQ, propertyValue);
myQuery->SetWhereCriterion (*wh);
myResult = DgnECManager::GetManager().FindInstances(*scope, *myQuery);

RE: [CONNECT C++] Using a WhereCriterion to filter out schemas

Jan Šlegr — Tue, 29 Oct 2019 09:37:10 GMT

Hi John,

I guess it goes a bit beyond scope of this discussion, but anyway... ;-)

[quote userid="2269" url="~/products/programming/microstation_programming/f/microstation-programming---forum/187538/connect-c-using-a-wherecriterion-to-filter-out-schemas/551175"]I don't understand the concepts or design that went into the EC query language. I find it hard to use and suspect that I am not alone.[/quote]

That's probably true. But I guess it wise to split EC query "language" and how it's implemented in API.

[quote userid="2269" url="~/products/programming/microstation_programming/f/microstation-programming---forum/187538/connect-c-using-a-wherecriterion-to-filter-out-schemas/551175"]Here are some other paths that Bentley Systems might have considered...[/quote]

That's a bit unfair in my opinion, because you want to evaluate technology invented (I guess) more than 10 years ago with pretty complex structure of features and priorities from today perspective. The then decisions can be decided not best easily in such position.

[quote userid="2269" url="~/products/programming/microstation_programming/f/microstation-programming---forum/187538/connect-c-using-a-wherecriterion-to-filter-out-schemas/551175"]If data are stored as XML fragments and schemas are XML, then why not use the XML query language XQuery?[/quote]

XQuery focuses unstructured data and it's not context-sensitive tool. Which does not mean XQuery (and XPath) is not seriously powerful tool, but ECQuery is designed to work in defined EC Schema context, which I guess can be hardly implemented into XQuery.

[quote userid="2269" url="~/products/programming/microstation_programming/f/microstation-programming---forum/187538/connect-c-using-a-wherecriterion-to-filter-out-schemas/551175"]Why not make them exactly like SQL by incorporating a domain specific language (DSL) compiler?[/quote]

ECSQL is available already in iModelJS API. It's all about steady development of the whole technology and implementing new features and tools, where some are not backward compatible (e.g. some changes in ECSchemas in PowerPlatform products and iModelJS).

[quote userid="2269" url="~/products/programming/microstation_programming/f/microstation-programming---forum/187538/connect-c-using-a-wherecriterion-to-filter-out-schemas/551175"]Why not use a LINQ data source to convert query statements into an ECQuery?[/quote]

I guess LINQ did not exist when EC technology was invented ;-)

But actually ... nobody protect you from implementing own LINQ extension to work with geometry, standard properties and also custom structures defined in EC schemas. But it sounds like long-term complex task.

[quote userid="2269" url="~/products/programming/microstation_programming/f/microstation-programming---forum/187538/connect-c-using-a-wherecriterion-to-filter-out-schemas/551175"]Instead, we have a proprietary query API that is poorly documented.[/quote]

The documentation is the biggest problem in my opinion. Even not well structured API can be used efficiently when documented properly. The opposite situation is much worse.

With regards,

Jan

RE: [CONNECT C++] Using a WhereCriterion to filter out schemas

Jon Summers — Mon, 28 Oct 2019 10:12:02 GMT

[quote userid="3014" url="~/products/programming/microstation_programming/f/microstation-programming---forum/187538/connect-c-using-a-wherecriterion-to-filter-out-schemas/551170"]Is it not possible to query base on library name alone? For example using a SQL like syntax[/quote]

If only that were so!

I don't understand the concepts or design that went into the EC query language. I find it hard to use and suspect that I am not alone. Here are some other paths that Bentley Systems might have considered...

If data are stored as XML fragments and schemas are XML, then why not use the XML query language XQuery?
Comments in the API (ECQuery struct reference) state that EC queries are analogous to SQL. That analogy is stretched rather thin: Why not make them exactly like SQL by incorporating a domain specific language (DSL) compiler?
Why not use a LINQ data source to convert query statements into an ECQuery?

Instead, we have a proprietary query API that is poorly documented. It's a combination of classes and text expressions: classes are formally defined and have the usual terse documentation; expressions are not formally defined and have no documentation. Examples are sparse.

And why are Report queries different and also undocumented?

RE: [CONNECT C++] Using a WhereCriterion to filter out schemas

Bruce Reeves SRNS — Mon, 28 Oct 2019 09:49:44 GMT

Thanks for the explanation and sample. Is not possible to query base on library name alone? For example (using a SQL like syntax):

SELECT Library:* FROM Element WHERE Library="MyLIbrary"

RE: [CONNECT C++] Using a WhereCriterion to filter out schemas

Jon Summers — Fri, 25 Oct 2019 07:18:13 GMT

[quote userid="3014" url="~/products/programming/microstation_programming/f/microstation-programming---forum/187538/connect-c-using-a-wherecriterion-to-filter-out-schemas/550765"]DgnCustomItemTypes_SRSFeature:Air__x0020__Tunnel[/quote]

Item Type Library::Class Name

Get Named Schema

Here's a method to get a named schema from the active DGN file...

bool  SchemaFactory::GetNamedSchema     (ECN::ECSchemaPtr&  pSchema, WCharCP name)
{
    DgnFileP           pDgnFile  = ISessionMgr::GetActiveDgnFile ();
    const UInt32&      VerMajor  = 1;
    const UInt32&      VerMinor  = 0;
    DgnPlatform::SchemaInfo  schemaInfo  (ECN::SchemaKey (name, VerMajor, VerMinor), *pDgnFile);
    DgnECManagerR      ecMan     = DgnPlatform::DgnECManager::GetManager ();
    pSchema   = ecMan.LocateSchemaInDgnFile (schemaInfo,
            ECN::SchemaMatchType::SCHEMAMATCHTYPE_LatestCompatible);
  return pSchema.IsValid ();
}

Create Query for Item Type

Create a query for a named Item Type class...

ECQueryPtr    ECQueryFactory::CreateQueryForItemType  (WCharCP    itemTypeName)
{
  ECQueryPtr            ecQuery;
  ItemTypeLibraryMgr    libMgr  (L"library name");
  bool                  found  { libMgr.ExistsInActiveFile () };
  if (found)
  {
    ItemTypeLibraryPtr  pLib  { libMgr.Get () };
    ItemTypeP           itemType = pLib->GetItemTypeByName(itemTypeName);
    if (nullptr == itemType)
    {
      // Unable to get Item Type  itemTypeName
    }
    else
    {
      // Note reliance on internal library and class names
      WString  internalName (ItemTypes::GetInternalName (itemType));
      ecQuery  = CreateQuery (pLib->GetInternalName (), internalName.c_str ());
    }
  }

  return ecQuery;
}

Internal Class Names

Many of the EC interfaces require a class's internal name rather than the name that you & I would expect. This article discusses internal names and how to obtain them.

RE: [CONNECT C++] Using a WhereCriterion to filter out schemas

Bruce Reeves SRNS — Thu, 24 Oct 2019 19:19:09 GMT

Yes. I have models that originated in V8 that have XAttributes added to some elements using XMLInstanceAPI::Native. That API is no longer available in CONNECT. When You examine one of these elements, in the Properties dialog they show up as ItemTypes.

Now I need to (in CONNECT) report on these XAttributes-turned-ItemTypes. I know I can scan the model, and extract ALL the element's ECClasses, but that returns not only the Item Types, but all the 'other' XAttributes (like DgnElementSchema). I'm wondering if there is a way to "filter" the ones returned to ONLY those in the schema I'm interested in.

The ClassName is reported (I assume) in the format Schema::Class. I'd like to find any/all that belong to a specific schema without having to test each Class returned to ensure it's in the schema I want.

It's my impression that when the class name is returned (e.g. DgnCustomItemTypes_SRSFeature:Air__x0020__Tunnel), that since I have a ECClass object, that the Schema and Class names are not really 'properties' of the Class, so I'm not sure how filter on them. I am able to filter them using AddSearchClass() and providing the schema and class, but I'd like to accept ALL Classes and don't want to have explicitly name each one...If I could supply '*' to get all Classes, that would be perfect, but unfortunately that doesn't work.

RE: [CONNECT C++] Using a WhereCriterion to filter out schemas

Jon Summers — Thu, 24 Oct 2019 18:52:02 GMT

[quote userid="3014" url="~/products/programming/microstation_programming/f/microstation-programming---forum/187538/connect-c-using-a-wherecriterion-tp-filter-out-schemas"]I'm looking at elements that have XAttributes on them[/quote][quote userid="3014" url="~/products/programming/microstation_programming/f/microstation-programming---forum/187538/connect-c-using-a-wherecriterion-tp-filter-out-schemas"][DgnCustomItemTypes_SRSFeature:Air__x0020__Tunnel][/quote]

Your question is about Item Types and you want to filter on the property values of an Item Type instance? Are XAttributes relevant?

Query Scope

  using namespace Bentley::DgnPlatform;
  FindInstancesScopeOption option (DgnECHostType::Element);
  //  In entire DGN file
  //scope  = FindInstancesScope::CreateScope (*Utilities::GetActiveDgnFile  (), option);
  //  In active model
  Bentley::DgnPlatform::FindInstancesScopePtr scope  = FindInstancesScope::CreateScope (
                                                         *ISessionMgr::GetActiveDgnModelP (),
                                                         option);

Compose Query

bool   ECQueryFactory::ComposeCriteria (ECQueryPtr query,
  WCharCP        property,
  WCharCP        filter)
{
  using namespace Bentley::DgnPlatform;
  bool     composed   { false };
  if (query.IsValid())
  {
    WhereExpressionPtr  expression     { WhereExpression::CreatePropertyExpression (property) };
    const bool&         IfMatch        { true };
    const bool&         CaseSensitive  { true };
    WhereCriterionPtr   where;
    WhereCriterion::StringFilterError   error;
    if (RegEx::IsRegEx (filter))
    {
      where = WhereCriterion::CreateRegexFilter (&error, *expression, filter, !CaseSensitive);
    }
    else
    {
      where = WhereCriterion::CreateStringFilter(&error, *expression, filter, IfMatch, !CaseSensitive);
    }
    }
    if (!where.IsValid () && WhereCriterion::STRING_FILTER_ERROR_InvalidSyntax == error)
    {
      // CreateStringFilter syntax error filter= filter
    }
    else
    {
      query->SetWhereCriterion (*where);
      composed = query.IsValid ();
    }
  }
  return composed;
}

Execute

DgnECInstanceIterable      ECQueryManager::FindInstances   ()
{
  return ECQueryFactory::FindInstances   (scope_,
                      query_,
                      propertyName_,
                      strFilter_.c_str (),
                      nullptr);
}

Thanks to Paul Connelly for guiding me through that jungle.