Ticket Q559655

Visible to All Users

PersistentAlias parameters

Andrew Thornton

created 11 years ago

Hi,

I am going to need to be able to have something like the concept of 'parameters' in PersistentAlias expressions. the scenario I have is this:

This is a legacy database - many 'companies' share the same tables, but there is an identifier column 'CompanyID' - string type on the table that says which 'company' the data belongs to. When the session is created, we know which 'company' we are working on, and so could for instance provide this data as a Dictionary to the session/unit of work in question. We need to be able to only return the result for the correct company.

For instance:

[PersistentAlias("[<DepartmentsXpo>][CompanyID = ?CompanyDSDepartmentsXpo && DepartmentID = ^.DepartmentID].Single()")]

public DepartmentsXpo DepartmentIDXpo

{

get { return GetValue<DepartmentsXpo>(null,"DepartmentIDXpo"); }

}

Where ?CompanyDSDepartmentsXpo is a value in the Dictionary that we know for the session. Each table in the session would have a different parameter that needed to be checked against to get the correct record for that company, as some companies share the tables!

Now, I can't see how this can be done at present so I wondered if this could be performed as an enhancement (seems simple enough, have a 'parameters' dictionary object for session, we populate that when creating the session, and then the PersistentAlias mechanism looks for a key in the dictionary matching the parameter and replaces the parameter with the value).

Alternatively I was wondering if it could be performed with current functionality through custom functions, and if so if you could point me in the right direction with an example for what I am looking to achieve?

Answers approved by DevExpress Support

DevExpress Support Team

created 11 years ago (modified 11 years ago)

Hi Andrew.
If your application works with one company at a time, you can replace this parameter with a custom function that returns a value stored in a static variable.

C#
public class CurrentCompanyIdOperator : ICustomFunctionOperator {  
    public const string OperatorName = "CurrentCompanyId";  
    public static object CurrentCompanyId { get; set; }  
    private static readonly CurrentCompanyIdOperator instance = new CurrentCompanyIdOperator();  
    public static void Register() {  
        CriteriaOperator.RegisterCustomFunction(instance);  
    }  
    public object Evaluate(params object[] operands) {  
        return CurrentCompanyId;  
    }  
    public string Name {  
        get { return OperatorName; }  
    }  
    public Type ResultType(params Type[] operands) {  
        return typeof(object);  
    }  
}

Another solution is to remove the PersistentAlias attribute from this property and perform the calculation in the property getter:

C#
public DepartmentsXpo DepartmentIDXpo {  
    get { return Session.FindObject<DepartmentsXpo>(CriteriaOperator.Parse("CompanyID = ? && DepartmentID = ?", GetCompanyDSDepartmentsXpo(), this.DepartmentID)); }  
}

If you need to associate some data with a session instance, you can use methods of the DevExpress.Xpo.Helpers.IWideDataStorage interface that the Session class implements. However, this interface is not documented and designed for internal use.

Show previous comments (19)

Andrew Thornton 11 years ago

Hi Michael,
Removing the PersistentAlias is not an option, as everything we do needs to work in XPView and Linq.
The custom function operator looks useful, but can the above example also take a parameter? I would prefer to pass 'CurrentCompanyId' as a parameter rather than having a function for each table which would be 1000+ functions.

Dennis Garavsky (DevExpress) 11 years ago

Hello Andrew,
Sure, it is possible to implement custom functions that can accept parameters. Please refer to the http://documentation.devexpress.com/#XPO/CustomDocument5206 help article for an example of this kind of function (you can also pass persistent objects as parameters).
Finally, it is possible initialize the function itself during its registration by passing required data via the constructor, e.g.: CriteriaOperator.RegisterCustomFunction(new MyGetMonthFunction(myCustomData));
I hope this helps.

Andrew Thornton 11 years ago

Dennis,
Thanks for that, I see how that works now. I don't think I can use this as it stands though - I know which 'company' the session is for when creating a session/unit of work, but would have to override the session/unit of work class to include the 'company'/ company 'dictionary' so that it could be looked up. That would be possible but the session itself is not accessible in the evaluate method, so I couldn't therefore get the company, or my 'dictionary' of values from the session.
Is there any other work-around that is possible, or have I missed something here that can still be used?

DevExpress Support Team 11 years ago

