​

Building Queries

Once you’ve connected your database, Infactory helps you create queries that answer specific questions about your data. These queries form the foundation of your AI-powered data experiences.

​

Understanding the Build Page

The Build page is your command center for creating and managing queries.

The Build page consists of these main components:

• Query List: All your queries, both automatically generated and custom
• Query Editor: Where you view and modify query code
• Query Parameters: Configure slots (parameters) for your query
• Results Panel: See the structured data results when you test your query
• Assistant Panel: Get AI-powered help with query creation and editing

​

Auto-Generated Queries

After connecting a data source, Infactory automatically generates approximately 12 queries based on your data schema.

​

Types of Auto-Generated Queries

Depending on your data, Infactory may generate queries such as:

​

Testing Auto-Generated Queries

To test an auto-generated query:

​

Understanding Slots (Query Parameters)

“Slots” are what make Infactory queries so powerful. They are placeholders in queries that can be filled with different values, making a single query capable of answering many related questions.

​

How Slots Work

For example, a query with the question pattern “What is the average by ?” has two slots:

• The metric slot can be filled with any numeric field (height, weight, sales, etc.)
• The category slot can be filled with any categorical field (position, team, region, etc.)

This means one query template can answer hundreds of specific questions like:

• “What is the average height by position?”
• “What is the average sales by region?”
• “What is the average order value by product category?”

​

Slot Types

Infactory supports various slot types:

​

Creating Custom Queries

While auto-generated queries cover many common scenarios, you may want to create custom queries for specific needs.

​

Using the Infactory Assistant

The easiest way to create a new query is with the Infactory Assistant:

​

Manual Query Creation

For advanced users comfortable with Python, you can create queries manually:

def run(parameters, context):
    # Step 1: Load data from your connected data source
    df = context.load_table("your_table_name")
    
    # Step 2: Process the data based on parameters
    result = df.groupby(parameters["category"]).mean(parameters["metric"])
    
    # Step 3: Return the results
    return result

​

Query Code Structure

Understanding the structure of query code helps you create and customize queries effectively.

​

Basic Structure

All Infactory queries follow this basic structure:

def run(parameters, context):
    # Step 1: Load data
    df = context.load_table("your_table_name")
    
    # Step 2: Process data
    result = process_data(df, parameters)
    
    # Step 3: Return results
    return result

• parameters: Contains the values for your query slots
• context: Provides access to your data sources and helper functions
• return value: The structured data result of your query

​

Common Data Processing Patterns

Here are some common patterns used in query code:

# Filter data based on a condition
filtered_df = df[df["column_name"] > parameters["threshold"]]

​

Advanced Query Features

Infactory’s query system provides several advanced features for complex scenarios.

​

Working with Multiple Data Sources

Queries can combine data from multiple tables or collections:

def run(parameters, context):
    # Load data from different tables
    players = context.load_table("players")
    teams = context.load_table("teams")
    stats = context.load_table("statistics")
    
    # Join the tables
    players_teams = players.merge(teams, on="team_id")
    all_data = players_teams.merge(stats, on="player_id")
    
    # Process the joined data
    result = all_data.groupby("team_name").mean("points_per_game")
    
    return result

​

Creating Calculated Fields

You can create new fields based on calculations:

def run(parameters, context):
    players = context.load_table("players")
    
    # Create a new field
    players["bmi"] = players["weight"] / ((players["height"] / 100) ** 2)
    
    # Use the calculated field
    result = players.groupby("position").mean("bmi")
    
    return result

​

Advanced Filtering

Combine multiple filters for complex query conditions:

def run(parameters, context):
    players = context.load_table("players")
    
    # Multiple filter conditions
    filtered = players[
        (players["height"] > parameters["min_height"]) &
        (players["weight"] < parameters["max_weight"]) &
        (players["position"].isin(parameters["positions"]))
    ]
    
    return filtered

​

Result Formatting

You can format and structure your query results for optimal use:

def run(parameters, context):
    data = context.load_table("sales")
    
    # Process data
    results = data.groupby("region").sum("revenue")
    
    # Format results
    formatted_results = {
        "labels": results["region"].tolist(),
        "values": results["revenue"].tolist(),
        "total": results["revenue"].sum(),
        "average": results["revenue"].mean()
    }
    
    return formatted_results

​

Query Performance Optimization

For larger datasets, consider these optimization techniques:

​

Filter Early

Apply filters as early as possible to reduce the amount of data being processed:

# Good: Filter first, then process
df = context.load_table("large_table")
filtered = df[df["region"] == parameters["region"]]
result = filtered.groupby("category").mean("value")

# Less efficient: Process everything, then filter
df = context.load_table("large_table")
grouped = df.groupby("category").mean("value")
result = grouped[grouped.index == parameters["category"]]

​

Select Only Needed Columns

Only load the columns you need for your query:

# Efficient: Only load required columns
df = context.load_table("large_table", columns=["id", "category", "value"])

# Less efficient: Load all columns
df = context.load_table("large_table")

​

Use Efficient Operations

Prefer vectorized operations over loops:

# Good: Vectorized operation
df["doubled"] = df["value"] * 2

# Less efficient: Loop
for i in range(len(df)):
    df.at[i, "doubled"] = df.at[i, "value"] * 2

​

Debugging Queries

When your query doesn’t work as expected, these debugging strategies can help:

def run(parameters, context):
    df = context.load_table("my_table")
    print(f"Loaded data shape: {df.shape}")
    
    filtered = df[df["category"] == parameters["category"]]
    print(f"Filtered data shape: {filtered.shape}")
    
    result = filtered.groupby("subcategory").mean("value")
    print(f"Result: {result}")
    
    return result

def run(parameters, context):
    print(f"Parameters received: {parameters}")
    
    # Rest of your query code

def run(parameters, context):
    df = context.load_table("my_table")
    print(f"Sample data:\n{df.head()}")
    
    # Check for specific values
    if "important_column" in df.columns:
        print(f"Unique values in important_column: {df['important_column'].unique()}")
    
    # Rest of your query code

def run(parameters, context):
    df = context.load_table("my_table")
    
    # Instead of complex query, try basic operations first
    basic_result = df.groupby("category").count()
    print(f"Basic groupby result: {basic_result}")
    
    # Then add complexity incrementally
    # ...

​

Best Practices

​

Next Steps

After building your queries, the next step is to deploy them as API endpoints. Continue to Deploying APIs to learn how to make your queries available for applications to use.