How to apply continue and yield multiple values from a for-loop in scala?

I am trying to convert a module of a java program into Scala. So far, I have been able to apply Scala's functional programming paradigm and its syntax in every module I converted. But I have come across a method that does some validations, use continue and finally yield the output.
Below is the code in Java:

public boolean checkColumn(String server, String database, String schema, String table, String column) {
        boolean bServer, bDatabase, bSchema, bTable, bColumn, bRet = false;
        for (int i = 0; i < columns.length; i++) {
            if ((server == null) || (server.length() == 0)) {
                bServer = true;
            } else {
                bServer = columns[i][0].equalsIgnoreCase(server);
            }
            if (!bServer) continue;

            if ((database == null) || (database.length() == 0)) {
                bDatabase = true;
            } else {
                bDatabase = columns[i][1].equalsIgnoreCase(database);
            }
            if (!bDatabase) continue;

            if ((schema == null) || (schema.length() == 0)) {
                bSchema = true;
            } else {
                bSchema = columns[i][2].equalsIgnoreCase(schema);
            }

            if (!bSchema) continue;

            bTable = columns[i][3].equalsIgnoreCase(table);
            if (!bTable) continue;

            bColumn = columns[i][4].equalsIgnoreCase(column);
            if (!bColumn) continue;

            bRet = true;
            break;
        }
        return bRet;
    }

While I understand there is no continue in recent versions of Scala I am able to understand how to write the same code in Scala. I tried to construct a for loop as below:

val finalReturn = for {i <- 0 until columns.length
    
} yield bRet

But couldn't think of a way to form the logic of all the if-conditions & continue inside the for-loop. Could anyone let me know how can I write the same code in Scala ?

You are checking that (at least) one of the columns matches all the tests. This is the exists operation:

def checkColumn(server: String, database: String, schema: String, table: String, column: String) = {
  columns.exists { col =>
    (server.isEmpty || col(0).equalsIgnoreCase(server)) &&
    (database.isEmpty || col(1).equalsIgnoreCase(database)) &&
    (schema.isEmpty || col(2).equalsIgnoreCase(schema)) &&
    col(3).equalsIgnoreCase(table) &&
    col(4).equalsIgnoreCase(column)
  }

This will check each element in turn until one of the columns passes all the tests (which will return true) or the list is exhausted, which will return false.

There is no way to write exactly the same algorithm with a functional approach because in java code this is a very imperative style with mutability and manual control over the flow of evaluation.
So you should think what this code does, what is the logic in the code. And then implement this logic with functional primitives and patterns.

Let's go step by step

        if ((server == null) || (server.length() == 0)) {
            bServer = true;
        } else {
            bServer = columns[i][0].equalsIgnoreCase(server);
        }
        if (!bServer) continue;

it checks that if there is the defined server string - you should check that 1st field of the column
should be equal to that defined server string (i don't know what columns exactly are, but I try to guess that columns[i] is column and column[j] is a field of the column).
Otherway it calls continue and skips the iteration.
Same for other fields with the exception that table and schema doesn't being checked for emptiness.

If we looked at the end, the skipping results in "not setting bRet to true". So if all checks passed for some column, bRet would be true and the loop breaks after that.

So we can say that "if there exists at least one column that passes the checks - the result of that method should be true". Good for you that in scala you have a special method of the collection exists with exactly that logic.

Also, it is better to have a dedicated helper function to deal with nullability and emptiness.

private def isEmpty(string: String) = string == null || string.isEmpty

def checkColumn(server: String, database: String, schema: String, table: String, column: String): Boolean = {
  columns.exists { column =>
      (isEmpty(server)   || column(0).equalsIgnoreCase(server)) &&
      (isEmpty(database) || column(1).equalsIgnoreCase(database)) &&
      (isEmpty(schema)   || column(2).equalsIgnoreCase(schema)) &&
                            column(3).equalsIgnoreCase(table) &&
                            column(4).equalsIgnoreCase(column)
  }
}

In addition, I have to mention that in Scala dealing with nulls in business code is very bad practice, you should change nullable parameters to Option[String] and change a little bit expressions to deal with that type. I will show 3 ways of doing that:

def checkColumn(serverOpt: Option[String], databaseOpt: Option[String], schemaOpt: Option[String], String table, String column): Boolean =
  columns.exists { column =>
      serverOpt.filterNot(_.isEmpty).map(server => column(0).equalsIgnoreCase(server).getOrElse(true) &&
      databaseOpt.filterNot(_.isEmpty).map(column(1).equalsIgnoreCase).getOrElse(true) &&
      schemaOpt.filterNot(_.isEmpty).fold(true)(column(2).equalsIgnoreCase)&&
      column(3).equalsIgnoreCase(table) &&
      column(4).equalsIgnoreCase(column)
  }

And when you call it, you should wrap your nullable strings with Option constructor like this:

checkColumn(Option(nullableServer), Option(nullableDatabase), Option(nullableshema), table, column)

Further improvements would be to use refinement types techniques and change the type of nullable and maybe empty strings from just Option[String] to Option[NonEmptyString].