Roles, permissions and query data access reference
Gluesync controls access at two levels. A role sets what a user can do anywhere in the Control Plane, Query Studio included. Query data access policies then narrow which schemas and tables a user can query on each connection, and which masked PII columns the user can reveal. This page lists each role and permission, every setting of Settings → Query data access, and how Core Hub applies them.
|
How-to guides
For step-by-step walkthroughs tested on a running Gluesync, see Manage users, groups, and roles and Query data with Query Studio. Creating accounts, password rules and sessions are covered in Users and roles. |
Roles
Gluesync has a fixed set of roles. You cannot create a role or change what a role can do. To give one person less access to data than their role allows, use a query data access policy.
Each user has exactly one role. Users and roles apply to the whole Gluesync instance: there is no per-pipeline role.
| Role | Meant for | How it is assigned |
|---|---|---|
The few people who manage users, user groups, query data access and platform-wide security settings. |
The default |
|
People who build and run pipelines. |
Settings → Users & access → Users, the REST API, or an OIDC role mapping. |
|
Operators who start, pause and tune entities but must not create or delete anything. |
The REST API only. |
|
People who only look at pipelines and run read-only queries. |
Settings → Users & access → Users, the REST API, or an OIDC role mapping. |
|
Gluesync modules such as Chronos, not people. |
Gluesync assigns it to its modules. |
Super Admin
Full access to everything. A Super Admin is the only role that can create user groups, edit query data access policies, see the Query Studio audit log, and manage backups to Gluesync Connect.
Query data access rules never apply to a Super Admin: a Super Admin can query every table and reveal every masked PII value, whatever the policies say.
Manager
Can do everything a Super Admin can do except manage user groups, query data access policies, the Query Studio audit log and backups. A Manager can create, change and delete Manager and Viewer accounts only.
In Query Studio a Manager can run SQL that changes data, save and share queries, and reveal masked PII where a PII unmask grant allows it.
Monitor
Can see everything, start, pause and stop entities, edit the settings of an existing entity, and run, enable and disable existing schedules. A Monitor cannot create or delete pipelines, entities, connections or schedules, cannot change global settings, and cannot run user-defined functions.
In Query Studio a Monitor can run read-only SQL and save personal queries, but cannot run SQL that changes data, share saved queries or reveal masked PII.
Permissions by role
A permission is fixed by the role. Core Hub checks every permission on the server, whatever the UI shows, and refuses a request the role does not allow.
Query Studio permissions
These permissions decide what a user can do with SQL. Query data access policies then decide which tables those statements may touch.
| Permission | Viewer | Monitor | Manager | Super Admin | External Module |
|---|---|---|---|---|---|
Yes |
Yes |
Yes |
Yes |
Yes |
|
No |
No |
Yes |
Yes |
Yes |
|
No |
Yes |
Yes |
Yes |
No |
|
No |
No |
Yes |
Yes |
No |
|
No |
No |
With a grant |
Yes |
No |
|
No |
No |
No |
Yes |
No |
|
No |
No |
No |
Yes |
No |
|
No |
No |
No |
Yes |
No |
Run read-only SQL
Every role can run read-only statements in Query Studio, in Query Studio AI and through the AI and MCP query tools. The statements still go through the query data access policy of the user, so a read-only query can be refused with Access denied to <schema>.<table>.
Run SQL that changes data
Running Query Studio in writable mode, editing a result cell, or importing data needs a role that may write: Manager, Super Admin or External Module. For a Viewer or a Monitor, Core Hub refuses the statement with Role VIEWER does not have canRunQueryWritable permission (or MONITOR). Switching the writable toggle on does not change this: the role decides, not the toggle.
The tables a writable statement changes, such as the target of an INSERT, UPDATE, MERGE or TRUNCATE, are checked against the query data access policy like the tables it reads.
Save queries
Monitor, Manager and Super Admin can create, change and delete their own saved queries, and see the queries their team has shared. A Viewer cannot save queries and sees no shared ones.
Reveal masked PII
When PII masking is on, Query Studio results show masked values for columns classified as PII. The PII visible switch reveals them, and Core Hub decides cell by cell:
-
a Super Admin always sees the real values;
-
a Manager sees the real values only in columns covered by one of their PII unmask grants on that connection;
-
a Monitor, a Viewer and an External Module never see them, even with a grant.
Unmasking is opt-in: without a grant a Manager sees masked values everywhere, even on an installation that has no query data access policy at all. See PII discovery and masking for how columns are classified and how masking is switched on.
See the Query Studio audit log
Only a Super Admin can read the Query Studio audit log of executed statements.
Manage query data access policies
Only a Super Admin sees Settings → Query data access and the shield icon Manage query data access in Query Studio and AI Studio, and only a Super Admin can read or change policies and templates through the REST API.
Manage user groups
Only a Super Admin can create, rename and delete user groups and change their members, in Settings → Users & access → User groups. A user group has no permissions of its own: it exists so that one query data access policy can apply to several users. Deleting a group deletes its policies.
Control Plane permissions
| Permission | Viewer | Monitor | Manager | Super Admin |
|---|---|---|---|---|
See pipelines, entities, status, metrics and notifications |
Yes |
Yes |
Yes |
Yes |
Start, pause and stop entities, and run snapshots |
No |
Yes |
Yes |
Yes |
Edit the settings of an existing entity |
No |
Yes |
Yes |
Yes |
Run now, enable and disable existing schedules |
No |
Yes |
Yes |
Yes |
Create and delete pipelines and entities, publish function collections, run user-defined functions |
No |
No |
Yes |
Yes |
Create, edit and delete connections, schedules and Courier endpoints |
No |
No |
Yes |
Yes |
Change global settings |
No |
No |
Yes |
Yes |
Create, change and delete user accounts |
No |
No |
Manager and Viewer accounts only |
Any role |
Create, edit, save, fork and refresh visualizations |
No |
Yes |
Yes |
Yes |
Publish a visualization on a public URL |
No |
No |
Yes |
Yes |
Act on database health from Gluesync Connect (scan, remedy, apply index) |
No |
No |
Yes |
Yes |
Manage backups to Gluesync Connect, the Visualize feature switch |
No |
No |
No |
Yes |
A Personal API Token never has more access than its user’s role. Its permission and agent scopes can narrow it further, for example to the agents a BI tool may query: see Personal API Tokens and scopes.
Query data access
A query data access policy limits what one user, or every member of one user group, can query on one connection. It holds a mode, schema and table rules and PII unmask grants. Open it from Settings → Query data access, or from the shield icon Manage query data access in Query Studio or AI Studio. Only a Super Admin can open it.
Policies apply wherever Gluesync runs SQL or reads tables on behalf of a user:
-
Query Studio: the schema and table browser, read-only and writable statements, and saved queries;
-
Query Studio AI, AI Studio chat tools and the MCP query tools;
-
the embedded JDBC gateway;
-
Courier SQL endpoints, which run as their caller;
-
data comparison runs;
-
Visualize and the Enterprise brain, which show only the tables the user may see.
A policy limits queries only. It does not hide pipelines or entities in the Control Plane.
|
Available from Gluesync 2.3.3.0: each setting of the Query data access panel has a ? link that opens its section on this page. |
Applies to
Choose User to edit the policy of one user, or User group to edit the policy shared by every member of a group. The switch is shown only when you can manage user groups.
User
The user whose own policy you edit. When the user belongs to user groups, a note lists the groups and shows the policy actually enforced for the user on the selected connection. See How the enforced policy is worked out.
User group
The user group whose policy you edit. Every member receives it, unless the member has a policy of their own on the same connection. Create groups in Settings → Users & access → User groups.
Connection
The connection the policy applies to. A policy always belongs to one user or group and one connection: to restrict several connections, save a policy on each.
Query Studio finds the policy through the agent being queried: it takes the connection that the agent uses. A connection marked (not used by any agent) is never reached by a query, so a policy saved on it has no effect until an agent uses that connection.
Template
A template is a stored policy matrix, per connection, that you can copy onto a user or a group. The list holds two built-in templates and the templates you saved:
-
VIEWER (read-only default): Restricted mode with one rule that allows every schema and table (
*,*). Edit the matrix to narrow it. -
MANAGER (read-only default): Open mode with one PII unmask grant for the whole connection.
The built-in matrices are stored for a connection the first time you select it here. Below the list, the panel shows what the selected template holds on the selected connection.
Templates are named after roles but are not tied to them: a new Manager does not receive the MANAGER template. A template applies only when you apply it.
Apply template
Copies the selected template onto the selected user or group. Applying replaces the user’s or group’s policies with the template’s on every connection: their policies on connections the template does not cover are deleted. Later changes to the template do not reach users it was applied to; apply it again.
When the template has nothing stored yet, Template … has no matrix stored yet appears: edit the matrix and use Save as template first.
Save as template
Saves the matrix you are editing, for the selected connection, as a template. Enter a Template name and select Save. The name is stored in lower case, with letters, digits, - and _ kept and any other run of characters turned into one -: Analyst read only becomes analyst-read-only. Saving under an existing name of yours replaces that template’s matrix for this connection. You cannot save under VIEWER or MANAGER from the panel: they stay read-only defaults.
Connection mode
- Open
-
Every table is allowed except those a Deny rule matches. A user with no policy on a connection is treated as Open.
- Restricted
-
Only tables that an Allow rule matches, and no Deny rule matches, are allowed. Everything else is denied.
Schema and table rules
Each rule allows or denies a schema, or one table in a schema. Select Add rule to add one and the trash icon to remove it. Matching ignores letter case.
A Deny rule always wins over an Allow rule.
Schema
The schema the rule applies to. * matches every schema. A rule with an empty schema is not saved: type * to mean every schema.
PII unmask grants
Each grant lets the user reveal masked PII in the columns it covers on this connection. Select Add unmask grant to add one. Leave Schema, Table or Column empty to cover all of them: a grant with all three empty covers the whole connection. Unlike rules, * is not a wildcard here; it matches only a schema, table or column literally named *.
A grant has an effect only for a Manager: a Super Admin always sees real values, and a Monitor or a Viewer never does. See Reveal masked PII.
Save policy
Stores the mode, rules and grants for the selected user or group on the selected connection, replacing what was stored before. Data access policy saved confirms it. The policy applies to the next query: there is nothing to restart.
How the enforced policy is worked out
For a user querying an agent, Core Hub takes the agent’s connection and resolves the policy like this:
-
If the user has a policy of their own on that connection, it is the one enforced. Their groups' policies on that connection are ignored.
-
Otherwise the policies of all the user’s groups on that connection combine:
-
the mode is Open when any group’s policy is Open, and Restricted only when all of them are;
-
the rules and the PII unmask grants are the union of all the groups' rules and grants, and a Deny rule from any group still wins.
-
-
If neither the user nor any of their groups has a policy on that connection, nothing is restricted there, and nothing can be unmasked.
The note under User shows this result as Effective saved policy on this connection and names the groups that contributed.
How Core Hub checks a statement
-
No policy anywhere. Until the first policy is saved on the installation, nothing is checked.
-
Super Admin. Never checked.
-
Every table a statement touches is checked, including the tables a writable statement changes. One denied table refuses the whole statement with Access denied to <schema>.<table>.
-
Unqualified table names. When the policy can deny something (it is Restricted, or has a Deny rule), a table named without its schema is refused with qualify '<table>' with its schema, because the database resolves it through a search path Gluesync does not know. Under an Open policy without Deny rules it runs.
-
Statements Gluesync cannot parse are refused under a policy that can deny something, and run otherwise.
-
System catalogs (
information_schema,pg_catalog,sys,mysql,performance_schema,sqlite_master,sqlite_temp_master) are always allowed. -
Unresolved callers. Once a policy exists, a query is refused when the agent has no connection, or when the caller does not match a Gluesync user.
Deleting a user, a user group or a connection deletes the policies stored for it.
REST API
The same policies are available under /query-studio/data-access, for Super Admins only:
| Request | What it does |
|---|---|
|
Lists the user’s policies on every connection. |
|
Reads, saves or deletes the user’s policy on one connection. Deleting it leaves the connection to the user’s groups. |
|
The policy enforced for the user on the connection, as described in How the enforced policy is worked out. |
|
Applies a template, body |
|
The same for a user group. |
|
Lists the templates, reads one, and saves one template’s matrix on a connection. |
The body of a PUT is the policy:
{
"mode": "RESTRICTED",
"rules": [
{ "schemaName": "shop", "tableName": "orders", "effect": "ALLOW" },
{ "schemaName": "shop", "tableName": "customers", "effect": "DENY" }
],
"piiUnmaskGrants": [
{ "schemaName": "shop", "tableName": "orders", "columnName": "email" }
]
}
Any other role receives 403 Forbidden. See Core Hub REST API for authentication.