support Select with WhereAny condition

Signed-off-by: Yan Zhu <hackzhuyan@gmail.com>

Author: halfcrazy

README.md

@@ -233,6 +233,101 @@ They can also be created based on a list of Conditions:
         }).Delete()
     ovs.Transact(ops...)
 
+### Querying with Select
+
+The `Select` operation is used to build an OVSDB `select` query. Unlike the `List` operation, which returns results directly from the cache, `Select` only generates an `ovsdb.Operation`. You must pass this operation to `Transact` to execute it against the database, and then use a helper function like `GetSelectResults` to parse the reply.
+
+The core workflow is: `WhereXxx(...).Select() -> Transact(...) -> GetSelectResults(...)`
+
+#### Selecting Rows
+
+**Select All Rows from a Table:**
+
+To select all rows from a table, you can call `Where()` with a zero-value instance of the model struct (e.g., `&MyLogicalSwitch{}`). This sets the table context for the `Select` operation without adding any conditions.
+
+```go
+// var ovs client.Client
+// var ctx context.Context
+// var allSwitches []MyLogicalSwitch
+// 1. Generate Op: Where(&MyLogicalSwitch{}) specifies the table
+selectOp, err := ovs.Where(&MyLogicalSwitch{}).Select()
+// ...
+// 2. Execute transaction
+reply, err := ovs.Transact(ctx, selectOp...)
+// ...
+// 3. Parse result
+err = ovs.GetSelectResults(reply, &allSwitches)
+// ...
+```
+
+**Select by Index:**
+
+You can also use `Where()` with a model instance that has indexed fields populated. This will create a condition to find matching rows based on the first available index.
+
+```go
+// Assuming "Name" is an indexed field
+ls := &MyLogicalSwitch{Name: "switch1"}
+var results []MyLogicalSwitch
+// 1. Generate Op
+selectOp, err := ovs.Where(ls).Select()
+// ...
+// 2. Transact and parse
+reply, err := ovs.Transact(ctx, selectOp...)
+err = ovs.GetSelectResults(reply, &results)
+// ...
+```
+
+**Select with Conditions (AND):**
+
+Use `WhereAll()` to set the table context and one or more filter conditions. All conditions are combined with an `AND` operator.
+
+```go
+var specificSwitches []MyLogicalSwitch
+lsModel := &MyLogicalSwitch{}
+cond1 := model.Condition{Field: &lsModel.Name, Function: ovsdb.ConditionEqual, Value: "sw1"}
+cond2 := model.Condition{Field: &lsModel.Ports, Function: ovsdb.ConditionIncludes, Value: "some_port_uuid"}
+
+// 1. Generate Op: Use WhereAll for one or more AND conditions
+selectOp, err := ovs.WhereAll(lsModel, cond1, cond2).Select()
+// ...
+// 2. Transact and parse
+reply, err := ovs.Transact(ctx, selectOp...)
+err = ovs.GetSelectResults(reply, &specificSwitches)
+// ...
+```
+
+**Select with Conditions (OR):**
+
+Use `WhereAny()` to set the table context and one or more filter conditions. All conditions are combined with an `OR` operator.
+
+```go
+var specificSwitches []MyLogicalSwitch
+lsModel := &MyLogicalSwitch{}
+cond1 := model.Condition{Field: &lsModel.Name, Function: ovsdb.ConditionEqual, Value: "sw1"}
+cond2 := model.Condition{Field: &lsModel.Ports, Function: ovsdb.ConditionIncludes, Value: "some_port_uuid"}
+
+// 1. Generate Op: Use WhereAny for one or more AND conditions
+selectOp, err := ovs.WhereAny(lsModel, cond1, cond2).Select()
+// ...
+// 2. Transact and parse
+reply, err := ovs.Transact(ctx, selectOp...)
+err = ovs.GetSelectResults(reply, &specificSwitches)
+// ...
+```
+
+#### Selecting Specific Columns
+
+By default, `Select` queries all columns of a table. You can pass column names to the `Select` method to retrieve only specific columns. The `_uuid` column is always included in the result.
+
+```go
+// Selects only the "name" and "ports" columns
+selectOp, err := ovs.Where(&MyLogicalSwitch{Name: "sw1"}).Select("name", "ports")
+```
+
+#### Limitations
+
+-   `WhereCache(...).Select()`: **Not supported**. Cache-based predicate functions cannot be translated into OVSDB query conditions. Calling `Select` after `WhereCache` will return an error.
+
 ## Monitor for updates
 
 You can also register a notification handler to get notified every time an element is added, deleted or updated from the database.

client/api.go