Hi Andrew.
Custom functions and criteria operators in general do not have a reference to the session, so you cannot access it from the custom function implementation. In fact, criteria operators represent an abstraction not tied to XPO; they can be evaluated on usual non-persistent objects as well. It is unlikely possible to support session-aware functions or parameters without rewriting XPO evaluators and formatters. So, a static variable holding the "current" company seems to be the only way to go.

Andrew Thornton 11 years ago

Hi Michael,
Is there any way at all to do this? As I mentioned in the first instance, a 'parameters' dictionary of key string and value object and that utilised in the persistent alias would do me, or if I could just add something like a 'tag' object to a session i.e. Session.Tag = "FCL", and be able to be provided this in the custom function I could use that to get the actual value that needs to be returned. A static variable won't do as the session belongs to a company - it is possible that we delve into data in other companies on the table to return results.

DevExpress Support Team 11 years ago

Hi Andrew.
As I already mentioned, you can associate some data with a session by casting it to the DevExpress.Xpo.Helpers.IWideDataStorage interface and using the SetWideDataItem and GetWideDataItem methods. However, it is impossible to access a session from a custom function or customize the evaluation mechanism to process persistent alias criteria with respect to the current session. And, I'm afraid this capability unlikely will be added in the near future.

Andrew Thornton 11 years ago

