Experimenting With The Developer Ergonomics Of Data Access Using Parallel Struct Iteration In Lucee 5.3.2.77

var userIDs = [ 1, 2, 3, 4 ];

// Map the userIDs on to user records using parallel threads. This allows us to run the
// queries in parallel rather than in series.
var users = userIDs.map(
	function( userID ) {

		return( dataAccess.getUserByID( userID ) );

	},
	true // Use parallel threads for iteration.
);

var results = runInParallel({
	taskOne: taskOneFunction,
	taskTwo: taskTwoFunction,
	taskThree: taskThreeFunction,
	taskFour: taskFourFunction
});

// Pluck items out of parallel results collection.
var taskOne = results.taskOne;
var taskTwo = results.taskTwo;
var taskThree = results.taskThree;
var taskFour = results.taskFour;

component 
	output = false
	hint = "I demonstrate various ways to use parallel Struct iteration in Lucee in order to facilitate parallel data access / query execution."
	{

	/**
	* I explore some developer ergonomics of gathering data using parallel struct
	* iteration in Lucee.
	*/
	public void function getData( required numeric userID ) {

		var user = getUserByID( userID );

		// Now that we know that we have a valid user, we can gather more detailed
		// information in parallel. The following task all depend on the user result, but
		// are independent of each other (in terms of inputs).
		// --
		// In this version, each task is defined a Function that contains the task logic.
		var chunk = runInParallel({
			subscription: function() {

				return( getSubscription( user.id ) );

			},
			teamMembers: function() {

				return( getTeamMembers( user.id ) );

			},
			projects: function() {

				return( getProjects( user.id ) );

			}
		});

		// Pluck the calculated values out of the parallel results chunk.
		var subscription = chunk.subscription;
		var teamMembers = chunk.teamMembers;
		var projects = chunk.projects;

		writeDump(
			label = "APPROACH: Using inline closures.",
			var = {
				subscription: subscription,
				teamMembers: teamMembers,
				projects: projects
			}
		);

	}


	/**
	* I explore some developer ergonomics of gathering data using parallel struct
	* iteration in Lucee.
	*/
	public void function getData2( required numeric userID ) {

		var user = getUserByID( userID );

		// Now that we know that we have a valid user, we can gather more detailed
		// information in parallel. The following task all depend on the user result, but
		// are independent of each other (in terms of inputs).
		// --
		// In this version, each task is defined an array in which the first item is the
		// task Function that contains the task logic; and, the second item is the
		// argument collection that is used to invoke the task Function.
		var chunk = runInParallel({
			subscription: [ getSubscription, [ user.id ] ],
			teamMembers: [ getTeamMembers, [ user.id ] ],
			projects: [ getProjects, [ user.id ] ]
		});

		// Pluck the calculated values out of the parallel results chunk.
		var subscription = chunk.subscription;
		var teamMembers = chunk.teamMembers;
		var projects = chunk.projects;

		writeDump(
			label = "APPROACH: Using arrays of Function / Arguments.",
			var = {
				subscription: subscription,
				teamMembers: teamMembers,
				projects: projects
			}
		);

	}


	/**
	* I explore some developer ergonomics of gathering data using parallel struct
	* iteration in Lucee.
	*/
	public void function getData3( required numeric userID ) {

		var user = getUserByID( userID );

		// Now that we know that we have a valid user, we can gather more detailed
		// information in parallel. The following task all depend on the user result, but
		// are independent of each other (in terms of inputs).
		// --
		// In this version, each task is defined as a Function that contains the task
		// logic. And, each task is invoked with the given set of arguments. In this
		// case, the function signatures must use NAMED PARAMETERS in order to pluck out
		// the correct subset of invoke arguments, since each Function receives the same
		// set of arguments.
		var chunk = runInParallelWithArgs(
			{
				userID: user.id
			},
			{
				subscription: getSubscription,
				teamMembers: getTeamMembers,
				projects: getProjects
			}
		);

		// Pluck the calculated values out of the parallel results chunk.
		var subscription = chunk.subscription;
		var teamMembers = chunk.teamMembers;
		var projects = chunk.projects;

		writeDump(
			label = "APPROACH: Using Function references and shared Arguments.",
			var = {
				subscription: subscription,
				teamMembers: teamMembers,
				projects: projects
			}
		);

	}

	// ---
	// TASK INVOCATION METHODS.
	// ---

	/**
	* I execute the given task collection in parallel threads and return the mapped
	* results. Each struct value is assumed to be a Function that contains the task
	* logic; or, an array in which the first item is the task Function and the second
	* item contains the task arguments:
	* 
	* key: function
	* key: [ function, arguments ]
	* 
	* @tasks I am the collection of tasks to run in parallel.
	* @output false
	*/
	private struct function runInParallel( required struct tasks ) {

		return( runInParallelWithArgs( {}, tasks ) );

	}


	/**
	* I execute the given task collection in parallel threads and return the mapped
	* results. Each struct value is assumed to be a Function that contains the task
	* logic; or, an array in which the first item is the task Function and the second
	* item contains the task arguments:
	* 
	* key: function
	* key: [ function, arguments ]
	* 
	* If the value is a plain Function, it is invoked with the given set of task
	* arguments.
	* 
	* @taskArguments I am the argument collection to pass to each task operation.
	* @tasks I am the collection of tasks to run in parallel.
	* @output false
	*/
	private struct function runInParallelWithArgs(
		required struct taskArguments,
		required struct tasks
		) {

		var results = tasks.map(
			function( taskName, taskOperation ) {

				// If the operation is defined as an Array, then the first item is the
				// task operation and the second item is the task arguments:
				// --
				// value: [ taskOperation, taskArguments ]
				// --
				// This approach overrides the taskArguments provided by the parent
				// function, passing in the arguments provided by the array.
				if ( isArray( taskOperation ) ) {

					var invokeArguments = taskOperation[ 2 ];
					var invokeOperation = taskOperation[ 1 ];

				// If the operation is defined as a Function, then we're going to use the
				// taskArguments provided by the parent function.
				} else {

					var invokeArguments = taskArguments;
					var invokeOperation = taskOperation;

				}

				return( invokeOperation( argumentCollection = invokeArguments ) );

			},
			true // Perform struct mapping in parallel threads.
		);

		// TIP FROM BRAD WOOD
		// ==================
		// If you ever want to constraint the number of parallel threads to match the
		// number of cores that your server has, you can introspect the runtime to get
		// this value; then, you can pass this value in as a third argument to your
		// parallel method (default parallel thread count is 20).
		// ---
		// createObject( "java", "java.lang.Runtime" ).getRuntime().availableProcessors()

		return( results );

	}

	// ---
	// DEMO DATA METHODS.
	// ---

	public array function getProjects( required numeric userID ) {

		return([
			{ id: 15, userID: userID, name: "My project!" },
			{ id: 749, userID: userID, name: "My other project!" }
		]);

	}

	public struct function getUserByID( required numeric userID ) {

		return({ id: userID, name: "Kim Smith" });

	}

	public struct function getSubscription( required numeric userID ) {

		return({ id: 1001, planType: "Pro", price: 9.99, userID: userID });

	}

	public array function getTeamMembers( required numeric userID ) {

		return([
			{ memberID: 99, leadID: userID },
			{ memberID: 205, leadID: userID }
		]);

	}

}