1h 5m read

Singdata Enterprise Data Governance: RBAC and Row-Level Security in Practice

A practitioner's guide to routing access requirements between RBAC and row-level security in Singdata Lakehouse, testing effective permissions, and building audit evidence that proves controls operated.

Singdata Enterprise Data Governance: RBAC and Row-Level Security in Practice

Most access reviews fail for a structural reason rather than a careless one: role-based access control (RBAC) and row-level security (RLS) are configured in different places, by different people, and reviewed on different schedules. The role list looks tidy, the row filter is bound to the table, and nobody has run the query that would show what a specific user actually sees. That gap is where audit findings live.

This guide is a practitioner's reference for data platform owners, security architects, and audit liaisons running Singdata Lakehouse. It does four things: it gives you a decision rule for routing each access requirement to a role or a row filter; it sets out the documented Singdata mechanics that determine effective access; it specifies test patterns that produce evidence rather than an impression; and it closes with an acceptance checklist that separates a passing configuration review from a passing audit.

Where Singdata's published documentation does not settle a behavior, this guide marks it as a validation item instead of filling the gap with an assumption. A documented gap is not evidence that a control is missing — only that the published pages do not describe it, and that you should confirm the behavior in a trial before relying on it.

What RBAC and Row-Level Security Each Control

The two mechanisms operate at different scopes, and conflating them is the root of most review errors. RBAC decides whether a principal may touch an object at all. Row filtering decides which rows come back from an object the principal can already reach.

Roles as permission carriers in Singdata Lakehouse

Singdata documents roles as carriers of permissions, with privileges as the smallest access unit — querying a table, inserting data, managing a schema, using a virtual cluster (Access Control Overview). A user can hold multiple roles and direct grants simultaneously, and the permission scope for any operation is the sum of both. Users do not declare a current role; the authentication system traverses everything the user owns. The same page states that Singdata does not directly support the DAC model of secondary authorization based on object ownership and recommends RBAC for centralized management. Preset roles cannot have their permissions modified or be deleted, though they can be granted directly (Roles). The documentation also describes no super-user concept.

Row filters as query-time predicates

A row filter binds a BOOLEAN-returning function to a table; the engine applies it automatically, so only rows where the function returns true are visible to the current operation. Singdata states this takes full effect for SELECT, UPDATE, DELETE, and aggregate queries, and that filter functions can read current_user() and current_roles() to filter by login identity (Row Filter). Two conditions matter for planning. First, the page labels the feature an invite-only preview, so confirm production availability with support before you rely on it as a control. Second, schema-qualify filter function names, because unqualified names resolve against the current schema and can fail with function not found.

Where the two mechanisms overlap and where they do not

The boundary is one-directional in both directions. A correctly scoped row filter cannot rescue an over-broad grant, because it does not restrict which objects are reachable — only which rows return from objects already reachable. Conversely, a tight grant does not restrict which rows come back: Singdata documents that with no row-level permission configured, users can view all data in the table (Row-Level Permissions). Table access without a row rule is full access. That asymmetry is the premise the decision rule below rests on.

The Decision Rule: Role or Row Filter

Route every access requirement through the same question before you configure anything: does this requirement change which objects or operations a principal can reach, or which rows of an already-reachable object are visible? The answer determines the mechanism, and the ordering matters because a row filter applied to an object nobody can reach protects nothing.

A routing procedure for access requirements

Work each requirement through three questions in order.

  1. Does it change reachability? If the requirement is about which tables, schemas, virtual clusters, or operations a principal can use, it belongs to a role.

  2. Does it change row visibility within a reachable object? If the principal already has access and the requirement narrows which records they see, it belongs to a row filter.

  3. Does it change both? Then it needs both, configured and reviewed together — a grant that establishes reachability and a filter that bounds the rows.

One corollary catches a common design shortcut: a requirement expressed as a row condition but implemented as a separate object — a per-region table, a per-region view — is a role decision in disguise. It multiplies objects and grants instead of filtering one table, and it moves the control from a query predicate into an object-provisioning process that is harder to review.

Ambiguous case: "can see EU rows" versus "can run export"

Take the two requirements separately. "Can see EU rows" is a row-scope requirement: the principal can already reach the table, and the requirement narrows which records return, so it belongs in a row filter. "Can run export" is an operation on an object, so it belongs in a role.

The interaction is where reviews go wrong. A principal holding export permission and an EU row filter should be able to export EU rows only — provided the export path honors the filter. That is a validation item, not an assumption: run the export as the restricted principal and inspect the output. And note where the protection ends. If the export writes to a destination outside the filtered object, the row filter's protection stops at the query boundary; what happens to the file afterward is governed by controls on the destination, not by the filter.

