lsfusion / platform Goto Github PK

Everywhere except this place it is possible to use not only { f(a); } but simple f(a).

Needed grammar rule in LsfLogics.g is nonSemiActionOrPropertyOption.

Now property is automatically hidden when one of its arguments is NULL. It is not very convenient in some cases (for example adding object, selecting objects when there is no table, etc). Generally it's not possible to find out that out of context, so this option should be set explicitly (however maybe some heuristics may be applied first)

Probably this issue is related to #12 task.

Embed information from documentation.lsfusion.org for the rule, where the caret is at the moment, when CTRL+Q is pressed.

This will allow to upload lsFusion to central maven repositories, and get rid of repo.lsfusion.org.

At the moment, LOG-property signature is created using original property's interface classes, not using the signature of the original property. Potentially this can lead to an appearance of non-unique canonical names and, more importantly, this prevents simple migration of the LOG-properties. If we use the signature of the original property, we will move migration of LOG-properties from addLogPropertiesToMigration to setUserLoggableProperties and will add LOG-properties canonical name changes directly to storedPropertyCNChanges right there.

Now this statistics is recalculated, on one hand, that makes updating statistics platform-independent, but on another hand it may be really time-consuming. So it's better to read statistics from server (this also will make both statistics relevant to each other), but so far it is not so clear what to do with quantile statistics (top 80% distinct values).

At least for symmetry with EXPORT LIST, IMPORT ATTR.

Just like in FORM PROPERTIES operator, where property expressions and action code blocks are allowed

This option is implemented only for some of these formats.

Now they are supported only for NEW, EDIT, DELETE. It will break backward compatibility, so need to be extra causious with that.

This container attribute is really important when there are a lot of dynamic elements (with SHOW IF) in this container. This will prevent interface from leaping.

Now only CHARWIDTH and FIXEDCHARWIDTH are supported.

Just like HEADERS in EXPORT form operator.

Either throw an error if not all parameters in ORDER clause, or automatically add them to the end of that clause. It might give a little overhead, but mistakes are really too often, when using this operator.

Need to implement the possibility of hiding report columns in run-time. Should be implemented with empty space divided between remaining columns.

Now only NOT NULL statistics is supported, so if there are no null values in field f, then statistics for IN JOIN A AND A.f IS NULL will not be correct, and ANTI JOIN optimization will not work.

Usually it's not needed, but when compiler is trying to convert for example GROUP LAST to subquery with LIMIT 1, and inside there are 2 UNIONS, one of them is big temporary table with filter on non-key field, it might be a problem to not have indices on them.

Similarly to GROUP LAST compilations.

Now only filter is supported, and sometimes it is more convenient to find first object instead of all objects.
All necessary infrastructure (for example like SEEK operator) is already implemented.

Especially this feature is important for trees, where it should be implemented differently (with recursion, and that is why filter can not be used for searching)

Now there is no requestIndex support in navigator remote calls, so retryable requests are supported only in forms (what is a lot more important, but still)

Now when changes are immediately applied in database ("single applied"), all PREV values used in global events are also materialized in some temporary tables (this values will be needed when executing corresponding events). It is done for all values, even ones that will not be used later. For example if we have CONSTRAINT CHANGED(f(a)) AND g(a), it is wise to calculate PREV(f(a)) only for g(a) values. It is pretty tricky, but, it seems, not very hard to implement, at least in most evident cases.

For operators READ, EXPORT, EXTERNAL and PRINT (all that have TO clause). Do it similarly to input and import operators.

Also it can be done for EXEC operator, but it will be a little more tricky.

Plus, IMPORT operator does not support working with results as parameters, when fields identification in import is done via their order (and not names).

Now DATA, GROUP and some other operators don't allow having NULL values in their parameters.

It might be really dangerous having NULL arguments in a property, because it will immediately lead to incorrect operations with sets. For example, if we have a = DATA INTEGER (A NULL), and wanna do iteration (for example FOR) over all a(b(param) objects, we will get an exception, because property will be not null for infinite number of objects. But in certain cases it is really convenient so should be implemented.

Also NULL support may be provided for comparison operators (=, >, <, ...etc,)

Probably this issue is related to #11 task.

It seems, that existing caching algorithm can be used for that.

It was made this way to always see what the current order is. But sometimes it is not very convenient.

Now group change works like not inlined FOR, what is really inefficient when there are really a lot of objects in grid. So, group change (GroupChangeActionProperty) should be implemented using FOR operator, then it will be automatically inlined during basic compilation process.

Also add JAVA RMI as subtype in LSF integration type in this operator.

Now this block is ignored (used only when clearing session)

This attribute already exists, but it's not possible to set it (it's used only for determining default property value width)

Here is an example how this can be done :

If we have action like FOR f(a) DO g(a) <- h(a); and there is no dependency between f and g, this action will be compiled to f(a) <- h(a) WHERE f(a); but there will be no debug info for this "new action", what is very inconvinient for debug / support.

Needed for support purposes. The problem is how to identify anonymous events / actions. It seems, that the only option is using debugInfo - for example ModuleX(144:33);

staticName and staticCaption properties have fixed length string types. Replacing them with variable length string types can decrease memory usage.

So in the end there will be only 2 container types : regular and tabpane, and 2 extra attributes : split = true / false, scroll = true / false (just like it is usually done in css).

Also maybe it makes sense to make split option default (in some cases) for better user customization.

This feature is the most important for forms.

This issue is related to lsfusion/plugin-idea#4

Something like #'Test.test[A.b]'. It is really important for mechanisms that are using scripts and reflection simultaneously (grouping, scheduler etc.)

One click less when developing.

Now it's only simple id (without namespace)

Now this feature is supported only for regular (not tree) grids.

Similarly to NEW option / NEW operator. This operator / option will generate LONG number using System,iterate (recursive subquery) with guarantee that this number will be unique.

Now only CLASS properties migrate with classes. FULL properties are recalculate what can be really time consuming.

For integration with external servers via Java RMI protocol.

Swing text strings are not localized when desktop client is started with javaws. Seems that our *.properties files are not used.

The problem is that the grammar will stop being LL* in that case (however it is already non-LL* but in only couple of very simple rules). So apparently some pretty complex lookahead is needed (as far as i remember the problem is that after property draw options block there comes a property expression without any prefix)

Similarly to charWidth (numRowHeight or something like that)

Sometimes it's hard to understand exact line in code-generation-execution tasks.

In this cases we have to generate "virtual" recursive joins (just like when instead of 1<=a<=5, would have been System.iterate(a, 1, 5)). This feature will allow to disable number of heuristics with ExprIntervalJoin.

Metacode usage instruction @ could be written in several lines of code. This leads to wrong line index determination.

The issue is that different parts of these names are combined using the underscore _ (and special symbols in property (action) canonical names are replaced with the underscore as well) that can be a part of some name. This could lead to the situation when two names formed by different parts could be identical.

• VALUE properties (_OBJVALUE). Name contains form canonical name + object name
• NEWEDIT/NEW/EDIT actions (_ADDFORM/_EDITFORM). Name contains class name + form canonical name
• SECURITY properties (_POLICY). Name contains property (action) canonical name

Methods:

• VALUE: BaseLogicsModule.getObjValueProp
• NEWEDIT/NEW/EDIT: BaseLogicsModule.getAddFormAction, BaseLogicsModule.getEditFormAction
• SECURITY: BusinesLogics.setupPropertyPolicyForms