appian and maps

RE: appian and maps

dgomezcid — Mon, 03 Oct 2022 10:23:46 GMT

Hi there again,

So I finally created a recursive method that prevents duplicates from being added to the map. It is a bit ugly, but it does the trick.

Thank you for all your help

David

RE: appian and maps

dgomezcid — Tue, 20 Sep 2022 22:21:02 GMT

Hello Stewart,

Your approach sounds good!

If a new dependency is going to cause a circular dependency, it should be discarded. Therefore:

a->a - should that end up as just a ? Yes
a->b->a - should that end up as a->b ? or b->a ? a->b
a->b->c->b - should that end up as a->b->c ? Yes
a->b->c->a - should that end up as a->b->c ? or b->c->a ? a->b->c
a->b->c->x->x - should that end up as a->b->c->x ? Yes

Thank you

RE: appian and maps

Stewart Burchell — Tue, 20 Sep 2022 21:09:37 GMT

The approach I would take would be to break the problem down into some smaller problems:

generate the output a per my original example
remove duplicate nodes from the output
remove the circular dependencies

So I need to know the "rules" that you want to apply for step 3. What should the result be for the following examples?

a->a - should that end up as just a ?
a->b->a - should that end up as a->b ? or b->a ?
a->b->c->b - should that end up as a->b->c ?
a->b->c->a - should that end up as a->b->c ? or b->c->a ?
a->b->c->x->x - should that end up as a->b->c->x ?

On easy to implement option might be just to remove the duplicate items, but that might not be the right answer, so it depends on what rules you want to apply as to what the solution needs to look like.

RE: appian and maps

dgomezcid — Tue, 20 Sep 2022 16:58:30 GMT

Hi there again,

Duplicate node: yes, figured that one out already, thank you!

Circular dependency: Ideally, the verification would be done while creating the map from the list, eliminating this way, the need to reprocess it later on. The initial list is arbitrary, I do not have control over the different items might contain. However, I do have to guarantee that no circular dependencies are created.

A circula dependency could potentially happen at any moment ( [->] translates to "depends on")

a->a

a->b->a

a->b->c->b

a->b->c->a

a->b->c->x->x

...

I am not sure at this time what would be more efficient, preventing such an scenario or extending the current code as you mentioned.

Thank you again

RE: appian and maps

ujjwalr0002 — Tue, 20 Sep 2022 16:58:17 GMT

Stewart Burchell I was thinking can we create a temporary CDT which can have a column of multiple type.

RE: appian and maps

Stewart Burchell — Tue, 20 Sep 2022 16:40:04 GMT

Well that's a totally different ball game...

Circular Dependency: firstly, are you asking how to prevent such a scenario being written to this data structure in the first place, or how to extend the current code to take your data structure generate something that does not have such a dependency (and if so, what are the rules that govern this?)

Duplicate Node: I already showed you how to removed duplicates for the output by using fn!union() so you can use that on your input before you process it

RE: appian and maps

dgomezcid — Tue, 20 Sep 2022 16:34:27 GMT

Hello Stewart,

Thank you so much for your quick replay, I very much appreciate it.

How would you prevent adding circular and duplicated tasks?

{
{
taskId: 100,
dependsOnTaskId: 101
},
{
taskId: 100,
dependsOnTaskId: 121
},

{
taskId: 101,
dependsOnTaskId: 123
},

{
taskId: 103,
dependsOnTaskId: 0
},

{
taskId: 123,
dependsOnTaskId: 100
},

/*duplicated node*/

{
taskId: 123,
dependsOnTaskId: 100
}
}

100 -> 101 -> 123 -> 100 (circular dependency)

Thank you again for your time!

RE: appian and maps

Stewart Burchell — Tue, 20 Sep 2022 15:23:56 GMT

Hi - this seems to work:

a!localVariables(
  local!sourceData: {
    a!map(taskId: 100, dependsOnTaskId: 101),
    a!map(taskId: 100, dependsOnTaskId: 121),
    a!map(taskId: 101, dependsOnTaskId: 123),
    a!map(taskId: 103, dependsOnTaskId: 0),
    a!map(taskId: 123, dependsOnTaskId: 5)
  },
  local!result: a!forEach(
    items: local!sourceData.taskId,
    expression: a!map(
      taskId: fv!item,
      dependencies: local!sourceData.dependsOnTaskId[wherecontains(fv!item, local!sourceData.taskId)]
    )
  ),
  fn!union(local!result,local!result)
)

...with output of:

I did notice that your expected output value for 'dependancies' for taskId 103 is blank, whereas your source data has a value of 0. I am assuming you wanted 0. If not then you'll have to add a specific clause to output 'null' when the actual value is 0.

If you want an explanation as to what's going on I'm happy to provide you with one.