Ambiguous case: column sensitivity and masking

Dynamic masking is the third mechanism you will meet, and it is neither a role nor a row filter. It operates at column level and complements row filtering: the row filter decides which records return, the masking policy decides what a sensitive column shows for the querying user.

Singdata documents a specific grant requirement that trips up implementations: querying a table with masking policies requires SELECT on the table and USE FUNCTION on every required masking function (Dynamic Mask). If the user lacks USE FUNCTION on any required function, the entire query fails with a NoPermission error rather than returning NULL or a masked value. The page also notes that USE FUNCTION only allows the masking function to execute; it does not grant access to the original value. Plan masking grants as part of the same change as the SELECT grant, or queries break at cutover.

Effective Permissions When Roles Combine

The question that decides whether your review is meaningful is not what each role grants, but what a given user can do once every role and direct grant is combined. Singdata documents the combination rule for permissions. It does not document the equivalent rule for multiple row scopes, and that difference changes how you review.

Documented union semantics for roles and grants

Singdata states that when a user has multiple roles, their permissions are the union of those role permissions, and that a user can be directly granted multiple permissions and multiple roles at the same time — the scope for any operation is the sum of direct grants and role permissions (Access Control Overview). The Roles page confirms the same union rule. Because users do not declare a current role and the system traverses all owned permissions, the practical consequence is direct: a review organized role by role is insufficient. Review effective grants per user, computed from every source, or you will miss a combined scope that no single role owner approved.

The undocumented case: multiple row scopes

Singdata's row-level permission documentation notes that a user can be covered by multiple permission rules and advises verifying that the combined data scope meets expectations (Row-Level Permissions). It does not specify whether the combination is a union, an intersection, or an error. Do not guess, and do not assume the union rule that governs roles carries over to row rules.

Resolve it with a test. Create a test user covered by two rules with non-overlapping scopes, query the table as that user, and record the returned rows alongside the rule configuration. The result determines whether row filters can safely be layered: if the combination is a union, layering two narrow rules widens access rather than narrowing it, and every rule addition becomes a review event.

Ownership as an access path

Ownership is a second access path that grant reviews routinely miss. Singdata documents that the role owning an object can perform all operations on it, including modification and deletion, and that transferring object ownership is not currently supported (Access Control Overview).

The consequence is that object creation is itself an access grant. A developer who created a table during a project keeps full control of it afterward, and no documented handover step removes that control. Treat ownership accumulation as a review target distinct from role membership: inventory objects by creator, compare that list against current job responsibilities, and route production creation through service identities or named owners rather than individual accounts.

Proving RLS Works: Test Patterns

A configuration screenshot proves that someone intended a control. A test proves the control operated. The pattern below produces evidence an auditor can test, and it is the same pattern whether you are validating a row filter, a masking policy, or an agent's delegated scope.

The restricted-versus-authorized comparison

Run the same statement as two principals: one restricted by the row rule and one authorized to see the full set. Before either run, write down the expected result — which rows must be present and which must be absent — so the outcome is a comparison against a prediction rather than a judgment after the fact.

Cover SELECT, UPDATE, DELETE, and an aggregate, because Singdata documents filter application across all of them (Row Filter). Add a negative control: a principal with no row rule, who should see the full set. Without that control you cannot show the filter is what changed the result rather than a data condition or a query difference.

Testing the paths the documentation leaves open

Several behaviors are not settled by the published pages. Each becomes a trial activity with a recorded result rather than an assumption carried into production.

  • Direct SQL versus Agent queries. Row-level filtering is described in the context of Agent-generated queries (Row-Level Permissions). Run the same statement by hand, including through a direct connection that bypasses any dashboard, and compare.

  • Multiple row rules. Query as a user covered by two rules with non-overlapping scopes and record the combination.

  • View versus base table. Query the base table directly as the restricted principal to see whether the filter follows.

  • Export path. Export as the restricted principal and inspect the file.

Record the observed behavior, the configuration in force, and the date for each.

Reading the access record

For every test statement, capture four fields: the principal, the statement text, the rows returned, and the corresponding access record entry. The result tells you what happened; the record tells you who did it and when, which is what makes the result attributable.

A correct result with no attributable record is not audit evidence. It is an observation that cannot be tied to a principal, a time, or a control. Singdata's security documentation lists operation logs and job history as the audit surface (Lakehouse Security); confirm in your trial that the statements you run appear there with enough detail to reconstruct the request, and export the record alongside the result set.

Audit Evidence: What Counts and What Does Not

