Attribute

Attributes belong to types; each attribute has its own configuration, governed by the rules of its attribute type.

If you want different access permissions for specific attributes, see Attribute permissions.

Creating an attribute

The attribute type picker is a searchable card grid covering all 25 user-facing types (six shown here), not a dropdown; types that need extra configuration (Reference, Workflow, SLA, Depreciation) open a second "Configure" step instead of creating immediately.

You can create attributes manually, or with AI: describe what you need in plain language, and it will generate attributes you can review and select to create.

"Give me the standard attributes of this type" is the pre-filled default instruction — you can replace it with your own.

We have provided attributes that are suitable for your Type. Select the attributes you want to create and leave the other ones disabled.

✓ Select All✓ Deselect All

Name	Type	Description
Warranty period	Integer	Length of the manufacturer warranty, in months
Discontinued	Boolean	Whether this product has been discontinued
Supplier	Reference	The vendor this product is sourced from

A suggestion whose name matches an attribute that already exists on the type is greyed out and can't be selected.

Changing an attribute's type

An attribute's type can be changed as long as nothing has come to depend on it yet. Open the type's schema, then either select the attribute's type in the Attribute type column or choose Change attribute type from the attribute's menu.

Changing the type takes the same two steps as creating an attribute: pick the new type, then set it up. The attribute keeps its name and its description, but not its settings — things like required, unique, character limit or options start again from the defaults for the new type, and you fill in whatever the new type needs before the change is saved.

Any type can be chosen except Workflow — a workflow attribute is created as one rather than converted into one. An inherited attribute is changed on the type that defines it.

When the type can't be changed

Where a change isn't possible the Attribute type column is greyed out, and hovering it says which of these is in the way:

Objects already hold values for it. This is the common one. The values are not converted, so the attribute has to be empty across every object of the type. Clearing the values frees it again.
It's the label attribute, a system attribute, or a workflow attribute.
It has reference properties.
Another attribute reads it — a completeness attribute that counts it, a reference attribute that cascades into it, a calculated or composite attribute whose formula uses it, or a depreciation or SLA attribute built from it. Change or remove that attribute's configuration first.

Converting the values of an attribute that objects already use isn't supported yet.

Label attribute

A label attribute is a mandatory, single-value attribute required for every type — each type must have exactly one attribute designated as the label. Whether a given attribute type can be used as a label is controlled by that attribute type's labelSupport rule (see the table below for which types currently support it).

When creating an object, a value for the label attribute must be provided. The label value serves as the object's "title," used to represent it across graphs, views, and references.

Attribute types