@@ -617,19 +617,17 @@ func newConditionalAPI(cache *cache.TableCache, cond Conditional, logger *logr.L
 // Select generates the OVSDB select operation based on the conditions previously set
 // using Where, WhereAll, or WhereCache.
 // It determines the target table and columns from the condition context.
-// Returns an error if called after WhereAny, as OVSDB select only supports
-// a single set of ANDed conditions.
+// Returns an error if called after WhereCache.
+// If used with WhereAny, it will generate one select operation per condition.
 func (a api) Select(columns ...string) ([]ovsdb.Operation, error) {
 	// Select now requires a condition to be set via WhereXxx first.
 	if a.cond == nil {
-		return nil, fmt.Errorf("Select called on API with no condition set (use Where or WhereAll first)")
+		return nil, fmt.Errorf("Select called on API with no condition set (use Where, WhereAll, or WhereAny first)")
 	}
 
 	if _, ok := a.cond.(*predicateConditional); ok {
 		// Prevent select based on cache predicate function which cannot be translated
 		return nil, fmt.Errorf("cannot generate OVSDB select operation from a cache predicate function (WhereCache)")
-	} else if a.cond.IsDisjunction() { // Check if condition is OR (from WhereAny)
-		return nil, fmt.Errorf("Select cannot be used with WhereAny conditions, use separate Select calls or Transact")
 	}
 
 	// Get table name directly from the condition
@@ -644,22 +642,6 @@ func (a api) Select(columns ...string) ([]ovsdb.Operation, error) {
 		return nil, fmt.Errorf("failed to generate conditions for select: %w", err)
 	}
 
-	// OVSDB Select only supports one set of conditions (implicitly ANDed).
-	// The IsDisjunction check above handles WhereAny. This check is a safeguard
-	// in case a future Conditional type could generate multiple lists without
-	// being a disjunction.
-	if len(ovsdbConditionsList) > 1 {
-		return nil, fmt.Errorf("internal error: condition generated multiple condition lists unexpectedly for Select")
-	}
-
-	var whereClause []ovsdb.Condition
-	if len(ovsdbConditionsList) == 1 {
-		whereClause = ovsdbConditionsList[0]
-	} else {
-		// No conditions specified or generated, select all rows
-		whereClause = []ovsdb.Condition{}
-	}
-
 	// Determine columns to select
 	if a.cache == nil || !a.cache.DatabaseModel().Valid() {
 		return nil, fmt.Errorf("database model/schema info not available for select")
@@ -699,12 +681,22 @@ func (a api) Select(columns ...string) ([]ovsdb.Operation, error) {
 		}
 	}
 
-	selectOp := ovsdb.Operation{
-		Op:      ovsdb.OperationSelect,
-		Table:   tableName,
-		Where:   whereClause,
-		Columns: columnsToSelect,
+	// If no conditions were generated (e.g. select all), create a single
+	// operation with an empty where clause which selects all rows.
+	if len(ovsdbConditionsList) == 0 {
+		ovsdbConditionsList = append(ovsdbConditionsList, []ovsdb.Condition{})
 	}
 
-	return []ovsdb.Operation{selectOp}, nil
+	operations := make([]ovsdb.Operation, 0, len(ovsdbConditionsList))
+	for _, whereClause := range ovsdbConditionsList {
+		selectOp := ovsdb.Operation{
+			Op:      ovsdb.OperationSelect,
+			Table:   tableName,
+			Where:   whereClause,
+			Columns: columnsToSelect,
+		}
+		operations = append(operations, selectOp)
+	}
+
+	return operations, nil
 }

client/client.go

@@ -65,9 +65,9 @@ type Client interface {
 	NewMonitor(...MonitorOption) *Monitor
 	CurrentEndpoint() string
 	API
-	// ParseSelectResult parses the result of a Select operation into the target slice.
+	// GetSelectResults parses the result of Select operations into the target slice.
 	// targetSlice must be a non-nil pointer to a slice of models (structs or pointers to structs).
-	ParseSelectResult(result ovsdb.OperationResult, targetSlice interface{}) error
+	GetSelectResults(results []ovsdb.OperationResult, targetSlice interface{}) error
 }
 
 type bufferedUpdate struct {
@@ -1475,14 +1475,21 @@ func (o *ovsdbClient) WhereCache(predicate any) ConditionalAPI {
 	return o.primaryDB().api.WhereCache(predicate)
 }
 
-// ParseSelectResult parses the result of a Select operation into the target slice.
-func (o *ovsdbClient) ParseSelectResult(result ovsdb.OperationResult, targetSlice interface{}) error {
-	if result.Error != "" {
-		details := ""
-		if result.Details != "" {
-			details = ": " + result.Details
+// GetSelectResults parses the result of a Select operation into the target slice.
+func (o *ovsdbClient) GetSelectResults(results []ovsdb.OperationResult, targetSlice interface{}) error {
+	var rows []ovsdb.Row
+	for _, result := range results {
+		rows = append(rows, result.Rows...)
+	}
+	exist := make(map[ovsdb.UUID]struct{})
+	var uniqRows []ovsdb.Row
+	for _, row := range rows {
+		uuid := row["_uuid"].(ovsdb.UUID)
+		if _, ok := exist[uuid]; ok {
+			continue
 		}
-		return fmt.Errorf("select operation failed: %s%s", result.Error, details)
+		uniqRows = append(uniqRows, row)
+		exist[uuid] = struct{}{}
 	}
 
 	_, err := validateParseTargetSlice(targetSlice)
@@ -1498,10 +1505,10 @@ func (o *ovsdbClient) ParseSelectResult(result ovsdb.OperationResult, targetSlic
 		return fmt.Errorf("database model for '%s' is not valid (client may not be connected or schema mismatch)", o.primaryDBName)
 	}
 
-	return mapSelectResultToSlice(result.Rows, targetSlice, db.model)
+	return mapSelectResultToSlice(uniqRows, targetSlice, db.model)
 }
 
-// validateParseTargetSlice validates the 'targetSlice' argument for ParseSelectResult.
+// validateParseTargetSlice validates the 'targetSlice' argument for GetSelectResults.
 // It ensures 'targetSlice' is a non-nil pointer to a slice whose elements are
 // structs or pointers to structs that implement model.Model.
 // It returns the underlying struct type of the slice elements.