The distinction that decides an access-control finding is whether an artefact demonstrates that a control operated during the period, or merely describes what someone configured. The AICPA's 2017 Trust Services Criteria supply the criteria; GDPR Article 32(1)(d) supplies a parallel requirement for a process of regularly testing, assessing, and evaluating the effectiveness of security measures (EUR-Lex, Art. 32). Neither is satisfied by a screenshot.

Evidence that demonstrates the control operated

These artefacts show operation, and each carries a date and an attributable owner:

  • The complete account and grant export for each in-scope system, with the export date and who exported it, so the auditor can see the population was not filtered.

  • Per-statement access records for the restricted and authorized test runs, paired with the pre-declared expected results.

  • A change ticket for each grant or revocation, with its completion date — a decision to remove access that never happened is still an open finding.

  • The review worksheet with a decision for every account and a named reviewer.

  • For a Type 2 period, the same set for every review in the audit window, because the control is tested across the period rather than at one point in time.

Evidence that describes intent but does not prove operation

Each of the following fails the operation test on its own:

  • A role design document. It states what access should look like, not what any user held or what any query returned.

  • A screenshot of a configured policy. It proves a configuration existed at a moment; it does not prove the engine applied it, and it cannot show a bypass path.

  • A vendor's SOC 2 report. It covers the vendor's controls over a defined observation period and says nothing about your configuration or your tenant.

  • A bulk "approved" review with no per-account decision. It shows the review was signed, not that each account was examined — which is precisely the failure a per-account decision column exists to prevent.

Mapping evidence to CC6 and Article 32

The mapping is straightforward once the artefacts are separated. CC6.1 addresses logical access security software, infrastructure, and architectures over protected information assets; the access model design and the effective-permission export speak to it. CC6.2 covers registering and authorizing users before credentials are issued and removing credentials when access is no longer authorized; the account export joined against HR status and the change tickets speak to it. CC6.3 covers authorizing, modifying, or removing access based on roles and responsibilities, with consideration of least privilege and segregation of duties; the per-account review decisions speak to it (AICPA TSP 100).

Article 32(1)(d) requires a process for regularly testing, assessing, and evaluating the effectiveness of the measures — which is what the restricted-versus-authorized runs and their retained records demonstrate. Keep the mapping at the level the standards state: the criteria ask whether controls are designed, operated, and tested, not which product feature implements them.

AI Agents, Generated SQL, and Delegated Scope

An agent that queries the lakehouse inherits every access weakness of the identity it runs under. Singdata documents that Agent-generated queries automatically include row filter conditions; the published pages do not settle how the agent's own identity is established, so treat that as a validation item.

How agent identity should be established

Register one stable identity per agent, with a named human owner and a backup, a recorded business purpose, and short-lived credentials plus scoped entitlements per run rather than a new identity per task. The audit record should show both the agent identity and the acting user. Singdata's retrieved pages describe filtered agent queries but not the credential model behind them; confirm identity, lifetime and revocation with support before production.

Delegated scope: intersection, not union

A delegated request should reach the intersection of the agent's registered scope and the acting user's scope — never the union, and never the agent's own standing role. Union semantics would let an agent exceed its owner's access: a user restricted to EU rows could obtain US rows through an agent holding a broader grant. Sub-delegation must be a strict subset of the parent grant, validated by the delegation service rather than trusted from the requesting agent's claim.

Reviewing agent scope

Two criteria are measurable in a trial: mean time to revoke or disable an agent identity including token invalidation, and the percentage of production agents with a unique identity and a named accountable owner. A permission review organized by human users will not surface standing agent credentials, so inventory agent identities separately and flag any credential that outlives a working day.

Failure Modes That Pass Configuration Review but Fail Audit

Each failure below passes a configuration review because the configuration is valid. What is wrong is the entitlement, and only a test that exercises the access path exposes it.

Effective-permission union hides an over-grant

Singdata documents that a user's permission scope is the sum of direct grants and role permissions, and that multiple roles combine as a union. A review organized per role can therefore miss a user who accumulates reach through several roles plus direct grants. The test is an effective-permission export per user, not a role-by-role read.

Ownership confers access that no grant shows

The role that owns an object can perform all operations on it, and Singdata documents that transferring object ownership is not currently supported. A table created by a developer account therefore carries access that no grant review will list. Route creation through service identities or named owners, and record who created each object in a production schema.

RLS on a view but not the base table

A filter bound to a view does not protect the base table if that table is independently reachable. Query the base table directly as the restricted principal and compare. Singdata documents row filters bound to tables; whether a view and its base table are both filtered is a validation item, not a settled behavior.