An attribute type defines what kind of data an attribute can hold (e.g. text, integer, date) and the expected behavior for that attribute. There are 26 user-facing types, listed below (a 27th, Rank, isn't covered here yet — see Rank).

Attribute type	Description	Rules	Configuration
Text (`STRING`)	Names, identifiers, and free text values.	Label support: yes · User-updatable: yes	Required, uniqueness, regex, character limit (max 32,000 bytes)
Rich text (`STRING`)	Markdown-formatted descriptions.	Label support: no · User-updatable: yes	Required
Date (`DATE`)	A calendar date with no time component — launch dates, end-of-life dates.	Label support: no · User-updatable: yes	Required, uniqueness
DateTime (`DATETIME`)	A date with a time component — calendar invites and similar.	Label support: no · User-updatable: yes	Required, uniqueness
Date Range (`DATE \| DATETIME`)	A start and end date on a type.	Label support: no · User-updatable: yes	Include Time (date or date + time), required
Integer (`INTEGER`)	Whole numbers — quantities, numerical identifiers, weight in grams.	Label support: yes · User-updatable: yes	Required, uniqueness, number formatting (see Number formatting)
Decimal (`DECIMAL`)	Numbers with a decimal component.	Label support: yes · User-updatable: yes	Required, uniqueness, number formatting (see Number formatting)
Boolean (`BOOLEAN`)	Yes/no values — e.g. "Dishwasher safe," "Discontinued."	Label support: no · User-updatable: yes	Required
Reference (`REFERENCE`)	A reference to another object of a type specified in the configuration. With `includeChildren` enabled (requires type inheritance), objects from both the parent type and its child types can be selected.	Label support: no · User-updatable: yes	Min/max cardinality (default 0 min, unlimited max), uniqueness, reference type, filter, include children, cascading (see Reference configuration)
User (`USER`)	A reference to a workspace user.	Label support: no · User-updatable: yes	Min/max cardinality, uniqueness, include (see User configuration)
Option (`STRING`)	One or many values from a configured, ordered set of options.	Label support: no · User-updatable: yes	Min/max cardinality, uniqueness, options list, allow unknown options
Priority (`STRING`)	A set of priorities; sort order follows priority order.	Label support: no · User-updatable: yes	Required, priorities list with color (defaults: Lowest, Low, Medium, High, Highest)
Email (`STRING`)	An email address, optionally restricted by allowed/blocked domains.	Label support: yes · User-updatable: yes	Required, uniqueness, domains (single list, allow- or block-mode)
URL (`STRING`)	A link to an external resource.	Label support: no · User-updatable: yes	Required, uniqueness
Media (`STRING`/`BINARY`)	A file of any format. Max size 200 MB; preview available for images, video, and PDF.	Label support: no · User-updatable: yes	Min/max cardinality
Completeness (`DECIMAL`)	Tracks completion progress by "listening" to whether other attributes have values.	Label support: no · User-updatable: no	Select which attributes count toward completeness (only attributes a person could otherwise fill in are eligible)
Calculated (`DECIMAL`)	Computes a result from other numeric attributes via a formula, e.g. `{{Car speed}} * {{Driving time}}`. Supports INTEGER, DECIMAL, DEPRECIATION, RATING, CALCULATED, TEXT, OPTION, DATE_RANGE, and one level of reference traversal.	Label support: no · User-updatable: no	Formula, number formatting (see Number formatting), supported functions (max, min, average, median)
Rollup (`DECIMAL`)	Totals one reference property across every object a Reference attribute points at — the yearly cost of all an application's licences, say. Calculated computes from attribute values, on the object or one reference away; Rollup reads the values stored on the references themselves, across all of them.	Label support: no · User-updatable: no	Reference attribute, reference property, calculation (see Rollup configuration), number formatting (see Number formatting)
Composite (`STRING`)	Combines values from other attributes into a string, e.g. `{{First name}} {{Last name}}`.	Label support: no · User-updatable: no	Text template, supported functions (max, min, average, median, upper/lowercase, trim, replace, date_add)
Location (`STRING`)	A location name plus latitude/longitude.	Label support: no · User-updatable: yes	Required, uniqueness
SLA (`STRING`)	A service level agreement, with goals, conditions, and breach/remaining/elapsed tracking.	Label support: no · User-updatable: no	Priority attribute, goals, conditions (start/pause/stop), display type (see SLA configuration)
Workflow (`STRING`)	Connects an object to a workflow and moves it through that workflow's stages.	Label support: no · User-updatable: yes	Workflow selection
IP address (`STRING`)	An IPv4 or IPv6 address, optionally validated against a CIDR range.	Label support: yes · User-updatable: yes	Required, uniqueness, CIDR
Sequence (`STRING`)	An auto-generated sequence value on object creation, e.g. `TECH-1`, `TECH-2`.	Label support: no · User-updatable: no	Optional prefix
Rating (`DECIMAL`)	A star rating.	Label support: no · User-updatable: yes	Required, max rating (default 5), allow half values
Depreciation (`DECIMAL`)	The calculated book value of an asset; recalculated monthly from purchase price, start date, useful life, and residual value.	Label support: no · User-updatable: no	Depreciation method, linked attributes, acting user (see Depreciation configuration)

In an activity space, Depreciation and IP address aren't offered, and a type can have at most one Workflow and one Media attribute.

Starhive also uses several system-managed attribute types (not user-configurable) for built-in fields like created/updated timestamps, the object's avatar image, and the creating user.

Configuring specific attribute types

Most attribute types are fully described by the table above. A few have configuration involved enough to need more room, covered here.

Reference configuration

Type — the type of object this attribute can point to.
Cardinality — minimum and maximum number of referenced objects; the default is no minimum and an unlimited maximum. Uncheck "Unlimited max cardinality" to cap it.
Include children — with type inheritance, lets objects of the referenced type's child types be selected too, not just the type itself.
Filter references — a StarQL expression that narrows which objects of the referenced type are offered as selectable options. Checked for valid StarQL syntax when saved, not for whether it's meaningful against the referenced type.

Cascading

Scopes this attribute's dropdown by the value already selected in another Reference attribute on the same object (the "dependent attribute") — useful when one reference should only offer choices related to another.

For each dependent attribute you add, choose a direction:

Outbound — only show objects that themselves reference the dependent attribute's selected value.
Inbound — only show objects that the dependent attribute's selected value itself references.

Ignore empty values controls what happens before the dependent attribute has a value selected: checked, the rule is skipped entirely (no filtering yet); unchecked (the default), the dropdown shows no options until a value is selected in the dependent attribute.

You can add more than one dependent attribute, but each must reference a different Type. An attribute currently used as someone else's cascading dependent can't be deleted until that cascading rule is removed first.

Number formatting

Available on Integer, Decimal, Calculated, and Rollup attributes. This only changes how the number is displayed — it doesn't affect what values are accepted or stored.

No formatting — the default; the raw number is shown.
Percentage — appends a % sign. Choose whether the stored value already represents the percentage (100 displays as 100%) or a fraction to multiply by 100 (1.0 displays as 100%).
Custom Currency — appends a currency symbol or code, chosen from a full list of ISO currency codes.
Unit — appends a unit of measurement, chosen from length, area, volume, weight, temperature, time, or energy units.

A live preview shows how a sample value will be formatted before you save.

User configuration

Beyond cardinality and uniqueness, a User attribute has an Include setting controlling which workspace users can be selected: Internal, External, or All. This option only appears on plans that include external users.

Depreciation configuration

A Depreciation attribute calculates an asset's book value automatically, based on:

Depreciation method — Straight line, or Declining balance (with an optional "Double declining balance" option that doubles the declining rate).
Linked attributes — which Integer/Decimal attribute holds the purchase price, which Date attribute holds the start date, which Integer attribute holds the useful life (entered in months), and optionally which Integer/Decimal attribute holds a residual value.
Acting user — the user whose permissions apply when the value is recalculated on a schedule.

Rollup configuration

A Rollup attribute totals one reference property across every object a Reference attribute points at, and stores the answer on the object as a number. Configure it with three choices:

Reference attribute — which Reference attribute's links to follow. It has to be one on the same type as the Rollup, since those are the links the object itself holds.
Reference property — which property on those links to read. Only properties belonging to the chosen Reference attribute are offered, so changing the attribute clears this.
Calculation — Sum, Average, Median, Lowest, Highest, or Count.

Sum, Average, Median, Lowest and Highest need numbers, so they are offered only for an Integer or Decimal property. Count asks whether a value is there at all, so it is offered for any property type, and answers with a number like the rest.

A Rollup attribute can only be created through Configure — there is nothing to total until it has been told which property and which calculation to use.

What the total counts

Every reference is read, including ones pointing at objects you cannot open yourself. What you are allowed to see is applied when the data is shown to you, not when the total is worked out.
A reference with no value for the property takes no part: it moves neither a sum nor the divisor of an average.
If no reference carries a value, the attribute is empty rather than zero — a total of nothing is not nought. Count behaves the same way.
A property holding several values on one reference contributes all of them.
The total is recalculated when a property value is edited, when a reference is added or removed, and when the property itself is deleted. It can take a moment to catch up after a change.

Once calculated, a Rollup is an ordinary number: it can be shown as a column, sorted on, filtered in StarQL, and summed in widgets, which reference property values on their own cannot.

SLA configuration

An SLA attribute tracks a time-bound goal against an object, configured in three parts:

Goals — an ordered list of rules, each with an optional StarQL scope, a calendar (24/7, 24/5, or business hours), and a time target per priority value, plus a default goal for anything not otherwise matched. Objects are checked against the list top to bottom; the first matching goal applies.
Conditions — when the SLA timer starts, pauses, and stops, based on the object being created or reaching specific workflow states.
Display type — whether the SLA shows as a due date or a running duration.

Querying attributes with StarQL

Every attribute type supports the operators explained in Which operators apply to which attribute type — what follows here is what's distinctive per type, plus real worked examples for each.

Reference

Connects an object to other objects, and is the basis for all relationship queries — including the ->/<- reference-traversal operators used throughout StarQL.

Beyond the shared operators (matched against the referenced object's label), Reference adds:

Operator	Example	Description
`->`	`Manager -> starQL(Department = Engineering)`	Outbound: filter by attributes of the referenced object(s).
`<-`	`@Objects <- starQL(Position = Manager)`	Inbound: find objects referenced by others matching a query.
`.`	`Employee.Manager.City.Country = Sweden`	Dot notation — traverses a chain of references to unlimited depth.

Functions: starQL(...) (nest a query, recursively), objectId(uuid) (match a specific referenced object by ID).

Basic reference filters:

Manager = Jack
Manager * Jack
Project * "Quarterly Review"
Manager = "Jack \"The Eagle\" Wilson"
Manager #* Jack
Manager *# son
Project is empty
Project is not empty

Outbound filtering (->):

Manager -> starQL(Department = Engineering)
Customer -> starQL(Country = "United States")
Customer -> starQL("Billing Address" * "New York")
@Objects -> starQL("Engagement type" = Project AND Title * "AI Research")

Inbound filtering (<-):

@Objects <- starQL(Order Status = Active)
@Objects <- starQL(Position = Manager AND Name * Jack)

Dot notation (unlimited depth):

Manager.Department.Location = Stockholm
Customer.Company."Main Office".Country = Sweden
Project."Client Contact"."Full Name" = "Jack \"The Eagle\" Wilson"

Nested starQL() recursion:

Manager -> starQL(Manager = Jack)
@Objects <- starQL("Engagement type" = Project AND Customer -> starQL("Billing Address" * London))

Using objectId():

Project = objectId(c7b3b1b0-3aad-46b9-a91a-460993163665)

If the attribute has Reference Properties, use Attribute -> starQL(<query on the referenced object>;<query on the reference's own properties>):

ReportsTo -> starQL(;"Since" < "2020-01-01")
Purchased -> starQL(;Rating >= 4 AND "Purchase Date" >= now(-30d))
Friends -> starQL(;"Relationship Strength" > 0.8 AND Since >= "2024-01-01")
Friends -> starQL(Country = Sweden;"Relationship Strength" > 0.8 AND Since >= "2024-01-01")

Practical tips: use -> for outbound filtering and <- for inbound; dot notation supports unlimited depth; quotes are optional for values/attribute names with no spaces, mandatory when they contain spaces.

Text

Free text — names, identifiers, titles. Supports the full shared set (equality, string matching, set, emptiness, history).

Title = Report
Name == "Annual Report"
Summary != Draft
Title !== "Final Report"
Title ~ Reprot
Summary * progress
Summary !* confidential
Name #* Ann
Title *# ment
Tagline is empty
Description is not empty
@Type = Document AND (Title * Q1 OR Summary * Finance)
@Type = Task AND Title * Review AND Summary * Approval
@Type = Project AND Name #* AI AND Description is not empty

Practical tips: use = for case-insensitive equality and == for strict equality; use ~ for flexible, typo-tolerant searches when spelling might vary; always quote text containing spaces; escape internal quotes with backslashes (e.g. "He said: \"Yes\"").

Rich text

Markdown-formatted long-form content. Restricted: only *, !*, is empty, is not empty, and history — no equality or anchored matching, since exact/prefix matching rarely makes sense against formatted prose.

"Detailed Description" * network
Notes !* draft
Summary is not empty
"Detailed Description" is empty
Title * Proposal AND "Detailed Description" * security
Content is empty AND Name is not empty
@Type = Project AND (Summary * architecture OR "Detailed Description" * architecture)

Practical tips: equality operators (=/!=) aren't supported for rich text — use */!* instead; searches are case-insensitive.

Date

A calendar date with no time component. Supports ordering and the date functions below.

Functions (all accept an offset — h, d, w, m, y): now(), startOfDay(), endOfDay(), startOfWeek(), endOfWeek(), startOfMonth(), endOfMonth(), startOfYear(), endOfYear().

"Created date" = 2025-01-01
"Created date" < 2025-01-01
"Updated date" > 2025-04-01
"Updated date" >= 2025-01-01 AND "Updated date" <= 2025-06-30
"Created date" is empty
"Completion date" is not empty
"Created date" >= now(-1m)
"Created date" >= now(-7d)
"Updated date" >= startOfWeek()
"Updated date" >= startOfWeek(-1w) AND "Updated date" <= endOfWeek(-1w)
"Created date" >= startOfDay() AND "Created date" <= endOfDay()
"Created date" >= startOfDay(-1d) AND "Created date" <= endOfDay(-1d)
"Completion date" >= startOfMonth() AND "Completion date" <= endOfMonth()
"End date" <= endOfMonth(3m)
"Created date" >= startOfYear(-1y) AND "Created date" <= endOfYear(-1y)
@Type = Project AND "Start date" > 2025-04-01 AND Title * AI
@Type = Task AND "Created date" >= now(-2w) AND Assignee = "John Doe"
@Type = Document AND "Updated date" >= startOfMonth() AND "Updated date" <= endOfMonth() AND Status = Published
@Type = Order AND "Created date" < now(-1y) AND Status = Open

Practical tips: dates must be written in YYYY-MM-DD format; negative offsets (-1m, -2w) refer to the past, positive offsets (1d, 2m) to the future.

DateTime

A date with a time component. Same functions and format as Date, plus timezone-aware literals (2025-10-14T14:55:08 local, or 2025-10-14T14:55:08Z UTC).

Also backs two system attributes with identical StarQL behavior: Created and Updated.

Created >= startOfDay(-7d)
Updated < 2025-10-14T00:00:00Z
"Start time" = 2025-10-14T14:55:08
"Meeting time" > 2025-04-01T12:00:00Z
"End time" >= now(-1d)
"Start time" >= now(-3h)
"Completion time" >= startOfDay() AND "Completion time" <= endOfDay()
"Meeting time" >= startOfDay(-1d) AND "Meeting time" <= endOfDay(-1d)
"Start time" >= startOfWeek(-1w) AND "Start time" <= endOfWeek(-1w)
"Start time" <= endOfMonth() AND "End time" >= startOfMonth()
"Start time" >= startOfMonth(1m) AND "Start time" <= endOfMonth(1m)
"End time" < now(-1y)
"Start time" is empty
"End time" is not empty
@Type = Task AND Status = Active AND "End time" < now()
@Type = Project AND Title * Review AND "Start time" >= startOfWeek() AND "Start time" <= endOfWeek()

Practical tips: always use ISO 8601 (local YYYY-MM-DDThh:mm:ss, UTC YYYY-MM-DDThh:mm:ssZ); use functions for relative filtering and combine start/end functions to define clear time windows.

Date Range

A start/end span, configured to hold either Date or DateTime values. Queried two ways: point-in-range (compare to a single date, using =/!=) or range-vs-range (compare to another range).

Functions: dateRangeIntersects(d1, d2) (any overlap), dateRangeContains(d1, d2) (fully covers), dateRangeWithin(d1, d2) (entirely inside), dateRangeEqual(d1, d2) (exact match). Range function arguments can use unparenthesized offset subfunctions like startOfDay-2w or startOfMonth+1m.

"Contract period" = 2025-02-15
"Maintenance window" = 2025-10-14T14:55:08
"Event duration" = 2025-10-14T12:55:08Z
"Contract period" != 2025-02-01
"Booking window" is empty
"Booking window" is not empty
"Contract period" = dateRangeIntersects(2025-02-01, 2025-02-28)
"Project timeline" = dateRangeWithin(startOfYear, startOfYear+1y)
"Warranty coverage" = dateRangeContains(startOfMonth, startOfMonth+1m)
"Event schedule" = dateRangeEqual(startOfWeek, startOfWeek+1w)
"Contract period" = dateRangeIntersects(startOfDay-2w, now)
"Vacation period" = dateRangeWithin(startOfMonth+1m, startOfMonth+2m)
@Type = Project AND Title * Migration AND "Project duration" = dateRangeIntersects(startOfMonth, startOfMonth+1m)

Practical tips: use point-in-range to check whether a single Date/DateTime falls inside a stored range; use range functions for span-to-span logic; subfunctions in range functions don't use parentheses (e.g. startOfDay-2w).

Integer

Whole numbers. Ordering plus equality and set membership; no string matching.

Function: countStarQL(<nested query>) — returns the count of matching objects, usable on either side of a comparison.

Quantity = 10
Count != 5
Age < 18
Age > 30
Score <= 50
Score >= 90
Attempts is empty
Attempts is not empty
Age >= 20 AND Age <= 35
Quantity > 100 AND Quantity < 500
Count > 50 AND Score is empty
Name * Laptop AND Quantity < 50
@Type = Task AND Priority > 3 AND Title * Critical
Quantity in (1, 2, 3)
Quantity not in (0, 99)
Age not in (18, 21)
(Quantity in (5, 10, 15) OR Quantity > 100) AND Status = Open
Stock < countStarQL(@Type = Order AND Status = Open)

Practical tips: use <, >, <=, >= for ranges, =/!= for exact matches; integer attributes can't use text operators like * or ~; values are numeric only, no quotes.

Decimal

Numbers with a decimal component. Ordering plus equality and set membership; no string matching.

Function: countStarQL(<nested query>).

Price = 99.99
Score != 7.5
Weight < 12.5
Weight > 100.5
Price <= 20.0
Price >= 50.0
Price in (9.99, 19.99, 29.99)
Price not in (0.00, 9999.99)
Discount is empty
Discount is not empty
@Type = Product AND Category = Electronics AND Price > 500.00
@Type = Employee AND Score > 8.5 AND Bonus is empty
Total >= 100.50 AND Total <= 500.75
Stock < countStarQL(@Type = Order AND Status = "Waiting to be shipped" AND Product = "Labubu the Monster")

Boolean

true/false values only. Restricted to =, !=, is empty, is not empty, and history — no ordering or string matching.

Active = true
Active = false
Archived = true
Archived != true
Approved = true
Approved = false
Published is empty
Published is not empty
@Type = Project AND Active = true AND Title * Migration
Active = false AND "Last login" >= now(-1m)

Practical tip: Boolean values must always be written as true or false, without quotes.

Option

One or more values from a configured, ordered list. Full shared operator set.

Plan = Premium
Plan != Basic
Plan ~ Premum
Region * East
Region #* North
Size *# XL
Plan is empty
Plan is not empty
Plan in (Basic, Premium, Enterprise)
Region not in (North, Central)
@Type = Product AND Plan = Premium AND Size = "Extra Large"
Plan = Enterprise AND Grade is empty
Plan * Pro AND Region !* West

User

References a workspace user, matched by label (name), with dedicated functions. Also backs the system attribute Creator (identical StarQL behavior).

Functions: userEmail(email), userCurrent() (the logged-in user), userId(uuid).

Creator = userCurrent()
Creator = Jack
Assignee = Jack
Reviewer = "Jack \"The Eagle\" Wilson"
Assignee #* Ja
Owner *# son
Assignee != Jack
Assignee = userEmail(jack@starhive.com)
Owner = userCurrent()
Reviewer = userId(c7b3b1b0-3aad-46b9-a91a-460993163665)
Reviewer is empty
Reviewer is not empty
@Type = Project AND Owner = userCurrent() AND Assignee = "Jack Svensson"
@Type = Document AND (Owner #* Jack OR Assignee *# Wilson)

Practical tip: userCurrent() filters dynamically for the active session user.

Email

An email address, with dedicated function support.

Function: userCurrentEmail() — the current user's own email.

"Contact email" = jack@starhive.com
"Contact email" *# starhive.com
"Contact email" #* sales
"Contact email" ~ gmal.com
"Contact email" in (jack@starhive.com, jill@starhive.com)
"Contact email" not in (noreply@starhive.com, test@starhive.com)
"Contact email" is empty
"Contact email" is not empty
"Contact email" * starhive.com AND "Contact email" !* support
"Contact email" *# .org OR "Billing email" *# .net
ContactEmail = userCurrentEmail()

Practical tip: don't quote standard emails; combine email filters with other attribute types (user, reference, date) for richer queries.

URL

A link to an external resource. Full shared operator set — no dedicated functions.

Website = https://www.starhive.com
Website != https://test.starhive.com
Website ~ starhiev.com
Website * starhive.com
Website !* staging
Website in (https://www.starhive.com, https://help.starhive.com)
Website not in (https://old.starhive.com, https://test.starhive.com)
Website #* https://docs
Website *# .pdf
Website is empty
Website is not empty
Website #* https://help.starhive.com
Website * api AND Website !* starhive.com
PublishedDate >= startOfMonth() AND Website * news
Customer -> starQL("Company website" *# .se)

Practical tips: URL comparisons are case-insensitive unless you use strict operators (==/!==); do not quote URLs.

Media

An uploaded file, matched by filename. Full shared operator set — no dedicated functions. Also backs the system attribute Avatar (the object's image), with identical behavior.

Avatar is not empty
Avatar * thumbnail
Attachment = banner.png
Attachment != logo.jpg
Attachment * report
Attachment is empty
Attachment is not empty
Attachment in (banner.png, brochure.pdf, logo.jpg)
Attachment not in (draft.docx, placeholder.jpg)
Category = Marketing AND "Media file" * promo AND "Created date" >= startOfMonth()
"Media file" * spec AND "Media file" !* old AND "Updated date" >= startOfWeek()

Practical tips: media filters are case-insensitive; quotes are required only for filenames containing spaces (e.g. "Marketing Banner.png").

Priority

An ordered set of priority levels (default: Lowest, Low, Medium, High, Highest). Full shared operator set — order/sort behavior follows the configured priority order, not alphabetically.

Priority = High
Severity * Urgent
Priority != Low
Severity is not empty
Priority is empty
Priority in (High, Medium)
Priority not in (Low, Lowest)
Priority #* P-
Priority *# -1
Priority * Urgent AND Assignee = Jack AND "Updated date" >= startOfWeek()
Priority = High AND Priority not in (Backlog) AND "Created date" >= startOfMonth()

Composite

A string built from a template combining other attributes, e.g. {{First name}} {{Last name}} (see the Configuration column above). Queried the same way as Text, against its computed value.

"Full name" = "Jack Wilson"
"Display name" == "Jack Wilson, Senior Engineer"
"Product summary" !* Draft
"Product summary" * "Premium Package"
"Display name" #* Jack AND "Display name" not in ("Jack Test", "Jack Sample")
"Product summary" ~ Summar
"Full name" = "Jack \"The Eagle\" Wilson"
@Type = Product AND "Product summary" * "Summer Sale" AND "Publication date" >= startOfMonth()
("Display name" #* Jack OR "Display name" == "Wilson, Jack") AND "Display name" !* Test

Practical tips: composite values are usually multi-word — quote values containing spaces; escape internal quotes with backslashes.

Rating

A numeric star rating. Ordering plus equality; no string matching (it's numeric, not text).

Rating = 5
Rating != 3
Rating > 4
Rating >= 4.5
Rating < 2
Rating is not empty
Rating is empty
Rating >= 4 AND UpdatedDate >= startOfMonth()
Assignee = Jack AND Rating < 3.5
@Type = Article AND Title * Guide AND Rating is not empty

Practical tip: ratings may be integers or decimals depending on configuration — use . as the decimal separator (e.g. 4.5).

Completeness

A calculated percentage tracking how many designated attributes have values. Ordering plus equality, plus countStarQL(...).

"Readiness for sale" = 100
"Readiness for sale" < 50
"Readiness for sale" not in (0, 99)
Images is empty AND "Readiness for sale" >= 75
"Readiness for sale" is empty
@Type = Project AND Status = Active AND Assignee = Jack AND "Readiness for sale" < 90
"Readiness for sale" >= 90 AND Status != Published
"Onboarding completeness" < 100
"Readiness for sale" < 80 AND countStarQL(@Type = Order AND Status = Open) > 0

Sequence

An auto-generated identifier, optionally prefixed (TECH-123). Numeric comparisons work even through a text prefix; also supports strict/non-strict equality and set membership.

ID = 123
"Product key" = TECH-123
pid == ord-0001
"Order id" != 999
Id in (100, 101)
Sequence not in (0, 99999)
pid < TECH-200
Key >= REV-99
@Type = Order AND ID > 1000 AND ID not in (TEST-1005, TEST-2004)

Practical tip: numeric operators (=, <, >, <=, >=) work even when the value includes a text prefix; no need to quote values.

Calculated

A computed decimal from a formula referencing other attributes. Ordering, equality, and countStarQL(...), same as Decimal.

"Calculated score" = 12.5
"Calculated score" not in (0.0, 9999.0)
"Profit margin" < 0.20
"Discounted price" <= 19.99
"Backlog index" > countStarQL(@Type = Order AND Priority = High AND Status = Open)
@Type = Product AND Assignee = Jack AND "Profit margin" < 0.10
"Readiness ratio" < 0.8 AND countStarQL(@Type = Order AND Status = Pending) > 0

Rollup

A computed decimal totalled from a reference property: ordering, equality, countStarQL(...) and is (not) empty.

Unlike Calculated, a Rollup does not take the was history operators — a rollup's past values aren't recorded, so there is no history to match against.

"Total licence cost" > 10000
"Total licence cost" <= 2500.50
"Open incidents" >= 5
"Average contract value" != 1.0
"Total licence cost" is not empty
@Type = Application AND "Total licence cost" > 50000 AND Owner = Jack

An attribute with no values to total is empty, so is empty finds objects whose references carry no value for the property — not objects whose values happen to add up to zero. This catches people out with Count in particular: a Count of nothing is empty too, so = 0 matches no object at all.

IP address

An IPv4 or IPv6 address. Full shared operator set for exact/substring matching, plus subnet matching.

Function: CIDR(range) — matches addresses inside a subnet, in either IPv4 or IPv6 CIDR notation. Prefer this over substring matching (*) for real network-aware checks.

"IP address" = 192.168.0.10
"Source IP" = 2001:0db8:85a3:0000:0000:8a2e:0370:7334
"IP address" != 10.0.0.5
"IP address" = CIDR(192.168.0.0/24)
"Source IP" != CIDR(2001:0db8:85a3::/48)
"IP address" in (192.168.0.10, 10.0.0.5)
"IP address" not in (127.0.0.1, ::1)
"IP address" #* 10.0
"IP address" is empty
"Remote address" is not empty
"IP address" = CIDR(10.10.0.0/16) AND Status = Active
"IP address" * 192.168.1

Practical tips: prefer CIDR() for correct subnet matching; string operators (*, #*) do substring matching, not true network-aware checks; use in/not in for small allow/deny lists of exact IPs.

Workflow

Connects an object to a workflow and tracks its current state. Full shared operator set, plus is endstate / is not endstate for final states.

Function: stateId(uuid) — match a specific workflow state by ID.

Status = Draft
"Campaign status" = "In review"
"Campaign status" not in (Test, "Demo Stage")
Status != stateId(c7b3b1b0-3aad-46b9-a91a-460993163665)
Status #* Approve
Status is endstate
"Delivery stage" is not endstate
"Campaign status" is endstate AND Assignee = Jack
"Delivery stage" is not endstate AND Assignee = Jack
Status is endstate AND Archived != true

Practical tips: quote values/attribute names that contain spaces; is endstate covers all final states when a workflow has more than one.

Location

A location label plus latitude/longitude. Full shared operator set for the label text, plus geospatial functions.

Functions: radius(lat, lng, distance) (within a distance — m, km, ft, mi), polygon({lat|lng}, {lat|lng}, ...) (inside an area — minimum 3 vertices, WGS84 decimal degrees).

Location == "New York, NY, USA"
"Store location" * "Central Station"
Location = radius(59.6493928, 17.9342942, 1km)
Location != radius(59.6493928, 17.9342942, 500m)

Location = polygon({59.6564539|17.9413554}, {59.6564539|17.9272330}, {59.6423316|17.9413554}, {59.6423316|17.9272330})
"Store location" = radius(59.6493928, 17.9342942, 5km) AND Status = Open
"Warehouse Location" != polygon({59.65|17.90}, {59.65|17.95}, {59.60|17.95}, {59.60|17.90})
Location is empty

Practical tips: radius()/polygon() operate on the stored lat/long pair — use them instead of text matching for real geospatial logic; quote attribute names or values only when they contain spaces.

Depreciation

A calculated, decreasing book value (see the Configuration column above). Ordering plus equality, same as Decimal — no string matching.

Book value = 9999.99
Book value != 7500
Book value < 12500.5
Book value > 100000
Book value <= 20
Book value >= 50000
Book value in (9999.99, 19999.99, 29999.99)
Book value not in (0, 1)
Book value is empty
Book value is not empty
@Type = Asset AND Category = IT AND Book value > 5000
Book value >= 10000 AND Book value <= 50000

SLA

A service level agreement with goals, conditions, and breach tracking. Equality, emptiness, is endstate, and history, plus dedicated timing functions.

Functions: breached(), remaining(duration), elapsed(duration).

"Time to resolution" = PAUSED
"Time to resolution" != PAUSED
"Time to resolution" is empty
"Time to resolution" is endstate
"Time to resolution" = breached()
"Time to resolution" = remaining(2h)
"Time to resolution" = elapsed(8h)

Rank

This attribute type isn't documented yet. Contact Starhive support if you'd like to know more about it.

Creating an attribute​

Changing an attribute's type​

When the type can't be changed​

Label attribute​

Attribute types​

Configuring specific attribute types​

Reference configuration​

Cascading​

Number formatting​

User configuration​

Depreciation configuration​

Rollup configuration​

What the total counts​

SLA configuration​

Querying attributes with StarQL​

Reference​

Text​

Rich text​

Date​

DateTime​

Date Range​

Integer​

Decimal​

Boolean​

Option​

User​

Email​

URL​

Media​

Priority​

Composite​

Rating​

Completeness​

Sequence​

Calculated​

Rollup​

IP address​

Workflow​

Location​

Depreciation​

SLA​

Rank​