SPTAG | distributed approximate nearest neighborhood search | Machine Learning library

An EXISTS subquery is there to qualify which rows you want to select. It does not add rows or columns to the result set.

Reduce the list of columns in the SELECT clause of your sub query to any single one of the columns, or even a literal - such as SELECT 1 - and you will get your duplicates:

(First a note: Most of your readers will not have a clue what a PLC is. I'm guessing it's a Programmable Logic Controller. You might want to call that out, and roughly describe it in your question)

I'm leaving my original answer at the bottom of this - it still make good points about the programming in your question. The new parts (immediately below) are less about programming and more about design.

Also note that I haven't done anything like this (controls systems, PLCs and batch systems) in a little over 20 years and of those three areas, I have the least experience in batch systems. By the way, does your PLC support a language like IEC-61131-3/SFC? The 1131-3 Sequential Function Chart language was really developed to program batch and recipe systems.

In order to allow "The operator can Stop, Pause, Go to Next and Previous step by pressing respective buttons", you will likely have to radically restructure your program. You will also want to make everything asynchronous.

Ten years ago, I would have recommended doing the control part in a dedicated thread and having the UI communicate through a queue or some other asynchronous mechanism. I suspect that you can do this now by making just about everything awaitable.

You are probably want to make your recipe steps much richer. As I understand it, your recipe steps now consist of a set of tag/setpoint pairs and then a step-completed condition that consists of a single tag, a setpoint and a comparison operation.

You might want to consider this in your recipe steps:

• The concept of time (how long to hold a particular state)
• That a step may not only involved changing setpoints, but also starting/stopping or opening/closing things
• That the end of a step may be complicated (time, measurement, or measurements)
• That measurement "equality" many not be good enough. It's not uncommon for a measured quantity to overshoot the setpoint by 20-25% and then ring a bit before settling down. You may want to consider having "equality" optionally mean "within N% of setpoint for T seconds".

In addition, to get your pause/stop/next/prev behavior, you are not going to just loop over your steps. Instead, create a class that maintains an ordered collection of steps and accepts commands to pause/stop/next/prev. Then implement a state machine that involves the steps, the commands, and a set of intermediate states.

What I mean by "intermediate states" is that a command to, for example, pause a step will not immediately cause the step to pause. Instead, it will go through a "waiting to pause" state and then get to the paused state. Make your commands awaitable. When the UI calls await Pause(), the task it returns will eventually complete when the state enters the Paused state. The same thing for stopped, next and previous.

A variation on the little loop that I showed in the original answer:

To include multiple nested sub-properties, write the Include() twice, like this

You can use a combination of Enumerable.SelectMany and Enumerable.Prepend.

The following code will project out each step's nodes into a collection of FlatRecepi1 and then prepend the FlatRecepi1 corresponding to the step at the start of the collection. Finally, the SelectMany flattens this "collection of collections" into a single list. This should give you the same ordering as the current code.