Stale grants and orphaned principals

A grant that outlives its business justification passes a configuration check because the configuration is correct; the entitlement is wrong. Join enabled accounts against HR status and last sign-in, then record a keep, change or remove decision per account with a named reviewer. A bulk approval with no per-account decision is not a review.

Over-scoped agent service accounts

An agent credential with standing broad access passes review because it is correctly configured for what it was granted. The defect is the grant's scope relative to the agent's purpose. Test it by justifying each permission against the agent's registered business purpose, then run a revocation drill and record how long the credential kept working.

A Minimum Acceptance Checklist Before Go-Live

Run this before cutover. Each item is a test with a named artefact; an item you cannot evidence is an item you have not verified.

Access model and configuration

  • Every access requirement routed to a role, a row filter, or both, using the decision rule above.

  • No per-region table or view duplication standing in for a row filter.

  • Object creation routed through named owners or service identities, with creators recorded.

  • Preset versus custom role boundaries understood: preset roles cannot be modified.

  • Where masking applies, USE FUNCTION granted on every required masking function alongside SELECT.

Evidence: the routing worksheet and the effective-permission export per user.

Testing and evidence

  • Restricted-versus-authorized runs completed for SELECT, UPDATE, DELETE and an aggregate.

  • Negative control run: a principal with no row rule sees the full set.

  • Base-table-direct query run as the restricted principal.

  • Export-path filter test run, with the destination recorded.

  • Multiple-row-rule combination resolved and the observed behavior written down.

  • Access records captured per statement; effective-permission export per user produced.

Evidence: result sets, access records and the completed worksheet.

Agent and lifecycle controls

  • Each agent has a unique identity, named owner and backup, registered purpose and scoped entitlements.

  • Delegation computes the intersection of agent and user scope, and sub-delegations are strict subsets.

  • Revocation drill completed with time-to-stop recorded.

  • Review cadence set with a named reviewer and a review date per role and per agent.

  • Row-filter preview status confirmed with support before you rely on it as a production control.

Where the Documentation Ends and Validation Begins

Published pages describe mechanics; they do not certify your tenant. The items below are the questions Singdata's documentation leaves open, and each one is answerable in a trial with a recorded result.

Open questions to resolve in a trial

  1. Do hand-written SQL and Agent-generated queries share an identical enforcement path?

  2. How do multiple row rules combine for one user — union, intersection, or error?

  3. Are a view and its base table both filtered?

  4. Does the export path honor row filters?

  5. How is an agent's identity established and recorded, and what is its credential lifetime?

  6. What is the production availability status of row filtering, given its invite-only preview label?

Record each answer with the date, the tester and the environment.

Further reading

Singdata documentation carries the mechanics: access control overview, roles, row filter, row-level permissions, dynamic masking, security overview, and the SHOW command reference for introspection.

External framing: NIST SP 800-162 (archived) for access-control vocabulary, the AICPA 2017 Trust Services Criteria for CC6, GDPR Article 32 for testing and evaluation duties, and OWASP LLM06:2025 Excessive Agency for agent least privilege.

FAQ

These answers stay within what Singdata's published pages state and mark where a trial must decide.

Does a row filter restrict which tables a user can query?

No. A row filter restricts rows within an object the principal can already reach. Which tables a user can query is a role decision, so an over-broad grant stays over-broad however well the filter is scoped.

If a user has two roles with different row scopes, what happens?

Singdata documents union semantics for role permissions and direct grants, and advises verifying that combined row-rule scope meets expectations. The retrieved pages do not specify whether multiple row rules combine by union, intersection, or error. Test it in a trial with two non-overlapping scopes and record the observed result.

Is row-level security generally available in Singdata Lakehouse?

Singdata's row-filter documentation labels the feature an invite-only preview and directs customers to contact technical support. Confirm production status with support before you rely on it as an audit control.

Can a row filter prevent an export?

Not by itself. A row filter limits which rows return from an object the principal can already reach; whether the export path honors that filter is a separate validation item, and export permission itself is a role decision.

What is the single most useful audit artefact?

The per-statement access record from a restricted-versus-authorized test run, paired with the expected result you declared before running it. It shows the control operated; a configuration screenshot only shows intent.

Does a vendor SOC 2 report cover our configuration?

No. A SOC 2 report covers the vendor's controls over a defined observation window; it says nothing about your configuration or your tenant. Your own test evidence is what an auditor tests.

Previous posts

https://www.singdata.com/

https://www.singdata.com/company

https://singdata.com/trending/powerbi-date-difference-dax-calculations/