Michael,
So that won't do the task then. I still need to be able to do this, so back to my original question - can we have parameters for PersistentAliases that could be used something like this:
[PersistentAlias("[<DepartmentsXpo>][CompanyID = ?CompanyDSDepartmentsXpo && DepartmentID =^.DepartmentID].Single()")]
public DepartmentsXpo DepartmentIDXpo
{
get { return GetValue<DepartmentsXpo>(null,"DepartmentIDXpo");
}
Dictionary<string, object> SessionParameters= new Dictionary<string, object>()
SessionParameters.Add("CompanyDSDepartmentsXpo", "FCL");
Session mySession = new Session() { Parameters = SessionParameters }
New Sessions (or units of work) created from existing units of work would also need to copy the parameters object from the existing session.

DevExpress Support Team 11 years ago

Parameters within persistent alias expressions are not supported. It is impossible to assign these parameters with values based on the current session before evaluation without rewriting a significant part of the library.

Andrew Thornton 11 years ago

OK, but I still need some kind of solution to this.
Would it be possible to get something passed from the session to the Evaluate function. I would only need a 3 character string passed to be able to find the details I needed:
public object Evaluate(params object[] operands, object tagfromsession = null)
To explain the situation further our companies have tables of the same type but with different extensions eg:
MYTABLE_FCL
MYTABLE_GBL
MYTABLE_TST
We currently create a session per company for each database connection overriding the table names inside XPO. However this takes a lot of time, and uses a lot of memory. I want to reduce this legacy database down to:
MYTABLE (with extra 'Company' column which would have 'FCL', 'GBL', 'TST' as data when the 3 example tables above were merged into this one table.
When we create the session, we know which company to use, but we will potentially have other multi-company queries going on.
So, in my above proposal we could create the session, then:
Session.Tag = "FCL" // for instance.
Then in the Custom function we would receive 'FCL' from the created session,

DevExpress Support Team 11 years ago

If you create a database view that merges the result of selection from all these tables and exposed the source table kind as a column, you can create a single class mapped to this view with a property mapped to this column. Then, you can refer to the company via this property in your criteria. So, there is no need for such session-based parameters.

Andrew Thornton 10 years ago

Been thinking about this again.
We've started to use Linq/XPO in the system now, as XPServerCollections seemed slow in lists if persistentaliases were used, so we've been using LinqServerMode instead and providing XPQueries of the table (with persistentalias), and then using Dynamic Linq to select only the columns we wish to show in the DXGrid. This overcomes many of the problems with XPO and persistentaliases being slow and is working a treat.
Now, I could overcome my tables problem below in the code in general as we could get individual XPQueries (adding the appropriate where clause for the 'company' we created it in on creation of the XPQuery). However, persistentaliases are just so useful and we've coded all the lookup joins using them and based everything on that and they still pose a problem.
I can't see the view working - and the problem is some tables are shared across companies but most are not, but they don't necessarily have the company code in them (2 companies could share a table with a third not for instance), so I still don't know what value I need to filter on to get the right data for the company originally selected in the query.
I know, it's complicated. But if I could just get hold of a 3 char company code string that I could put somewhere in an XPO session I could make this work and reduce all the companies individual tables (with all the complexities) into a single table with a name that didn't have to change - and that would massively reduce the complexity of our XPO model where at present we dynamically build sessions for each company changing the names as we do it.
(I can do this in the legacy application written in a type of Cobol by the way, as I'm in control of the code that generates the queries and I have all the information I need to insert that extra where clause! We're now at the point where we can change the Cobol application over to this mechanism, but our new product can't handle the change!)
Andrew

DevExpress Support Team 10 years ago

If I understand your scenario correctly, you have created a single class for each group of similar tables and change class-to-table mapping by modifying class metadata at runtime (by changing the Persistent attribute applied to a class). So, you have a separate data layer and metadata dictionary for each "company". If so, you can further customize your metadata dictionaries by iterating through classes and properties and replacing PersistentAlias attributes with patched criteria expressions. As a result, each "company" data layer will have its own class copies with customized aliases, without the need for session-dependent parameters in criteria expressions.

Please let me know if this solution meets your requirements.

Andrew Thornton 10 years ago

Michael,
Finally got back to this again.
Unfortunately what we are after is to stop using the class metadata and instead have all our tables fixed, and so only have one metadata dictionary.
In XPO->Linq we can handle this by having our method that returns XPQuery for eeach table automatically append a where on the table.
However, We can't do this in persistentaliases. The closest is using a custom function, but we have to be able to know which 'company' in the function, which we can't as it would be a function of the session and absolutely cannot be a static variable.
I don't particularly want to move away from using XPO as there are a lot of good things in it, but this and the lack of being able to use OrderBy().ThenBy().FirstOrDefault() to do a join to a single row in a one to many table really are causing substantial problems as we try to move ahead using XPO.
Andrew

DevExpress Support Team 10 years ago

Thank you for your feedback, Andrew. I'm afraid we cannot offer another solution beside already suggested ones. The solution I suggested in my previous message (use separate data layers for different companies, not only separate sessions) looks flexible enough to meet your requirements. Please try it and let me know your experience.

Andrew Thornton 10 years ago

Michael,
we currently in effect do this, and this is what we are trying to get away from. We have 1000+ XPO classes, manipulating and creating one takes long enough, doing it 10 times for one customer with 10 sub companies takes far too long, and indeed uses far too much memory to keep everything open.
The ability to pass a parameter down to the evaluate method of a custom filter from the session would solve our problem and allow us to have a single (unmodified) datalayer. I request that you look seriously to see if this can be implemented.
Andrew

DevExpress Support Team 10 years ago

Thank you for the reply. As I already mentioned, it is currently impossible to access a session from the custom function. We will take your scenario into account when planning improvemnts for future versions.

Andrew Thornton 9 years ago

Any chance of getting this looked at? This is going to really start affecting us soon.

DevExpress Support Team 9 years ago

The limitations discussed in this thread are still in effect. Do you have any difficulty with solutions I suggested?

Andrew Thornton 9 years ago

Yes, as per the rest of the discussion none of it will work.
We need to be able to add a dictionary of parameters to a session and that be passed into the filter method so we can use it, and setup these parameters in the session as we need them.
Static values just won't work.

DevExpress Support Team 9 years ago

Thanks for the clarification. This functionality isn't planned for any specific release date. At present, I suggest that you use separate data layers with customized metadata dictionaries, where parameter values are embedded into PersistentAlias criteria.

Andrew Thornton 9 years ago

Therein lies the problem.

with up to 2000 tables in each datalayer it takes long enough to make 1 (changing the table names), so 10+ takes an embarrassingly long amount of time. It's already been commented on.
This is what I'm trying to get away from by reducing the tables down to a single one for all companies which always has a fixed name.
All our persistentaliases (probably 10000+) are hard coded again the classes. So what are we supposed to do - read the existing ones, automatically try to tag the extra column and filter onto it? Can't see that taking long programmatically or being flawaed at all!
It doesn't fix my other problem which is some queries we do are based on filter criteria the customer is using for that query/report. Another query/report would need to use different criteria. Add new persistentaliases on the fly when the datalayer has been generated? Can't see it.
Our table names can actually change on the fly, but we can't currently handle that in the new .Net system (can in the cobol system…)
Really need a session dictionary passing down to the filter for it's use.

DevExpress Support Team 9 years ago

Thank you for describing your difficulties. Unfortunately, we don't have another solution to offer at the moment. If your model needs to be so flexible, possibly XPO is not the right choice for this application.

PersistentAlias parameters

Answers approved by DevExpress Support

Other Answers

Recently viewed tickets