Construct Query Algorithm

[TelloViz]

Construct Query Algorithm

A Step-by-Step Breakdown

1. Initialize an empty dictionary:

   • Start by creating an empty dictionary called query_parts. This will be used to store pieces of the query you're building.

2. Process each item in the input list:

   • Go through every item in the queryData list. Each item is expected to be a tuple with three elements: category, subcategory, and target.

3. Extract category, subcategory, and target:

   • For each item in the list:
     • Assign the first element of the tuple to category.
     • Assign the second element to subcategory.
     • Assign the third element to target.

4. Organize data by category:

   • Check if the current category is already present in the query_parts dictionary.
     • If it’s not, create a new list for this category.

5. Build the query string for each item:

   • If the subcategory is provided (i.e., it’s not empty):
     • Create a string in the format category.subcategory:target (e.g., set.name:Myset) and add it to the list for that category.
   • If no subcategory is provided:
     • Create a simpler string in the format category:target (e.g., type:Creature) and add it to the list for that category.

6. Prepare to build the final query:

   • Create an empty list called final_query_parts. This will hold the final pieces of the query that will be combined into the full query string.

7. Combine query parts by category:

   • For each category in query_parts:
     • If the category has more than one query string:
       • Combine the strings with " OR " between them and enclose the group in parentheses.
     • If the category only has one query string:
       • Just add it as-is to final_query_parts.

8. Construct the final query:

   • Once all query parts are processed, join them together with " AND " between each part to form the full query string.

9. Return the final query string:

   • The result is the final query that combines all conditions with "AND" and "OR" as needed.

---

Function Design Document: constructQuery

Function Name:

constructQuery

---

Brief Description:

The construct_query function constructs a query string suitable for use in an API call. The resulting string will follow the format necessary for querying, such as:

"q='(set.name:<set-name>) AND (name:<card-name>) AND (types:<type-name> OR types:<type-name>)'"

---

Assumptions:

• The function assumes that all query parameters passed to it are valid and recognized by the API.
• It is expected that the queryData will follow the defined structure.

---

Parameters:

• Type: List of Tuples

List[Tuple(category: String, subcategory: String, target: String)]

---

Structure of Each Tuple:

Each tuple in the list may contain any of the following formats:

( 'set', 'name', '<set-name>' )

( '', 'name', '<card-name>' )

( 'types', '', '<type-name>' )

( 'types', '', '<type-name>' )

---

Return Type:

• Type: String
  The function returns a string containing the constructed query in the following format:

"q='(set.name:<set-name>) AND (name:<card-name>) AND  (types:<type-name> OR types:<type-name>)'"

---

Notes:

• The 'OR' is necessary for multiple type filters, allowing the construction of logical OR conditions for types.
• The 'AND' is necessary to group the parameters logically, resulting in a structure like:
• This algorithm will also make allowing users to select multiple sets (or multiple of any filter) trivial.
  • It is built into the algorithm and all that would need to be updated is the front-end.

( (set) AND (card) AND (type1 OR type2 OR typeN) )

• where the number of types can range from 0 to N.

And later on could easily be:

( (set1 OR set2 OR setN ) AND (card) AND (type1 OR type2 OR typeM) )

• where the number of sets can range from 0 to N.
• where the number of types can range from 0 to M.

---

Exceptions:

• Currently, the function does not raise any exceptions.

---

Example Usage:

Here’s how to use the constructQuery function in pseudocode:

queryData = [ ('set', 'name', 'Base'), ('', 'name', 'charmander'), ('types', '', 'Grass'), ('types', '', 'Fire') ]

myQuery = constructQuery(queryData)

---

Pseudo Code of Function:

Notes: The name and purpose of each variable used in the pseudo code is described after the pseudo code.

FUNCTION constructQuery( queryData : List[Tuples] )
    # Initialize an empty dictionary to hold query parts
    INITIALIZE query_parts AS EMPTY DICTIONARY
    
    # Loop through each item in the queryData list
    FOR EACH item IN queryData DO
        # Extract the category, subcategory, and target from the item
        SET category TO item[0]
        SET subcategory TO item[1]
        SET target TO item[2]

        # If the category is not already in query_parts, create a new list for it
        IF category NOT IN query_parts THEN
            INITIALIZE query_parts[category] AS EMPTY LIST
        END IF

        # Check if subcategory is provided
        IF subcategory IS NOT EMPTY THEN
            # Create a string in the format "category.subcategory:target" and add it to the list
            APPEND-ELEMENT(query_parts[category], category + "." + subcategory + ":" + target)
        ELSE
            # Create a string in the format "category:target" and add it to the list
            APPEND-ELEMENT(query_parts[category], category + ":" + target)
        END IF
    END FOR

    # Prepare to construct the final query
    INITIALIZE final_query_parts AS EMPTY LIST
    
    # Loop through each list of items in query_parts
    FOR EACH items IN query_parts DO
        # If there is more than one item in the list
        IF LENGTH(items) > 1 THEN
            # Combine the items with "OR" and add parentheses around them
            APPEND-ELEMENT(final_query_parts, "(" + JOIN(items, " OR ") + ")")
        ELSE
            # If there's only one item, add it directly
            APPEND-ELEMENT(final_query_parts, items[0])
        END IF
    END FOR

    # Join all parts with "AND" to form the final query string
    RETURN JOIN(final_query_parts, " AND ")
END FUNCTION

---

Variables used in Pseudo and their intents

queryData: The data structure passed to us containing the data in a 'List of Tuples'
List[ Tuple( Category, Subcategory, Target ) ]

• Category: The primary grouping for the query (e.g., "set" or "types").
• Subcategory: An optional secondary grouping for the query (e.g., "name"). This can be empty.
• Target: The specific value associated with the category and subcategory (e.g., "Myset", "Grass").

query_parts: A dictionary that the function will use to store all of the separate elements of the final query. Each key represents a unique category, and the value is a list of formatted query strings related to that category.

item: A single tuple from queryData, representing a single query component consisting of Category, Subcategory, and Target.

category: A variable that stores the first element of the current tuple from queryData, representing the main category of the query.

subcategory: A variable that stores the second element of the current tuple from queryData, representing the subcategory of the query. It can be empty.

target: A variable that stores the third element of the current tuple from queryData, representing the specific target value.

final_query_parts: A list that accumulates the final parts of the constructed query. It will contain either formatted strings representing groups of query items combined with "OR" or individual query items.

items: A variable that represents the list of formatted query strings associated with a specific category in query_parts during the final construction phase of the query.