Arithmetic Operations HelixQL provides six fundamental arithmetic functions for performing basic mathematical calculations in your queries.
Available Functions ADD - Addition ADD(a, b) // Returns a + b
SUB - Subtraction SUB(a, b) // Returns a - b
MUL - Multiplication MUL(a, b) // Returns a * b
DIV - Division DIV(a, b) // Returns a / b
POW - Power POW(base, exponent) // Returns base^exponent
MOD - Modulo MOD(a, b) // Returns a % b (remainder)
When using the SDKs or curling the endpoint, the query name must match what is defined in the queries.hx file exactly.
Example 1: Basic arithmetic in property calculations Calculate discounted prices and tax for products:
QUERY CalculateProductPricing(discount_percent: F64, tax_rate: F64) => products <- N::Product ::{ name, original_price: price, discount: MUL(_::{price}, DIV(discount_percent, 100.0)), final_price: SUB(_::{price}, MUL(_::{price}, DIV(discount_percent, 100.0))), with_tax: MUL(SUB(_::{price}, MUL(_::{price}, DIV(discount_percent, 100.0))), ADD(1.0, tax_rate)) } RETURN products QUERY InsertProduct(name: String, price: F64) => product <- AddN<Product>({ name: name, price: price }) RETURN product
Here’s how to run the query using the SDKs or curl
Python
Rust
Go
TypeScript
Curl
from helix.client import Client client = Client( local = True , port = 6969 ) # Insert sample products products = [ { "name" : "Laptop" , "price" : 999.99 }, { "name" : "Mouse" , "price" : 29.99 }, { "name" : "Keyboard" , "price" : 79.99 }, ] for product in products: client.query( "InsertProduct" , product) # Calculate pricing with 15% discount and 8.5% tax result = client.query( "CalculateProductPricing" , { "discount_percent" : 15.0 , "tax_rate" : 0.085 }) print ( "Product pricing:" , result)
Example 2: Using POW for exponential calculations Calculate compound interest over time:
QUERY CalculateInvestmentGrowth(years: I32, rate: F64) => accounts <- N::Account ::{ account_id, initial_amount, final_amount: MUL(_::{initial_amount}, POW(ADD(1.0, rate), years)) } RETURN accounts QUERY CreateAccount(account_id: String, initial_amount: F64) => account <- AddN<Account>({ account_id: account_id, initial_amount: initial_amount }) RETURN account
Here’s how to run the query using the SDKs or curl
Python
Rust
Go
TypeScript
Curl
from helix.client import Client client = Client( local = True , port = 6969 ) # Create accounts accounts = [ { "account_id" : "ACC001" , "initial_amount" : 10000.0 }, { "account_id" : "ACC002" , "initial_amount" : 25000.0 }, { "account_id" : "ACC003" , "initial_amount" : 50000.0 }, ] for account in accounts: client.query( "CreateAccount" , account) # Calculate growth over 10 years at 7% annual rate result = client.query( "CalculateInvestmentGrowth" , { "years" : 10 , "rate" : 0.07 }) print ( "Investment growth:" , result)
Example 3: Using MOD for cyclic patterns Use modulo to determine recurring patterns or groupings:
QUERY CategorizeByRotation(group_size: I64) => items <- N::Item ::{ item_id, position, group: MOD(_::{position}, group_size), is_first_in_group: MOD(_::{position}, group_size)::EQ(0) } RETURN items QUERY CreateItem(item_id: String, position: I64) => item <- AddN<Item>({ item_id: item_id, position: position }) RETURN item
Here’s how to run the query using the SDKs or curl
Python
Rust
Go
TypeScript
Curl
from helix.client import Client client = Client( local = True , port = 6969 ) # Create items with positions for i in range ( 15 ): client.query( "CreateItem" , { "item_id" : f "ITEM { i :03d} " , "position" : i }) # Categorize into groups of 5 result = client.query( "CategorizeByRotation" , { "group_size" : 5 }) print ( "Categorized items:" , result)
Function Composition Arithmetic functions can be nested to create complex calculations:
// Multi-factor scoring ADD( MUL(_::{base_score}, 0.6), MUL(_::{bonus_score}, 0.4) ) // Percentage calculation MUL(DIV(_::{partial}, _::{total}), 100.0) // Exponential decay MUL(_::{initial_value}, POW(0.9, _::{time_elapsed}))
Use in Shortest Path Weights Arithmetic functions are commonly used in custom weight calculations:
// Distance-based weight with decay ::ShortestPathDijkstras<Route>( MUL(_::{distance}, POW(0.95, DIV(_::{days_old}, 30))) ) // Multi-factor routing cost ::ShortestPathDijkstras<Road>( ADD( MUL(_::{distance}, 0.7), MUL(_::{toll_cost}, 0.3) ) )
