The easy-to-use open source Business Intelligence and Embedded Analytics tool that lets everyone work with data :bar_chart:
TypeScript analyticsbibusiness-intelligencebusinessintelligenceclojuredashboarddatadata-analysisdata-visualizationdatabasemetabasemysqlpostgrespostgresqlreportingslacksql-editorvisualization
[perms] Refactor graph updates to remove costly N+1 query (#73694)
Braden Shepherdson1524459fb771
diff --git a/enterprise/backend/src/metabase_enterprise/data_studio/permissions/published_tables.clj b/enterprise/backend/src/metabase_enterprise/data_studio/permissions/published_tables.cljindex 2f4d5a45919..370a5b7fc43 100644--- a/enterprise/backend/src/metabase_enterprise/data_studio/permissions/published_tables.clj+++ b/enterprise/backend/src/metabase_enterprise/data_studio/permissions/published_tables.clj@@ -13,13 +13,15 @@"Returns :query-builder permission if table is published and user has collection access.Tables published into the root collection (collection_id=nil) are accessible to all users.":feature :library- [perm-type table-id]+ [user-id perm-type table-id](when (and (= perm-type :perms/create-queries)(t2/exists? :model/Table{:where [:and[:= :id table-id][:= :is_published true]- (collection/visible-collection-filter-clause :collection_id)]}))+ (collection/visible-collection-filter-clause+ :collection_id {} {:current-user-id user-id+ :is-superuser? (perms/is-superuser? user-id)})]})):query-builder))(defenterprise user-has-any-published-table-permission?diff --git a/src/metabase/permissions/core.clj b/src/metabase/permissions/core.cljindex 8bddae9bf97..6952ac06c48 100644--- a/src/metabase/permissions/core.clj+++ b/src/metabase/permissions/core.clj@@ -38,11 +38,14 @@(p/import-vars[metabase.permissions.models.data-permissionsat-least-as-permissive?+ batch-delete-permissions!+ batch-insert-permissions!disable-perms-cachedownload-perms-levelfull-db-permission-for-userfull-schema-permission-for-usergroups-have-permission-for-table?+ index-database-permissionsis-superuser?is-data-analyst?most-permissive-database-permission-for-userdiff --git a/src/metabase/permissions/models/data_permissions.clj b/src/metabase/permissions/models/data_permissions.cljindex 2eea1a4e8f0..7d3b9ad30a1 100644--- a/src/metabase/permissions/models/data_permissions.clj+++ b/src/metabase/permissions/models/data_permissions.clj@@ -402,7 +402,7 @@(or (when-not (= table-perm (least-permissive-value perm-type))table-perm)(when (pos-int? table-id)- (published-tables/user-published-table-permission perm-type table-id))+ (published-tables/user-published-table-permission user-id perm-type table-id))(least-permissive-value perm-type)))))(mu/defn user-has-permission-for-table? :- :boolean@@ -690,33 +690,31 @@Returns a map with keys:- :to-delete - sequence of DataPermissions models to delete- :to-insert - sequence of DataPermissions models to insert "- [group-or-id :- TheIdable+ [perms+ group-or-id :- TheIdabledb-or-id :- TheIdableperm-type :- ::permissions.schema/data-permission-typevalue :- :keyword](let [group-id (u/the-id group-or-id)db-id (u/the-id db-or-id)- existing-perms (t2/select :model/DataPermissions- :perm_type perm-type- :group_id group-id- :db_id db-id)+ existing-perms (get perms [group-id db-id perm-type])new-perm {:perm_type perm-type:group_id group-id:perm_value value:db_id db-id}recursive-calls (cond-> [](and (= perm-type :perms/create-queries) (not= value :no))- (conj (build-database-permission group-or-id db-or-id :perms/view-data :unrestricted))+ (conj (build-database-permission perms group-or-id db-or-id :perms/view-data :unrestricted))(= [:perms/view-data :blocked] [perm-type value])- (into [(build-database-permission group-or-id db-or-id :perms/create-queries :no)- (build-database-permission group-or-id db-or-id :perms/download-results :no)])+ (into [(build-database-permission perms group-or-id db-or-id :perms/create-queries :no)+ (build-database-permission perms group-or-id db-or-id :perms/download-results :no)])(and (= perm-type :perms/view-data) (not= value :unrestricted))- (conj (build-database-permission group-or-id db-or-id :perms/transforms :no))+ (conj (build-database-permission perms group-or-id db-or-id :perms/transforms :no))(and (= perm-type :perms/create-queries) (not= value :query-builder-and-native))- (conj (build-database-permission group-or-id db-or-id :perms/transforms :no)))]+ (conj (build-database-permission perms group-or-id db-or-id :perms/transforms :no)))](apply merge-with concat{:to-delete existing-perms:to-insert [new-perm]}@@ -724,7 +722,7 @@(def ^:private permission-batch-size 1000)-(defn- batch-insert-permissions!+(defn batch-insert-permissions!"In certain cases, when updating the permissions for many tables at once, we need to batch the insertions to avoidhitting database limits for the number of parameters in a prepared statement. This is only really applicable when a DBhas more than ~10k tables and we're transitioning from database-level permissions to table-level permissions."@@ -732,30 +730,61 @@(doseq [batched-new-perms (partition-all permission-batch-size new-perms)](t2/insert! :model/DataPermissions batched-new-perms)))-(defn- batch-delete-permissions!+(defn batch-delete-permissions!"Much like on insert, sometimes we have to delete more permission models than the psql limit of MAX 16-bit parameters.This batches our deletes into groups of `permission-batch-size`."[to-delete-ids](doseq [batched-to-delete-ids (partition-all permission-batch-size to-delete-ids)](t2/delete! :model/DataPermissions :id [:in batched-to-delete-ids])))+(defn index-database-permissions+ "Given seqs of `group-ids` and `db-ids`, computes an index of all relevant permissions.++ Use this to avoid N+1s in repeated [[set-database-permission!]] calls.++ BEWARE race conditions! This function must be run inside a cluster lock on the relevant DB(s), or you risk working+ from stale data and generating bad permissions. See+ [[metabase.permissions.models.data-permissions-test/race-conditions-test]].++ Returns a map of `{[group-id db-id perm-type] [DataPermission ...]}`. Returns nil if either input list is empty."+ [group-ids db-ids]+ (when (and (seq group-ids) (seq db-ids))+ (group-by (juxt :group_id :db_id :perm_type)+ (t2/select :model/DataPermissions :group_id [:in group-ids] :db_id [:in db-ids]))))+(mu/defn set-database-permission!- "Set a single permission to a specified- value for a given group and database. If a permission value already exists for the specified group and object,- it will be updated to the new value.+ "Set a single permission to a specified value for a given group and database. If a permission value already exists+ for the specified group and object, it will be updated to the new value.++ The optional first argument holds an in-memory index of permissions; this exists to avoid N+1 queries in large edits+ like updating the entire permissions graph. Singular calls to this function can omit it, and an index for just the+ input group and DB will be created on demand.Block permissions (i.e. :perms/view-data :blocked) can be set at the table or database-level."- [group-or-id :- TheIdable- db-or-id :- TheIdable- perm-type :- ::permissions.schema/data-permission-type- value :- :keyword]- (with-cluster-lock {:db-id (u/the-id db-or-id)- :perm-type (u/qualified-name perm-type)}- (let [{:keys [to-insert to-delete]} (build-database-permission group-or-id db-or-id perm-type value)]- (when (seq to-delete)- (batch-delete-permissions! (map :id to-delete)))- (when (seq to-insert)- (batch-insert-permissions! to-insert)))))+ ([group-or-id :- TheIdable+ db-or-id :- TheIdable+ perm-type :- ::permissions.schema/data-permission-type+ value :- :keyword]+ (let [group-id (u/the-id group-or-id)+ db-id (u/the-id db-or-id)]+ (with-cluster-lock {:db-id db-id+ :perm-type (u/qualified-name perm-type)}+ (set-database-permission! (index-database-permissions [group-id] [db-id])+ group-or-id db-or-id perm-type value))))+ ([perms :- [:map-of+ [:tuple pos-int? pos-int? ::permissions.schema/data-permission-type]+ [:sequential :any]]+ group-or-id :- TheIdable+ db-or-id :- TheIdable+ perm-type :- ::permissions.schema/data-permission-type+ value :- :keyword]+ (with-cluster-lock {:db-id (u/the-id db-or-id)+ :perm-type (u/qualified-name perm-type)}+ (let [{:keys [to-insert to-delete]} (build-database-permission perms group-or-id db-or-id perm-type value)]+ (when (seq to-delete)+ (batch-delete-permissions! (map :id to-delete)))+ (when (seq to-insert)+ (batch-insert-permissions! to-insert))))))(defenterprise new-group-view-data-permission-levels"Returns a map of {db-id → permission-level} for multiple databases. On OSS, all are `:unrestricted`."@@ -855,7 +884,8 @@(= values existing-table-values));; If all tables would have the same permissions after we update these ones, we can replace all of the table;; perms with a DB-level perm instead.- (build-database-permission group-id db-id perm-type (first values))+ (build-database-permission (index-database-permissions [group-id] [db-id])+ group-id db-id perm-type (first values));; Otherwise, just replace the rows for the individual table perm(let [table-perms-to-delete (t2/select :model/DataPermissions{:where [:and@@ -866,11 +896,11 @@:to-insert new-perms}))))(mu/defn- build-table-permissions- "Builds a sequence of DataPermissions models to delete and insert for setting+ "Determines which DataPermissions rows must be deleted and inserted to set the permissions for the provided tables.Returns a map with keys:- - :to-delete - sequence of DataPermissions models to delete- - :to-insert - sequence of DataPermissions models to insert "+ - :to-delete - sequence of DataPermissions row IDs to delete+ - :to-insert - sequence of DataPermissions maps to insert "[group-or-id :- TheIdableperm-type :- ::permissions.schema/data-permission-typetable-perms :- [:map-of TheIdable :keyword]]diff --git a/src/metabase/permissions/published_tables.clj b/src/metabase/permissions/published_tables.cljindex 8228037418f..a9e20646827 100644--- a/src/metabase/permissions/published_tables.clj+++ b/src/metabase/permissions/published_tables.clj@@ -14,7 +14,7 @@"Returns `:query-builder` permission if table is published and user has collection access.OSS implementation always returns nil - published tables only grant access in EE."metabase-enterprise.data-studio.permissions.published-tables- [_perm-type _table-id]+ [_user-id _perm-type _table-id]nil)(defenterprise user-has-any-published-table-permission?diff --git a/src/metabase/permissions_rest/data_permissions/graph.clj b/src/metabase/permissions_rest/data_permissions/graph.cljindex ea914f21b00..46b6108af41 100644--- a/src/metabase/permissions_rest/data_permissions/graph.clj+++ b/src/metabase/permissions_rest/data_permissions/graph.clj@@ -289,160 +289,245 @@(str/replace (name perm-type) "-" " ")){:status-code 402}))-(defn- update-table-level-metadata-permissions!- [group-id db-id schema new-table-perms]- (let [new-table-perms- (-> new-table-perms- (update-vals (fn [table-perm]- (case table-perm- :all :yes- :none :no)))- (update-keys (fn [table-id] {:id table-id :db_id db-id :schema schema})))]- (perms/set-table-permissions! group-id :perms/manage-table-metadata new-table-perms)))--(defn- update-schema-level-metadata-permissions!- [group-id db-id schema new-schema-perms]- (if (map? new-schema-perms)- (update-table-level-metadata-permissions! group-id db-id schema new-schema-perms)- (let [tables (t2/select :model/Table :db_id db-id :schema (not-empty schema))]- (when (seq tables)- (case new-schema-perms- :all- (perms/set-table-permissions! group-id :perms/manage-table-metadata (zipmap tables (repeat :yes)))-- :none- (perms/set-table-permissions! group-id :perms/manage-table-metadata (zipmap tables (repeat :no))))))))--(defn- update-db-level-metadata-permissions!- [group-id db-id new-db-perms]- (when-let [schemas (:schemas new-db-perms)]- (if (map? schemas)- (doseq [[schema schema-changes] schemas]- (update-schema-level-metadata-permissions! group-id db-id schema schema-changes))- (case schemas- :all- (perms/set-database-permission! group-id db-id :perms/manage-table-metadata :yes)-- :none- (perms/set-database-permission! group-id db-id :perms/manage-table-metadata :no)))))--(defn- update-table-level-download-permissions!- [group-id db-id schema new-table-perms]- (let [new-table-perms- (-> new-table-perms- (update-vals (fn [table-perm]- (case table-perm- :full :one-million-rows- :limited :ten-thousand-rows- :none :no)))- (update-keys (fn [table-id] {:id table-id :db_id db-id :schema schema})))]- (perms/set-table-permissions! group-id :perms/download-results new-table-perms)))--(defn- update-schema-level-download-permissions!- [group-id db-id schema new-schema-perms]- (if (map? new-schema-perms)- (update-table-level-download-permissions! group-id db-id schema new-schema-perms)- (let [tables (t2/select :model/Table :db_id db-id :schema (not-empty schema))]- (when (seq tables)- (case new-schema-perms- :full- (perms/set-table-permissions! group-id :perms/download-results (zipmap tables (repeat :one-million-rows)))-- :limited- (perms/set-table-permissions! group-id :perms/download-results (zipmap tables (repeat :ten-thousand-rows)))-- :none- (perms/set-table-permissions! group-id :perms/download-results (zipmap tables (repeat :no))))))))--(defn- update-db-level-download-permissions!- [group-id db-id new-db-perms]- (when-let [schemas (:schemas new-db-perms)]- (if (map? schemas)- (doseq [[schema schema-changes] schemas]- (update-schema-level-download-permissions! group-id db-id schema schema-changes))- (case schemas- :full- (perms/set-database-permission! group-id db-id :perms/download-results :one-million-rows)-- :limited- (perms/set-database-permission! group-id db-id :perms/download-results :ten-thousand-rows)-- :none- (perms/set-database-permission! group-id db-id :perms/download-results :no)))))--(defn- update-details-perms!- [group-id db-id value]- (perms/set-database-permission! group-id db-id :perms/manage-database value))--(defn- update-transforms-perms!- [group-id db-id value]- (perms/set-database-permission! group-id db-id :perms/transforms value))--(defn- update-table-level-create-queries-permissions!- [group-id db-id schema new-table-perms]- (let [new-table-perms (update-keys- new-table-perms- (fn [table-id] {:id table-id :db_id db-id :schema schema}))]- (perms/set-table-permissions! group-id :perms/create-queries new-table-perms)))--(defn- update-schema-level-create-queries-permissions!- [group-id db-id schema new-schema-perms]- (if (map? new-schema-perms)- (update-table-level-create-queries-permissions! group-id db-id schema new-schema-perms)- (let [tables (t2/select :model/Table :db_id db-id :schema (not-empty schema))]- (when (seq tables)- (perms/set-table-permissions! group-id :perms/create-queries (zipmap tables (repeat new-schema-perms)))))))--(defn- update-db-level-create-queries-permissions!- [group-id db-id new-db-perms]- (if (map? new-db-perms)- (doseq [[schema new-schema-perms] new-db-perms]- (update-schema-level-create-queries-permissions! group-id db-id schema new-schema-perms))- (when new-db-perms- (perms/set-database-permission! group-id db-id :perms/create-queries new-db-perms))))--(defn- update-table-level-view-data-permissions!- [group-id db-id schema new-table-perms]- (let [new-table-perms (->- (update-keys- new-table-perms- (fn [table-id] {:id table-id :db_id db-id :schema schema}))- (update-vals (fn [table-perm]- (case table-perm- :unrestricted :unrestricted- ;; If the table is sandboxed, we set `view-data` to `unrestricted` since- ;; sandboxes are stored separately in the `sandboxes` table- :sandboxed :unrestricted- :legacy-no-self-service :legacy-no-self-service- :blocked :blocked))))]- (perms/set-table-permissions! group-id :perms/view-data new-table-perms)))--(defn- update-schema-level-view-data-permissions!- [group-id db-id schema new-schema-perms]- (if (map? new-schema-perms)- (update-table-level-view-data-permissions! group-id db-id schema new-schema-perms)- (let [tables (t2/select :model/Table :db_id db-id :schema (not-empty schema))]- (when (seq tables)- (perms/set-table-permissions! group-id :perms/view-data (zipmap tables (repeat new-schema-perms)))))))--(defn- update-db-level-view-data-permissions!- [group-id db-id new-db-perms]- (if (map? new-db-perms)- (doseq [[schema new-schema-perms] new-db-perms]- (update-schema-level-view-data-permissions! group-id db-id schema new-schema-perms))- (case new-db-perms- (:unrestricted :impersonated)- (perms/set-database-permission! group-id db-id :perms/view-data :unrestricted)-- ;; Support setting legacy-no-self-service for testing purposes, though the UI shouldn't allow it normally- :legacy-no-self-service- (perms/set-database-permission! group-id db-id :perms/view-data :legacy-no-self-service)-- :blocked- (do- (when-not (premium-features/has-feature? :advanced-permissions)- (throw (ee-permissions-exception :blocked)))- (perms/set-database-permission! group-id db-id :perms/view-data :blocked)))))+;; Bulk update implementation ====================================================================================+;; Instead of iterating over groups x dbs x perm-types x schemas and making individual DB calls,+;; this implementation:+;; 1. Pre-fetches all tables and current permissions in bulk (2 queries)+;; 2. Uses pure functions to compute the desired state+;; 3. Diffs desired vs current to produce minimal inserts/deletes+;; 4. Applies changes in bulk (2 queries)++(def ^:private api-val->db-val+ {:view-data {:unrestricted :unrestricted+ :impersonated :unrestricted+ :sandboxed :unrestricted+ :legacy-no-self-service :legacy-no-self-service+ :blocked :blocked}+ :create-queries {:query-builder-and-native :query-builder-and-native+ :query-builder :query-builder+ :no :no}+ :download {:full :one-million-rows+ :limited :ten-thousand-rows+ :none :no}+ :data-model {:all :yes+ :none :no}+ :details {:yes :yes :no :no}+ :transforms {:yes :yes :no :no}})++(def ^:private api-key->perm-type+ {:view-data :perms/view-data+ :create-queries :perms/create-queries+ :download :perms/download-results+ :data-model :perms/manage-table-metadata+ :details :perms/manage-database+ :transforms :perms/transforms})++(defn- resolve-api-value+ "Translates an API permission value for a single [group-id db-id api-key] into a map of+ {table-id-or-nil {:perm_value v :schema_name s}}. A nil key means db-level."+ [api-key api-value db-id tables-by-db-schema]+ (let [raw-value (if (#{:download :data-model} api-key)+ (:schemas api-value)+ api-value)]+ (if (keyword? raw-value)+ {nil {:perm_value (get-in api-val->db-val [api-key raw-value])+ :schema_name nil}}+ (into {}+ (mapcat+ (fn [[schema-str schema-val]]+ (let [db-schema (not-empty schema-str)]+ (if (keyword? schema-val)+ (map (fn [{:keys [id schema]}]+ [id {:perm_value (get-in api-val->db-val [api-key schema-val])+ :schema_name schema}])+ (get tables-by-db-schema [db-id db-schema]))+ (map (fn [[table-id table-val]]+ [table-id {:perm_value (get-in api-val->db-val [api-key table-val])+ :schema_name db-schema}])+ schema-val)))))+ raw-value))))++(defn- add-implications:db-level+ [desired group-id db-id perm-type db-value]+ (cond-> desired+ (and (= perm-type :perms/create-queries) (not= db-value :no))+ (update [group-id db-id :perms/view-data]+ #(merge % {nil {:perm_value :unrestricted :schema_name nil}}))++ (and (= perm-type :perms/view-data) (= db-value :blocked))+ (-> (update [group-id db-id :perms/create-queries]+ #(merge % {nil {:perm_value :no :schema_name nil}}))+ (update [group-id db-id :perms/download-results]+ #(merge % {nil {:perm_value :no :schema_name nil}})))++ (and (= perm-type :perms/view-data) (not= db-value :unrestricted))+ (update [group-id db-id :perms/transforms]+ #(merge % {nil {:perm_value :no :schema_name nil}}))++ (and (= perm-type :perms/create-queries) (not= db-value :query-builder-and-native))+ (update [group-id db-id :perms/transforms]+ #(merge % {nil {:perm_value :no :schema_name nil}}))))++(defn- add-implications:table-level+ [desired group-id db-id perm-type table-entries]+ (cond-> desired+ (= perm-type :perms/create-queries)+ (update [group-id db-id :perms/view-data]+ #(merge %+ (into {}+ (keep (fn [[tid {:keys [perm_value schema_name]}]]+ (when (not= perm_value :no)+ [tid {:perm_value :unrestricted :schema_name schema_name}])))+ table-entries)))++ (= perm-type :perms/view-data)+ (-> (update [group-id db-id :perms/create-queries]+ #(merge %+ (into {}+ (keep (fn [[tid {:keys [perm_value schema_name]}]]+ (when (= perm_value :blocked)+ [tid {:perm_value :no :schema_name schema_name}])))+ table-entries)))+ (update [group-id db-id :perms/download-results]+ #(merge %+ (into {}+ (keep (fn [[tid {:keys [perm_value schema_name]}]]+ (when (= perm_value :blocked)+ [tid {:perm_value :no :schema_name schema_name}])))+ table-entries))))))++(defn- add-implications+ "Given a desired-state map and entries just added for a perm-type, merges in implied permission changes.+ Implications from later-processed perm-types override earlier values."+ [desired group-id db-id perm-type entries]+ (let [has-db-level? (contains? entries nil)+ db-value (get-in entries [nil :perm_value])+ table-entries (dissoc entries nil)]+ (cond+ has-db-level? (add-implications:db-level desired group-id db-id perm-type db-value)+ (empty? table-entries) desired+ :else (add-implications:table-level desired group-id db-id perm-type table-entries))))++(defn- compute-desired-state+ "Process the API graph changes in dependency order, producing a desired-state map of+ {[group-id db-id perm-type] {table-id-or-nil {:perm_value v :schema_name s}}}."+ [graph tables-by-db-schema]+ (reduce+ (fn [desired [group-id db-id api-key api-value]]+ (let [perm-type (api-key->perm-type api-key)+ entries (resolve-api-value api-key api-value db-id tables-by-db-schema)]+ (-> desired+ (update [group-id db-id perm-type] #(merge % entries))+ (add-implications group-id db-id perm-type entries))))+ {}+ (for [[group-id group-changes] graph+ [db-id db-changes] group-changes+ api-key [:details :data-model :download :transforms :create-queries :view-data]+ :let [api-value (get db-changes api-key)]+ :when api-value]+ [group-id db-id api-key api-value])))++(defn- expand-to-table-level+ "Expands a db-level permission value to table-level entries for all tables in the db.+ :query-builder-and-native becomes :query-builder per table since it can only be db-level."+ [perm-value all-tables]+ (let [table-value (if (= perm-value :query-builder-and-native) :query-builder perm-value)]+ (into {}+ (map (fn [{:keys [id schema]}]+ [id {:perm_value table-value :schema_name schema}]))+ all-tables)))++(defn- table-permissions-map [current-rows]+ (into {}+ (keep (fn [{:keys [table_id perm_value schema_name] :as _row}]+ (when table_id+ [table_id+ {:perm_value perm_value+ :schema_name schema_name}])))+ current-rows))++(defn- perms->base-state [current-rows current-db-row all-tables]+ (if current-db-row+ (expand-to-table-level (:perm_value current-db-row) all-tables)+ (table-permissions-map current-rows)))++(defn- finalize-tuple+ "For a single [group-id db-id perm-type], compute the final desired DataPermissions rows.+ Merges desired entries with current state for unmentioned tables, then coalesces if possible.++ Coalescing rules (matching legacy behavior):+ - Explicit db-level desired (nil key, no table overrides) → always db-level+ - Mixed (db-level default + table overrides) where all values same → coalesce to db-level+ - Table-level desired, current was db-level, all values match current → keep db-level (no-op)+ - Otherwise → table-level rows"+ [group-id db-id perm-type desired-entries current-rows all-tables]+ (let [has-db-level? (contains? desired-entries nil)+ table-entries (dissoc desired-entries nil)]+ (if (and has-db-level? (empty? table-entries))+ [{:perm_type perm-type+ :group_id group-id+ :perm_value (:perm_value (desired-entries nil))+ :db_id db-id}]+ (let [current-db-row (first (filter #(nil? (:table_id %)) current-rows))+ base-state (if has-db-level?+ (expand-to-table-level (:perm_value (desired-entries nil)) all-tables)+ (perms->base-state current-rows current-db-row all-tables))+ final-state (merge base-state table-entries)+ values (into #{} (map :perm_value) (vals final-state))+ all-same? (and (= 1 (count values))+ (seq all-tables)+ (= (count final-state) (count all-tables)))+ coalesce? (and all-same?+ (or has-db-level?+ (and current-db-row+ (= (first values) (:perm_value current-db-row)))))]+ (if coalesce?+ [{:perm_type perm-type+ :group_id group-id+ :perm_value (first values)+ :db_id db-id}]+ (mapv (fn [[table-id {:keys [perm_value schema_name]}]]+ {:perm_type perm-type+ :group_id group-id+ :perm_value perm_value+ :db_id db-id+ :table_id table-id+ :schema_name schema_name})+ final-state))))))++(def ^:private row-signature+ (juxt :perm_type :perm_value :table_id :schema_name))++(defn- rows-match?+ "Check if the current rows already represent the desired state (no changes needed)."+ [current-rows desired-rows]+ (= (into #{} (map row-signature) current-rows)+ (into #{} (map row-signature) desired-rows)))++(defn- compute-diff+ "Given the desired state, current permissions index, and tables-by-db,+ returns {:to-delete [id ...] :to-insert [row-map ...]}."+ [desired-state current-perms-index tables-by-db]+ (reduce-kv+ (fn [acc [group-id db-id perm-type] desired-entries]+ (let [current-rows (get current-perms-index [group-id db-id perm-type] [])+ all-tables (get tables-by-db db-id [])+ desired-rows (finalize-tuple group-id db-id perm-type desired-entries current-rows all-tables)]+ (if (rows-match? current-rows desired-rows)+ acc+ (-> acc+ (update :to-delete into (keep :id) current-rows)+ (update :to-insert into desired-rows)))))+ {:to-delete [] :to-insert []}+ desired-state))++(defn- validate-blocked-permissions!+ [graph]+ (doseq [[_group-id group-changes] graph+ [_db-id db-changes] group-changes]+ (when (= (:view-data db-changes) :blocked)+ (when-not (premium-features/has-feature? :advanced-permissions)+ (throw (ee-permissions-exception :blocked))))))(defn- check-data-analyst-locked-permissions"Check that we're not modifying data-model permission for the Data Analysts group.@@ -470,26 +555,31 @@{:status-code 400})))))(mu/defn update-data-perms-graph!*- "Takes an API-style perms graph and sets the permissions in the database accordingly."+ "Takes an API-style perms graph and sets the permissions in the database accordingly.+ Uses bulk operations to minimize database round-trips."([graph]- (doseq [[group-id group-changes] graph]- (doseq [[db-id db-changes] group-changes- ;; instead of iterating the provided cb-changes object we need to go in a specific order- ;; so backend consistency rules like setting create-queries and download to no when view-data- ;; is blocked can happen in the correct order despite what may come in the API request- perm-type [:details :data-model :download :transforms :create-queries :view-data]]- (when-let [new-perms (perm-type db-changes)]- (case perm-type- :view-data (update-db-level-view-data-permissions! group-id db-id new-perms)- :create-queries (update-db-level-create-queries-permissions! group-id db-id new-perms)- :download (update-db-level-download-permissions! group-id db-id new-perms)- :data-model (update-db-level-metadata-permissions! group-id db-id new-perms)- :details (update-details-perms! group-id db-id new-perms)- :transforms (update-transforms-perms! group-id db-id new-perms))))))+ (let [affected-group-ids (keys graph)+ affected-db-ids (into #{} (mapcat keys) (vals graph))+ all-tables (when (seq affected-db-ids)+ (t2/select [:model/Table :id :db_id :schema]+ :db_id [:in affected-db-ids]))+ tables-by-db-schema (group-by (juxt :db_id :schema) all-tables)+ tables-by-db (group-by :db_id all-tables)+ current-perms (or (perms/index-database-permissions affected-group-ids affected-db-ids) {})+ desired-state (compute-desired-state graph tables-by-db-schema)+ {:keys [to-delete to-insert]} (compute-diff desired-state current-perms tables-by-db)]+ (validate-blocked-permissions! graph)+ (when (seq to-delete)+ (perms/batch-delete-permissions! to-delete))+ (when (seq to-insert)+ (perms/batch-insert-permissions! to-insert))));; The following arity is provided solely for convenience for tests/REPL usage([ks :- [:vector :any] new-value]- (update-data-perms-graph!* (assoc-in (-> api-graph :groups) ks new-value))))+ (-> (api-graph)+ :groups+ (assoc-in ks new-value)+ update-data-perms-graph!*)))(mu/defn update-data-perms-graph!"Takes an API-style perms graph and sets the permissions in the database accordingly. Additionally ensures@@ -506,4 +596,6 @@;; The following arity is provided solely for convenience for tests/REPL usage([ks :- [:vector :any] new-value]- (update-data-perms-graph! (assoc-in (api-graph) (cons :groups ks) new-value))))+ (-> (api-graph)+ (assoc-in (cons :groups ks) new-value)+ update-data-perms-graph!)))diff --git a/test/metabase/permissions_rest/data_permissions/graph/bulk_update_test.clj b/test/metabase/permissions_rest/data_permissions/graph/bulk_update_test.cljnew file mode 100644index 00000000000..1a91557ecf1--- /dev/null+++ b/test/metabase/permissions_rest/data_permissions/graph/bulk_update_test.clj@@ -0,0 +1,395 @@+(ns metabase.permissions-rest.data-permissions.graph.bulk-update-test+ "Unit tests for the pure functions in the bulk permissions graph update implementation."+ (:require+ [clojure.test :refer :all]+ [metabase.permissions-rest.data-permissions.graph :as data-perms.graph]+ [metabase.test :as mt]+ [toucan2.core :as t2]))++(def ^:private tables-by-db-schema+ "A mock table index with two schemas: PUBLIC has tables 1,2 and OTHER has table 3."+ {[1 "PUBLIC"] [{:id 10 :db_id 1 :schema "PUBLIC"}+ {:id 11 :db_id 1 :schema "PUBLIC"}]+ [1 nil] [{:id 12 :db_id 1 :schema nil}]})++;;; ================================ resolve-api-value ================================++(deftest resolve-api-value-db-level-test+ (testing "DB-level keyword values"+ (is (= {nil {:perm_value :unrestricted :schema_name nil}}+ (#'data-perms.graph/resolve-api-value :view-data :unrestricted 1 tables-by-db-schema)))+ (is (= {nil {:perm_value :blocked :schema_name nil}}+ (#'data-perms.graph/resolve-api-value :view-data :blocked 1 tables-by-db-schema)))+ (is (= {nil {:perm_value :query-builder-and-native :schema_name nil}}+ (#'data-perms.graph/resolve-api-value :create-queries :query-builder-and-native 1 tables-by-db-schema)))+ (is (= {nil {:perm_value :no :schema_name nil}}+ (#'data-perms.graph/resolve-api-value :create-queries :no 1 tables-by-db-schema)))))++(deftest resolve-api-value-download-wrapper-test+ (testing "Download and data-model unwrap the :schemas key"+ (is (= {nil {:perm_value :one-million-rows :schema_name nil}}+ (#'data-perms.graph/resolve-api-value :download {:schemas :full} 1 tables-by-db-schema)))+ (is (= {nil {:perm_value :no :schema_name nil}}+ (#'data-perms.graph/resolve-api-value :download {:schemas :none} 1 tables-by-db-schema)))+ (is (= {nil {:perm_value :yes :schema_name nil}}+ (#'data-perms.graph/resolve-api-value :data-model {:schemas :all} 1 tables-by-db-schema)))+ (is (= {nil {:perm_value :no :schema_name nil}}+ (#'data-perms.graph/resolve-api-value :data-model {:schemas :none} 1 tables-by-db-schema)))))++(deftest resolve-api-value-schema-level-test+ (testing "Schema-level keyword expands to all tables in that schema"+ (is (= {10 {:perm_value :unrestricted :schema_name "PUBLIC"}+ 11 {:perm_value :unrestricted :schema_name "PUBLIC"}}+ (#'data-perms.graph/resolve-api-value :view-data {"PUBLIC" :unrestricted} 1 tables-by-db-schema))))+ (testing "Multiple schemas"+ (is (= {10 {:perm_value :unrestricted :schema_name "PUBLIC"}+ 11 {:perm_value :unrestricted :schema_name "PUBLIC"}+ 12 {:perm_value :blocked :schema_name nil}}+ (#'data-perms.graph/resolve-api-value :view-data {"PUBLIC" :unrestricted "" :blocked}+ 1 tables-by-db-schema)))))++(deftest resolve-api-value-table-level-test+ (testing "Table-level values produce per-table entries"+ (is (= {10 {:perm_value :query-builder :schema_name "PUBLIC"}+ 11 {:perm_value :no :schema_name "PUBLIC"}}+ (#'data-perms.graph/resolve-api-value :create-queries {"PUBLIC" {10 :query-builder 11 :no}}+ 1 tables-by-db-schema)))))++(deftest resolve-api-value-empty-schema-test+ (testing "Empty string schema maps to nil (null schema in DB)"+ (is (= {12 {:perm_value :unrestricted :schema_name nil}}+ (#'data-perms.graph/resolve-api-value :view-data {"" :unrestricted} 1 tables-by-db-schema)))))++(deftest resolve-api-value-translation-test+ (testing "API values are translated to DB values"+ (is (= {nil {:perm_value :unrestricted :schema_name nil}}+ (#'data-perms.graph/resolve-api-value :view-data :impersonated 1 tables-by-db-schema)))+ (is (= {nil {:perm_value :unrestricted :schema_name nil}}+ (#'data-perms.graph/resolve-api-value :view-data :sandboxed 1 tables-by-db-schema)))+ (is (= {10 {:perm_value :one-million-rows :schema_name "PUBLIC"}+ 11 {:perm_value :no :schema_name "PUBLIC"}}+ (#'data-perms.graph/resolve-api-value :download {:schemas {"PUBLIC" {10 :full 11 :none}}}+ 1 tables-by-db-schema)))+ (is (= {10 {:perm_value :yes :schema_name "PUBLIC"}+ 11 {:perm_value :no :schema_name "PUBLIC"}}+ (#'data-perms.graph/resolve-api-value :data-model {:schemas {"PUBLIC" {10 :all 11 :none}}}+ 1 tables-by-db-schema)))))++;;; ================================ add-implications ================================++(deftest add-implications-create-queries-db-level-test+ (testing "create-queries non-:no at db-level implies view-data :unrestricted and transforms :no"+ (let [desired {}+ entries {nil {:perm_value :query-builder :schema_name nil}}+ result (#'data-perms.graph/add-implications desired 1 1 :perms/create-queries entries)]+ (is (= {nil {:perm_value :unrestricted :schema_name nil}}+ (get result [1 1 :perms/view-data])))+ (is (= {nil {:perm_value :no :schema_name nil}}+ (get result [1 1 :perms/transforms])))))+ (testing "create-queries :query-builder-and-native implies view-data but NOT transforms :no"+ (let [desired {}+ entries {nil {:perm_value :query-builder-and-native :schema_name nil}}+ result (#'data-perms.graph/add-implications desired 1 1 :perms/create-queries entries)]+ (is (= {nil {:perm_value :unrestricted :schema_name nil}}+ (get result [1 1 :perms/view-data])))+ (is (nil? (get result [1 1 :perms/transforms])))))+ (testing "create-queries :no implies transforms :no but NOT view-data"+ (let [desired {}+ entries {nil {:perm_value :no :schema_name nil}}+ result (#'data-perms.graph/add-implications desired 1 1 :perms/create-queries entries)]+ (is (nil? (get result [1 1 :perms/view-data])))+ (is (= {nil {:perm_value :no :schema_name nil}}+ (get result [1 1 :perms/transforms]))))))++(deftest add-implications-view-data-db-level-test+ (testing "view-data :blocked implies create-queries :no, download :no, and transforms :no"+ (let [result (#'data-perms.graph/add-implications {} 1 1 :perms/view-data+ {nil {:perm_value :blocked :schema_name nil}})]+ (is (= {nil {:perm_value :no :schema_name nil}}+ (get result [1 1 :perms/create-queries])))+ (is (= {nil {:perm_value :no :schema_name nil}}+ (get result [1 1 :perms/download-results])))+ (is (= {nil {:perm_value :no :schema_name nil}}+ (get result [1 1 :perms/transforms])))))+ (testing "view-data :unrestricted has no implications"+ (let [result (#'data-perms.graph/add-implications {} 1 1 :perms/view-data+ {nil {:perm_value :unrestricted :schema_name nil}})]+ (is (empty? result)))))++(deftest add-implications-table-level-test+ (testing "Table-level create-queries non-:no implies view-data for those tables only"+ (let [entries {10 {:perm_value :query-builder :schema_name "PUBLIC"}+ 11 {:perm_value :no :schema_name "PUBLIC"}}+ result (#'data-perms.graph/add-implications {} 1 1 :perms/create-queries entries)]+ (is (= {10 {:perm_value :unrestricted :schema_name "PUBLIC"}}+ (get result [1 1 :perms/view-data])))+ (is (nil? (get result [1 1 :perms/transforms]))+ "No transforms implication at table level")))+ (testing "Table-level view-data :blocked implies create-queries :no and download :no for those tables"+ (let [entries {10 {:perm_value :blocked :schema_name "PUBLIC"}+ 11 {:perm_value :unrestricted :schema_name "PUBLIC"}}+ result (#'data-perms.graph/add-implications {} 1 1 :perms/view-data entries)]+ (is (= {10 {:perm_value :no :schema_name "PUBLIC"}}+ (get result [1 1 :perms/create-queries])))+ (is (= {10 {:perm_value :no :schema_name "PUBLIC"}}+ (get result [1 1 :perms/download-results]))))))++(deftest add-implications-override-behavior-test+ (testing "Implications override existing entries (later perm-type side effects take precedence)"+ (let [desired {[1 1 :perms/transforms] {nil {:perm_value :yes :schema_name nil}}}+ entries {nil {:perm_value :query-builder :schema_name nil}}+ result (#'data-perms.graph/add-implications desired 1 1 :perms/create-queries entries)]+ (is (= {nil {:perm_value :no :schema_name nil}}+ (get result [1 1 :perms/transforms]))+ "create-queries :query-builder implies transforms :no, overriding earlier :yes")))+ (testing "Protection from overriding explicit API values comes from processing order, not add-implications"+ (let [graph {1 {1 {:create-queries :query-builder :view-data :blocked}}}+ desired (#'data-perms.graph/compute-desired-state graph tables-by-db-schema)]+ (is (= {nil {:perm_value :blocked :schema_name nil}}+ (get desired [1 1 :perms/view-data]))+ "Explicit view-data :blocked overrides create-queries's implication because view-data is processed last"))))++;;; ================================ compute-desired-state ================================++(deftest compute-desired-state-ordering-test+ (testing "Transforms :yes is overridden by create-queries implication of transforms :no"+ (let [graph {1 {1 {:transforms :yes :create-queries :query-builder}}}+ desired (#'data-perms.graph/compute-desired-state graph tables-by-db-schema)]+ (is (= {nil {:perm_value :no :schema_name nil}}+ (get desired [1 1 :perms/transforms])))))+ (testing "Explicit view-data overrides create-queries implication"+ (let [graph {1 {1 {:create-queries :query-builder :view-data :blocked}}}+ desired (#'data-perms.graph/compute-desired-state graph tables-by-db-schema)]+ (is (= {nil {:perm_value :blocked :schema_name nil}}+ (get desired [1 1 :perms/view-data]))))))++(deftest compute-desired-state-details-test+ (testing "Details and transforms produce db-level entries"+ (let [desired (#'data-perms.graph/compute-desired-state {1 {1 {:details :yes :transforms :no}}} tables-by-db-schema)]+ (is (= {nil {:perm_value :yes :schema_name nil}}+ (get desired [1 1 :perms/manage-database])))+ (is (= {nil {:perm_value :no :schema_name nil}}+ (get desired [1 1 :perms/transforms]))))))++;;; ================================ finalize-tuple ================================++(def ^:private all-tables-db1+ [{:id 10 :db_id 1 :schema "PUBLIC"}+ {:id 11 :db_id 1 :schema "PUBLIC"}+ {:id 12 :db_id 1 :schema nil}])++(deftest finalize-tuple-pure-db-level-test+ (testing "Pure db-level entry produces one db-level row"+ (let [result (#'data-perms.graph/finalize-tuple 1 1 :perms/view-data+ {nil {:perm_value :unrestricted :schema_name nil}}+ [] all-tables-db1)]+ (is (= [{:perm_type :perms/view-data :group_id 1 :perm_value :unrestricted :db_id 1}]+ result)))))++(deftest finalize-tuple-table-level-empty-current-test+ (testing "Table-level entries with no current state produce table-level rows"+ (let [result (#'data-perms.graph/finalize-tuple 1 1 :perms/create-queries+ {10 {:perm_value :query-builder :schema_name "PUBLIC"}}+ [] all-tables-db1)]+ (is (= [{:perm_type :perms/create-queries :group_id 1 :perm_value :query-builder+ :db_id 1 :table_id 10 :schema_name "PUBLIC"}]+ result)))))++(deftest finalize-tuple-noop-when-current-db-level-matches-test+ (testing "Table-level entries that all match current db-level value coalesce (no-op)"+ (let [current [{:id 99 :perm_type :perms/view-data :group_id 1 :perm_value :unrestricted+ :db_id 1 :table_id nil :schema_name nil}]+ result (#'data-perms.graph/finalize-tuple 1 1 :perms/view-data+ {10 {:perm_value :unrestricted :schema_name "PUBLIC"}}+ current all-tables-db1)]+ (is (= [{:perm_type :perms/view-data :group_id 1 :perm_value :unrestricted :db_id 1}]+ result)))))++(deftest finalize-tuple-expand-db-level-on-change-test+ (testing "When current is db-level and change differs, expands to table-level"+ (let [current [{:id 99 :perm_type :perms/view-data :group_id 1 :perm_value :unrestricted+ :db_id 1 :table_id nil :schema_name nil}]+ result (#'data-perms.graph/finalize-tuple 1 1 :perms/view-data+ {10 {:perm_value :blocked :schema_name "PUBLIC"}}+ current all-tables-db1)]+ (is (= 3 (count result)))+ (is (every? :table_id result))+ (is (= :blocked (:perm_value (first (filter #(= 10 (:table_id %)) result)))))+ (is (= :unrestricted (:perm_value (first (filter #(= 11 (:table_id %)) result)))))+ (is (= :unrestricted (:perm_value (first (filter #(= 12 (:table_id %)) result))))))))++(deftest finalize-tuple-mixed-level-coalesces-test+ (testing "Mixed db-level + table overrides coalesces when all values same"+ (let [result (#'data-perms.graph/finalize-tuple 1 1 :perms/view-data+ {nil {:perm_value :unrestricted :schema_name nil}+ 10 {:perm_value :unrestricted :schema_name "PUBLIC"}}+ [] all-tables-db1)]+ (is (= [{:perm_type :perms/view-data :group_id 1 :perm_value :unrestricted :db_id 1}]+ result))))+ (testing "Mixed db-level + table overrides stays table-level when values differ"+ (let [result (#'data-perms.graph/finalize-tuple 1 1 :perms/view-data+ {nil {:perm_value :unrestricted :schema_name nil}+ 10 {:perm_value :blocked :schema_name "PUBLIC"}}+ [] all-tables-db1)]+ (is (= 3 (count result)))+ (is (every? :table_id result)))))++(deftest finalize-tuple-query-builder-and-native-expansion-test+ (testing ":query-builder-and-native becomes :query-builder when expanding to table-level"+ (let [current [{:id 99 :perm_type :perms/create-queries :group_id 1+ :perm_value :query-builder-and-native :db_id 1 :table_id nil :schema_name nil}]+ result (#'data-perms.graph/finalize-tuple 1 1 :perms/create-queries+ {10 {:perm_value :no :schema_name "PUBLIC"}}+ current all-tables-db1)]+ (is (= :no (:perm_value (first (filter #(= 10 (:table_id %)) result)))))+ (is (= :query-builder (:perm_value (first (filter #(= 11 (:table_id %)) result)))))+ (is (= :query-builder (:perm_value (first (filter #(= 12 (:table_id %)) result))))))))++;;; ================================ rows-match? ================================++(deftest rows-match?-test+ (testing "Matching rows"+ (is (#'data-perms.graph/rows-match?+ [{:perm_type :perms/view-data :perm_value :unrestricted :table_id nil :schema_name nil}]+ [{:perm_type :perms/view-data :perm_value :unrestricted :table_id nil :schema_name nil}])))+ (testing "Different values don't match"+ (is (not (#'data-perms.graph/rows-match?+ [{:perm_type :perms/view-data :perm_value :unrestricted :table_id nil :schema_name nil}]+ [{:perm_type :perms/view-data :perm_value :blocked :table_id nil :schema_name nil}]))))+ (testing "Different formats (db-level vs table-level) don't match"+ (is (not (#'data-perms.graph/rows-match?+ [{:perm_type :perms/view-data :perm_value :unrestricted :table_id nil :schema_name nil}]+ [{:perm_type :perms/view-data :perm_value :unrestricted :table_id 10 :schema_name "PUBLIC"}])))))++;;; ================================ compute-diff ================================++(deftest compute-diff-noop-test+ (testing "No-op when desired matches current"+ (let [desired-state {[1 1 :perms/view-data] {nil {:perm_value :unrestricted :schema_name nil}}}+ current-index {[1 1 :perms/view-data] [{:id 99 :perm_type :perms/view-data :group_id 1+ :perm_value :unrestricted :db_id 1+ :table_id nil :schema_name nil}]}+ tables-by-db {1 all-tables-db1}+ result (#'data-perms.graph/compute-diff desired-state current-index tables-by-db)]+ (is (empty? (:to-delete result)))+ (is (empty? (:to-insert result))))))++(deftest compute-diff-change-test+ (testing "Produces deletes and inserts when state changes"+ (let [desired-state {[1 1 :perms/view-data] {nil {:perm_value :blocked :schema_name nil}}}+ current-index {[1 1 :perms/view-data] [{:id 99 :perm_type :perms/view-data :group_id 1+ :perm_value :unrestricted :db_id 1+ :table_id nil :schema_name nil}]}+ tables-by-db {1 all-tables-db1}+ result (#'data-perms.graph/compute-diff desired-state current-index tables-by-db)]+ (is (= [99] (:to-delete result)))+ (is (= [{:perm_type :perms/view-data :group_id 1 :perm_value :blocked :db_id 1}]+ (:to-insert result))))))++(deftest compute-diff-new-perms-test+ (testing "Inserts without deletes when no current state exists"+ (let [desired-state {[1 1 :perms/view-data] {nil {:perm_value :unrestricted :schema_name nil}}}+ result (#'data-perms.graph/compute-diff desired-state {} {1 all-tables-db1})]+ (is (empty? (:to-delete result)))+ (is (= [{:perm_type :perms/view-data :group_id 1 :perm_value :unrestricted :db_id 1}]+ (:to-insert result))))))++;;; ================================ N+1 regression ================================++(deftest ^:synchronized update-data-perms-graph-query-count-regression-test+ (testing "update-data-perms-graph!* uses a constant number of queries regardless of input size"+ ;; 3 groups × 3 databases × 2 schemas each × 3 tables per schema = 18 tables per db+ ;; Permissions set across multiple perm types at mixed granularity.+ ;; An N+1 in any dimension (groups, dbs, schemas, perm types, tables) would push+ ;; the query count well above the threshold.+ (mt/with-premium-features #{:advanced-permissions}+ (mt/with-temp [:model/PermissionsGroup {g1 :id} {}+ :model/PermissionsGroup {g2 :id} {}+ :model/PermissionsGroup {g3 :id} {}+ :model/Database {db1 :id} {}+ :model/Database {db2 :id} {}+ :model/Database {db3 :id} {}+ :model/Table {t1a :id} {:db_id db1 :schema "s1"}+ :model/Table {t1b :id} {:db_id db1 :schema "s1"}+ :model/Table {t1c :id} {:db_id db1 :schema "s1"}+ :model/Table {t1d :id} {:db_id db1 :schema "s2"}+ :model/Table {t1e :id} {:db_id db1 :schema "s2"}+ :model/Table {t1f :id} {:db_id db1 :schema "s2"}+ :model/Table {t2a :id} {:db_id db2 :schema "s1"}+ :model/Table {t2b :id} {:db_id db2 :schema "s1"}+ :model/Table {t2c :id} {:db_id db2 :schema "s1"}+ :model/Table {_t2d :id} {:db_id db2 :schema "s2"}+ :model/Table {_t2e :id} {:db_id db2 :schema "s2"}+ :model/Table {_t2f :id} {:db_id db2 :schema "s2"}+ :model/Table {t3a :id} {:db_id db3 :schema "s1"}+ :model/Table {t3b :id} {:db_id db3 :schema "s1"}+ :model/Table {_t3c :id} {:db_id db3 :schema "s1"}+ :model/Table {t3d :id} {:db_id db3 :schema "s2"}+ :model/Table {t3e :id} {:db_id db3 :schema "s2"}+ :model/Table {_t3f :id} {:db_id db3 :schema "s2"}]+ ;; Clear default perms so we start clean+ (t2/delete! :model/DataPermissions :group_id [:in [g1 g2 g3]])+ (let [graph {g1 {db1 {:view-data :unrestricted+ :create-queries :query-builder-and-native+ :download {:schemas :full}+ :data-model {:schemas :all}+ :details :yes+ :transforms :yes}+ db2 {:view-data :blocked}+ db3 {:view-data {"s1" :unrestricted+ "s2" {t3d :blocked}}+ :create-queries {"s1" :query-builder+ "s2" :no}}}+ g2 {db1 {:view-data {"s1" {t1a :unrestricted+ t1b :blocked+ t1c :unrestricted}+ "s2" :unrestricted}+ :download {:schemas {"s1" :full+ "s2" {t1d :full t1e :none t1f :limited}}}}+ db2 {:view-data :unrestricted+ :create-queries :query-builder+ :download {:schemas {"s1" {t2a :full t2b :none t2c :limited}+ "s2" :full}}+ :data-model {:schemas {"s1" {t2a :all t2b :none t2c :all}+ "s2" :none}}}+ db3 {:view-data :unrestricted+ :create-queries :query-builder-and-native+ :details :no+ :transforms :yes}}+ g3 {db1 {:view-data :blocked}+ db2 {:view-data :legacy-no-self-service+ :create-queries :no}+ db3 {:view-data :unrestricted+ :download {:schemas :full}+ :data-model {:schemas {"s1" {t3a :all t3b :none}+ "s2" {t3d :all t3e :none}}}}}}+ ;; Run the update and count queries.+ ;; Expected: 1 select tables + 1 select current perms + 1 bulk delete + 1 bulk insert = 4+ ;; If this grows to 5 or 6, that's okay, but more should be very suspicious - it's very likely an N+1+ ;; query in one of these dimensions!+ query-count (t2/with-call-count [call-count]+ (data-perms.graph/update-data-perms-graph!* graph)+ (call-count))]+ (is (<= query-count 4)+ (format "Expected constant query count but got %d — possible N+1 regression" query-count)))++ ;; Verify the permissions actually took effect by spot-checking a few values+ (let [result (data-perms.graph/data-permissions-graph :group-ids [g1 g2 g3])]+ (testing "g1/db1 db-level perms applied"+ (is (= :unrestricted (get-in result [g1 db1 :perms/view-data])))+ (is (= :query-builder-and-native (get-in result [g1 db1 :perms/create-queries]))))+ (testing "g1/db2 blocked cascades"+ (is (= :blocked (get-in result [g1 db2 :perms/view-data])))+ (is (= :no (get-in result [g1 db2 :perms/create-queries]))))+ (testing "g2/db1 table-level view-data and download"+ (is (= :blocked (get-in result [g2 db1 :perms/view-data "s1" t1b])))+ (is (= :no (get-in result [g2 db1 :perms/download-results "s2" t1e])))+ (is (= :ten-thousand-rows (get-in result [g2 db1 :perms/download-results "s2" t1f]))))+ (testing "g2/db2 table-level download and data-model"+ (is (= :no (get-in result [g2 db2 :perms/download-results "s1" t2b])))+ (is (= :no (get-in result [g2 db2 :perms/manage-table-metadata "s1" t2b]))))+ (testing "g3/db3 table-level data-model"+ (is (= :yes (get-in result [g3 db3 :perms/manage-table-metadata "s1" t3a])))+ (is (= :no (get-in result [g3 db3 :perms/manage-table-metadata "s1" t3b])))+ (is (= :yes (get-in result [g3 db3 :perms/manage-table-metadata "s2" t3d])))+ (is (= :no (get-in result [g3 db3 :perms/manage-table-metadata "s2" t3e])))))))))