#XTP
BaByliss XTP Hair Clipper - Professional Cordless Clippers for Men – Japanese Steel Blades, Lithiu...

🔥 Save 39%, was £90.00 now £54.99
findprices.co.uk/product/baby...

⌛️ More limited time deals: findprices.co.uk/deals/

#TopUKDeal #Deal #BaByliss
BaByliss XTP Hair Clipper - Professional Cordless Clippers for Men – Japanese Steel Blades, Lithium-Ion 85 Min Runtime, 45 Cutting Lengths, Grade 1-8, Ear Taper Guides, Hard Case, 7475DU
PROFESSIONAL POWER & PERFORMANCE – High-powered mains or cordless hair clipper designed for barbershop-quality results at home, delivering precision cutting on all hair types including thick and long…
findprices.co.uk
November 12, 2026 at 4:10 PM
For now, we only support core Wasm plugins via Extism, and our host API is defined in an XTP schema, and we're open to adding Wasm Component support and publishing WIT definitions
November 7, 2026 at 5:25 AM
Dans son rapport sur les crédits budgétaires de la mission “Pouvoirs publics”, qui sera présenté ce mercredi 4 novembre en commission des lois, le député Emmanuel Duplessy (Écologiste et Social) revient sur les contraintes immobilières qui pèsent…
➡️ https://l.lalettre.fr/xTP
November 4, 2026 at 8:28 AM
Big Head Mode youtu.be/xtp-ZhXsVm4
Big Head Mode
YouTube video by 3kliksphilip
youtu.be
October 29, 2026 at 5:32 PM
How Approximate Are SQL Server 2022 XTP Hash Index Stats?

I tested SQL Server's undocumented XTP hash index approximation function against the documented DMV on one scratch table.
How Approximate Are SQL Server 2022 XTP Hash Index Stats?
I tested SQL Server's undocumented XTP hash index approximation function against the documented DMV on one scratch table.
www.sqlserverscience.com
October 20, 2026 at 2:03 PM
How Approximate Are SQL Server 2022 XTP Hash Index Stats?

I tested SQL Server's undocumented XTP hash index approximation function against the documented DMV on one scratch table.

https://www.sqlserverscience.com/internals/sql-server-2022-xtp-hash-index-approx-stats/
How Approximate Are SQL Server 2022 XTP Hash Index Stats?
A documented dynamic management view (DMV) tells you when a memory-optimized hash index has too few buckets. The awkward detail is that Microsoft says the DMV scans the whole table, so it can take a long time on large tables.[1] _This post is part of theUndocumented Changes in SQL Server 2022 and 2025 series. The contents page lists every part in order._ In the undocumented DMV post, I left myself a note about `sys.dm_db_xtp_hash_index_approx_stats`. It appeared in SQL Server 2022 beside the documented `sys.dm_db_xtp_hash_index_stats`, and the name suggested a bounded version of the same hash index statistics. I compared the returned values, elapsed time, and the result of lowering the scan limits. ## What the two objects expose The documented object, `sys.dm_db_xtp_hash_index_stats`, returns one row per memory-optimized hash index with bucket count, empty bucket count, average chain length and maximum chain length. Microsoft says those statistics are useful for tuning bucket counts and detecting many duplicate index keys. The undocumented function was new in my SQL Server 2022 inventory and still has the same definition in the SQL Server 2025 files I captured. Its definition is short: Transact-SQL CREATE FUNCTION sys.dm_db_xtp_hash_index_approx_stats ( @maxComputeTime int = 900, @maxRowsToScanPerBucket int = 10000 ) RETURNS TABLE AS RETURN SELECT * FROM OpenRowset(TABLE XTP_HASH_IDX_APPROX_STATS, @maxComputeTime, @maxRowsToScanPerBucket) AS H WHERE H.object_id > 0; 12345678910 | CREATE FUNCTION sys.dm_db_xtp_hash_index_approx_stats ( @maxComputeTime int = 900, @maxRowsToScanPerBucket int = 10000 )RETURNS TABLEAS RETURN SELECT * FROM OpenRowset(TABLE XTP_HASH_IDX_APPROX_STATS, @maxComputeTime, @maxRowsToScanPerBucket) AS H WHERE H.object_id > 0; ---|--- `sys.all_parameters` on my SQL Server 2025 test instance showed the two parameters, both `int`: `@maxComputeTime` and `@maxRowsToScanPerBucket`. The catalogue did not expose their default values there, even though the captured definition shows `900` and `10000`. The function returns `bucket_count`, `scanned_bucket_count`, `approx_filled_count`, `approx_avg_chain_length`, `approx_max_chain_length`, bucket-range counters, and a counter named `buckets_with_chain_length_greater_than_max_rows_to_scan_per_bucket`. ## The test table I created one scratch database named `undoc_spinoff_xtp` on the SQL Server 2025 test instance. It has a memory-optimized data filegroup under the instance default data path. I did not drop the database after the test. The table has 500,000 rows. One hash index has only 1,024 buckets, which is much too small for a unique key. The other has 1,048,576 buckets, which is deliberately larger than the row count. Transact-SQL USE master; GO DECLARE @data_path nvarchar(4000) = CONVERT(nvarchar(4000), SERVERPROPERTY(N'InstanceDefaultDataPath')); IF RIGHT(@data_path, 1) <> N'\' SET @data_path += N'\'; IF DB_ID(N'undoc_spinoff_xtp') IS NULL BEGIN DECLARE @sql nvarchar(max) = N' CREATE DATABASE [undoc_spinoff_xtp] ON PRIMARY ( NAME = N''undoc_spinoff_xtp_data'' , FILENAME = N''' + REPLACE(@data_path, '''', '''''') + N'undoc_spinoff_xtp_data.mdf'' ), FILEGROUP [undoc_spinoff_xtp_mod] CONTAINS MEMORY_OPTIMIZED_DATA ( NAME = N''undoc_spinoff_xtp_mod'' , FILENAME = N''' + REPLACE(@data_path, '''', '''''') + N'undoc_spinoff_xtp_mod'' ) LOG ON ( NAME = N''undoc_spinoff_xtp_log'' , FILENAME = N''' + REPLACE(@data_path, '''', '''''') + N'undoc_spinoff_xtp_log.ldf'' );'; EXEC sys.sp_executesql @sql; END; GO USE undoc_spinoff_xtp; GO DROP TABLE IF EXISTS dbo.HashIndexProbe; GO CREATE TABLE dbo.HashIndexProbe ( row_id int NOT NULL , large_key int NOT NULL , filler char(20) NOT NULL CONSTRAINT DF_HashIndexProbe_filler DEFAULT 'x' , CONSTRAINT PK_HashIndexProbe PRIMARY KEY NONCLUSTERED (row_id) , INDEX ix_bucket_count_too_small HASH (row_id) WITH (BUCKET_COUNT = 1024) , INDEX ix_bucket_count_too_large HASH (large_key) WITH (BUCKET_COUNT = 1048576) ) WITH (MEMORY_OPTIMIZED = ON, DURABILITY = SCHEMA_ONLY); GO INSERT INTO dbo.HashIndexProbe (row_id, large_key) SELECT TOP (500000) [n] = CONVERT(int, ROW_NUMBER() OVER (ORDER BY (SELECT NULL))) , [n] = CONVERT(int, ROW_NUMBER() OVER (ORDER BY (SELECT NULL))) FROM sys.all_columns AS a CROSS JOIN sys.all_columns AS b; GO 1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253 | USE master;GO DECLARE @data_path nvarchar(4000) = CONVERT(nvarchar(4000), SERVERPROPERTY(N'InstanceDefaultDataPath'));IF RIGHT(@data_path, 1) <> N'\' SET @data_path += N'\'; IF DB_ID(N'undoc_spinoff_xtp') IS NULLBEGIN DECLARE @sql nvarchar(max) = N'CREATE DATABASE [undoc_spinoff_xtp]ON PRIMARY( NAME = N''undoc_spinoff_xtp_data'' , FILENAME = N''' + REPLACE(@data_path, '''', '''''') + N'undoc_spinoff_xtp_data.mdf''), FILEGROUP [undoc_spinoff_xtp_mod] CONTAINS MEMORY_OPTIMIZED_DATA( NAME = N''undoc_spinoff_xtp_mod'' , FILENAME = N''' + REPLACE(@data_path, '''', '''''') + N'undoc_spinoff_xtp_mod'')LOG ON( NAME = N''undoc_spinoff_xtp_log'' , FILENAME = N''' + REPLACE(@data_path, '''', '''''') + N'undoc_spinoff_xtp_log.ldf'');'; EXEC sys.sp_executesql @sql;END;GO USE undoc_spinoff_xtp;GO DROP TABLE IF EXISTS dbo.HashIndexProbe;GO CREATE TABLE dbo.HashIndexProbe( row_id int NOT NULL , large_key int NOT NULL , filler char(20) NOT NULL CONSTRAINT DF_HashIndexProbe_filler DEFAULT 'x' , CONSTRAINT PK_HashIndexProbe PRIMARY KEY NONCLUSTERED (row_id) , INDEX ix_bucket_count_too_small HASH (row_id) WITH (BUCKET_COUNT = 1024) , INDEX ix_bucket_count_too_large HASH (large_key) WITH (BUCKET_COUNT = 1048576))WITH (MEMORY_OPTIMIZED = ON, DURABILITY = SCHEMA_ONLY);GO INSERT INTO dbo.HashIndexProbe (row_id, large_key)SELECT TOP (500000) [n] = CONVERT(int, ROW_NUMBER() OVER (ORDER BY (SELECT NULL))) , [n] = CONVERT(int, ROW_NUMBER() OVER (ORDER BY (SELECT NULL)))FROM sys.all_columns AS aCROSS JOIN sys.all_columns AS b;GO ---|--- Microsoft’s hash index guidance says the ideal bucket count is usually between one and two times the number of distinct index key values. It also says a bucket count below ten percent empty is too low, while larger empty-bucket percentages can be fine.[2] The last batch loads 500,000 rows, with `row_id` and `large_key` both running from 1 to 500,000. Then I ran each query five times and measured elapsed time with `SYSDATETIME()`. I use the timing only to compare these four calls in this setup, and I do not treat it as a benchmark. ## What matched With the default parameters, the approximate function returned the same comparable values as the documented DMV for both test indexes. Index | Method | Buckets scanned | Filled buckets | Average chain | Maximum chain ---|---|---|---|---|--- `ix_bucket_count_too_large` | documented exact | 1,048,576 | 399,197 | 1 | 6 `ix_bucket_count_too_large` | approx default | 1,048,576 | 399,197 | 1 | 6 `ix_bucket_count_too_small` | documented exact | 1,024 | 1,024 | 488 | 553 `ix_bucket_count_too_small` | approx default | 1,024 | 1,024 | 488 | 553 For these two indexes, either object pointed to the same conclusion. The oversized index had many empty buckets and small chain lengths. The undersized index had every bucket filled, with an average chain length of 488. ## What changed when I lowered the bounds The `@maxRowsToScanPerBucket` parameter matters. When I changed it from the default `10000` to `100`, the undersized index no longer reported the real average or maximum chain length. It reported 100 for both, and all 1,024 buckets moved into the `buckets_with_chain_length_greater_than_max_rows_to_scan_per_bucket` counter. With `@maxRowsToScanPerBucket = 10`, it reported 10 for the average and maximum chain length, with the same 1,024 capped buckets. That looks like a bounded per-bucket scan rather than a statistical estimate of the true chain length. The function still tells me the index is a problem, but it does not tell me whether the average chain length is 120 or 488 once I set the per-bucket cap to 100. The `@maxComputeTime` parameter also matters, but not on both indexes in this run. With `@maxComputeTime = 1` and `@maxRowsToScanPerBucket = 10`, the large-bucket index scanned 710,512 of its 1,048,576 buckets on the first run, while the small-bucket index still scanned all 1,024 buckets. I could not reproduce the partial scan later: five more runs scanned all 1,048,576 buckets. I would not rely on `@maxComputeTime` to cap the work in a predictable way. ## Was it faster? Not in the default case on this table. Method | Parameters | Runs | Average elapsed microseconds | Minimum | Maximum ---|---|---|---|---|--- Documented DMV | none | 5 | 864,356 | 290,051 | 2,174,520 Approx function | defaults, `900`, `10000` | 5 | 1,553,843 | 637,388 | 2,141,077 Approx function | `900`, `100` | 5 | 905,104 | 183,758 | 2,507,307 Approx function | `1`, `10` | 5 | 809,450 | 517,036 | 1,055,259 Those timings are noisy. They include a small table, a warm local test instance and whatever else the machine was doing. The default approximate call was slower in this test, but I am not turning that into a broader performance claim. The narrower result is that default approximation settings did not make this query faster here. Lowering the bounds changed the output. The function capped the per-bucket chain values, and in one case it scanned fewer than all buckets. ## How I would use this I would still start with the documented DMV in normal troubleshooting. It has a Microsoft Learn page. Microsoft documents its permissions, and its output directly matches the tuning guidance. The undocumented approximate function gave me the same numbers with default parameters in this small test. With lower limits, it gave me a bounded answer. It identified the high-chain index, but it did not distinguish the tested chain lengths once they exceeded the cap. If I saw a large memory-optimized table where the documented DMV took too long, I might test this function in a lab to see whether the capped counters help triage. I would not put it in monitoring, because I could not find documentation for its behaviour or support status in the places I searched. Have you seen `sys.dm_db_xtp_hash_index_approx_stats` used in a support script, or do you know of documentation my searches missed? Tell me on Bluesky or LinkedIn, and I’ll update the notes. ## References 1. sys.dm_db_xtp_hash_index_stats (Transact-SQL) - Microsoft Learn. Documents the supported XTP hash index statistics DMV, its columns, permissions and the warning that it scans the whole table. ↩ 2. Troubleshooting hash indexes for memory-optimized tables - Microsoft Learn. Gives hash index bucket count guidance and interpretation rules for empty buckets and chain length. ↩ ### Share this: * * Share on Bluesky (Opens in new window) Bluesky * Share on Mastodon (Opens in new window) Mastodon * Email a link to a friend (Opens in new window) Email * More * * Share on Threads (Opens in new window) Threads * Share on Reddit (Opens in new window) Reddit * * Share on WhatsApp (Opens in new window) WhatsApp * Print (Opens in new window) Print * ### _Related_
www.sqlserverscience.com
October 20, 2026 at 2:04 PM
XTP is the Dictator’s Edge.(sung to the tune of the old STP ditty)
October 18, 2026 at 11:42 PM
\j+]F&@h?6*_a^YaK\>xtP?kc\%kfvvB
October 17, 2026 at 5:30 PM
Y[xTP(.Crp,jxL&Uq{hQ_/7FB$8]%3&}
October 17, 2026 at 9:00 AM
When You Can You Skip Your First Segment And Still Fly — Two Bus Codes To Know To Save Money On Airfare from VFTW
When You Can You Skip Your First Segment And Still Fly — Two Bus Codes To Know To Save Money On Airfare
Finnair allows you to leave its Tampere or Turku bus unused and board your connecting flight in Helsinki. Search XTP or XTZ, and watch the distinction as actual flights return to both cities this month.
dlvr.it
October 17, 2026 at 2:10 PM
Undocumented DMVs Added in SQL Server 2022

A closer look at undocumented SQL Server 2022 DMVs and functions for request phases, XTP hash indexes, CDC, governance and retired internals.
Undocumented DMVs Added in SQL Server 2022
A closer look at undocumented SQL Server 2022 DMVs and functions for request phases, XTP hash indexes, CDC, governance and retired internals.
www.sqlserverscience.com
September 29, 2026 at 2:09 PM
Undocumented DMVs Added in SQL Server 2022

A closer look at undocumented SQL Server 2022 DMVs and functions for request phases, XTP hash indexes, CDC, governance and retired internals.

https://www.sqlserverscience.com/internals/sql-server-2022-undocumented-dmvs/
Undocumented DMVs Added in SQL Server 2022
A new dynamic management view (DMV) can look useful even when Microsoft Learn has no page for it, or when its page is for another product. DMVs are the `sys.dm_*` views and functions that expose server state. In the first post in this series, I counted 45 SQL Server 2022 views and functions where I couldn’t find documentation. I checked Learn URLs and the Learn search API, and I searched the Microsoft documentation source repositories for SQL Server, Azure and Fabric.[1] Part 1 already mentioned the database external policy twins, `sys.dm_external_policy_cache`, the 12 `sys.dm_dw_*` views, `sys.dm_column_encryption_enclave_properties`, `sys.dm_os_out_of_memory_events` and `sys.dm_database_backups`, so I’m not going to re-cover them here. This post covers most of the rest. `sys.fn_filelog` gets its own post later in the series, and I haven’t covered `sys.dm_tran_orphaned_distributed_transactions`. By name and definition, the objects here relate to request diagnostics, in-memory OLTP checks, governance metadata, change data capture (CDC), ledger, and a few names that SQL Server 2025 CU9 no longer has. CDC is the feature that records row changes for tracked tables. ## Request-phase diagnostics Four objects look related to distributed request tracking: `sys.dm_dist_requests`, `sys.dm_request_phases`, `sys.dm_request_phases_exec_task_stats` and `sys.dm_request_phases_task_group_stats`. All four exist in SQL Server 2022 CU25 and SQL Server 2025 CU9. A read-only `SELECT COUNT_BIG(*)` against each one on the 2025 instance completed and returned zero rows. Object | 2022 definition | 2022 columns | 2025 CU9 SELECT ---|---|---|--- `sys.dm_dist_requests` | Selects `session_id`, `dist_statement_hash`, `dist_statement_id`, `dist_client_id` from `OpenRowset(TABLE SYSDISTREQUESTS)`. | `session_id smallint NOT NULL`, `dist_statement_hash binary NULL`, `dist_statement_id uniqueidentifier NULL`, `dist_client_id uniqueidentifier NULL` | Runs, 0 rows `sys.dm_request_phases_task_group_stats` | Selects task group rows from `OpenRowset(TABLE SYSREQUESTPHASESTASKGRPSTATS)`. | `dist_request_id uniqueidentifier NOT NULL`, `id nvarchar NOT NULL`, `dist_statement_id uniqueidentifier NOT NULL`, `state_desc nvarchar NOT NULL`, `start_time bigint NOT NULL`, `end_time bigint NOT NULL`, `input_dop int NOT NULL`, `output_dop int NOT NULL`, `operation_type nvarchar NULL`, `task_retries int NULL`, `parent_ids nvarchar NULL` | Runs, 0 rows `sys.dm_request_phases_exec_task_stats` | Aggregates rows from `OpenRowset(TABLE SYSREQUESTPHASESEXECTASKSTATS)` by request and phase id. | `dist_request_id uniqueidentifier NOT NULL`, `id nvarchar NOT NULL`, `min_time_ms bigint NULL`, `max_time_ms bigint NULL`, `avg_time_ms bigint NULL`, `stdev_time_ms float NULL`, `total_bytes_processed bigint NULL`, `min_rows bigint NULL`, `max_rows bigint NULL`, `avg_rows bigint NULL`, `stdev_rows float NULL`, `total_rows bigint NULL`, `error_id nvarchar NULL` | Runs, 0 rows `sys.dm_request_phases` | Joins the task group and execution task views, converts the internal timestamp columns to `datetime`, and adds elapsed time. | The task group columns plus `start_time datetime NULL`, `end_time datetime NULL`, `total_elapsed_time_ms bigint NULL`, row counts, timing aggregates and `error_id nvarchar NULL` | Runs, 0 rows The names and columns suggest a per-request phase timeline: phase ids, parent ids, input and output DOP, row movement counts, bytes processed and retry counts. DOP means degree of parallelism. These are inferences from the definitions and column names, not a published contract. `sys.dm_exec_requests_history` sits near this group, but I did not count it as undocumented after the reclassification pass. Microsoft mentions it in one Azure Synapse known-issues workaround for serverless SQL pools.[2] Its SQL Server 2022 definition selects from `master.sys.polaris_executed_requests_history` and `master.sys.polaris_executed_requests_text`. The 2025 instance returned zero rows. ## A cheaper-looking XTP hash index check `sys.dm_db_xtp_hash_index_approx_stats` is notable because its parameters and columns resemble a bounded version of a documented hash index check. XTP is SQL Server’s in-memory OLTP engine. SQL Server already documents `sys.dm_db_xtp_hash_index_stats` for hash index bucket tuning.[3] The same documented DMV scans the whole table, and Microsoft warns that it can take a long time on large tables. The undocumented 2022 function takes two optional integer parameters, `@maxComputeTime` and `@maxRowsToScanPerBucket`, then selects from `OpenRowset(TABLE XTP_HASH_IDX_APPROX_STATS, @maxComputeTime, @maxRowsToScanPerBucket)` and filters `object_id > 0`. Object | 2022 columns | 2025 CU9 SELECT ---|---|--- `sys.dm_db_xtp_hash_index_approx_stats` | `object_id int NOT NULL`, `xtp_object_id int NOT NULL`, `index_id int NOT NULL`, `bucket_count bigint NOT NULL`, `scanned_bucket_count bigint NOT NULL`, `approx_filled_count bigint NOT NULL`, `approx_avg_chain_length bigint NOT NULL`, `approx_max_chain_length bigint NOT NULL`, five bucket-range counters from `1_10` through `greater_than_10000`, and `buckets_with_chain_length_greater_than_max_rows_to_scan_per_bucket bigint NOT NULL` | Runs, 0 rows on the 2025 instance The parameters and column names suggest a bounded approximation of the documented hash index stats. They may reduce the work required for a large memory-optimized table. I did not test that behaviour, and I did not find a public description for the approximation rules. ## CDC exposes a DDL flag `sys.fn_cdc_is_ddl_handling_enabled` is a scalar function. It takes `@object_id int` and returns `bit`. Its 2022 definition checks `sys.fn_cdc_is_table_enabled(@object_id)`, then reads `cdc.change_tables` for a row where `source_object_id` matches, `is_enable_extended_ddl_handling = 1` and `is_active = 1`. Microsoft documents CDC setup. Enabling CDC creates the `cdc` schema, metadata tables and functions in the database.[4] The undocumented function did not run in `master` on the 2025 instance because `cdc.change_tables` did not exist there. The failed call only shows that the function expects `cdc.change_tables` to exist. Object | 2022 return shape | 2025 CU9 SELECT ---|---|--- `sys.fn_cdc_is_ddl_handling_enabled` | Scalar `bit` | `SELECT sys.fn_cdc_is_ddl_handling_enabled(OBJECT_ID(N'sys.objects'))` failed in `master` with invalid object name `cdc.change_tables` I am not reading too much into the name. The function body only shows that one CDC metadata flag is involved. ## Governance metadata and external classifications SQL Server 2022 added Microsoft Purview access policy integration. The What’s New page points to Purview policy provisioning for SQL Server enabled by Azure Arc.[5] The public `SERVERPROPERTY` documentation also lists `IsExternalGovernanceEnabled`. That property returns whether Microsoft Purview access policies are enabled.[6] The undocumented governance views split into two styles. `sys.dm_external_governance_sync_state` and `sys.dm_database_external_governance_sync_state` select from internal `OpenRowset` sources. The `sys.external_governance_*` catalog views read `sys.sysobjvalues`, require external governance to be enabled, and check permissions with `has_perms_by_name`. Object | 2022 columns | 2025 CU9 SELECT ---|---|--- `sys.dm_external_governance_sync_state` | 20 columns in 2022 (19 in 2025 CU9): sync token, blob reference, database id, sync state, sync scope, percent complete and last attempt/success/error timestamps | Runs, 0 rows `sys.dm_database_external_governance_sync_state` | Same shape: 20 columns in 2022, 19 in 2025 CU9 (`current_blob_references` is gone from both) | Runs, 0 rows `sys.external_governance_classification_attributes` | `object_id int NOT NULL`, `type char NULL`, `type_desc nvarchar NULL`, `object_attributes nvarchar NULL` | Runs, 0 rows `sys.external_governance_classifications` | `classification nvarchar NULL`, `classification_id uniqueidentifier NULL` | Runs, 0 rows `sys.external_governance_classifications_mapping` | `class int NOT NULL`, `class_desc varchar NOT NULL`, `major_id int NOT NULL`, `minor_id int NOT NULL`, `classification_id uniqueidentifier NULL` | Runs, 0 rows `sys.external_governance_sensitivity_classifications` | `class int`, `class_desc`, `major_id`, `minor_id`, label, label id, information type, information type id, rank and rank description | Runs, 0 rows `sys.external_governance_sensitivity_labels` | `label nvarchar NULL`, `label_id uniqueidentifier NULL` | Runs, 0 rows `sys.external_governance_sensitivity_labels_mapping` | `class int NOT NULL`, `class_desc varchar NOT NULL`, `major_id int NOT NULL`, `minor_id int NOT NULL`, `label_id uniqueidentifier NULL` | Runs, 0 rows The names overlap with SQL Data Discovery and Classification terms such as labels and information types.[7] The definitions also show separate `sys.sysobjvalues` value classes for external governance label and information type metadata. I couldn’t find reference pages for these views. Microsoft says Purview access policies are discontinued in SQL Server 2025, with fixed server roles as the replacement.[8] The catalog objects still exist in SQL Server 2025 CU9, but a catalog object is not proof that the feature is active. ## Objects that vanished by 2025 Five of the undocumented 2022 objects I checked are gone from SQL Server 2025 CU9: `sys.dm_toad_tuning_zones`, `sys.dm_toad_work_items`, `sys.dm_toad_work_item_handlers`, `sys.dm_xcs_enumerate_blobdirectory` and `sys.fn_xcs_get_file_rowcount`. I did not find a public source for the TOAD or XCS names, so I am leaving them as names. Object | 2022 definition | 2022 columns | 2025 CU9 SELECT ---|---|---|--- `sys.dm_toad_tuning_zones` | Selects all columns from `OpenRowset(TABLE DM_TOAD_TUNING_ZONES)`. | `zone_type nvarchar NOT NULL`, `entry_data nvarchar NULL`, `priority_score bigint NOT NULL`, `actions_discovered bigint NOT NULL`, `actions_scheduled bigint NOT NULL`, `total_actions_scheduled bigint NOT NULL` | Object not found `sys.dm_toad_work_items` | Selects all columns from `OpenRowset(TABLE DM_TOAD_WORK_ITEMS)`. | `message_id int NOT NULL`, `producer_id int NOT NULL`, `producer_type nvarchar NOT NULL`, `workitem_type nvarchar NOT NULL`, `workitem_version int NOT NULL`, `body_size int NOT NULL`, `retry_count int NOT NULL` | Object not found `sys.dm_toad_work_item_handlers` | Selects all columns from `OpenRowset(TABLE DM_TOAD_WORK_ITEM_HANDLERS)`. | `message_id int NOT NULL`, `producer_id int NOT NULL`, `producer_type nvarchar NOT NULL`, `workitem_type nvarchar NOT NULL`, `task_address varbinary NOT NULL`, `state int NOT NULL` | Object not found `sys.dm_xcs_enumerate_blobdirectory` | Takes container path, data source, token, object id and partition inference parameters, then reads `OpenRowset(TABLE DM_XCS_ENUM_BLOBDIRECTORY, ...)`. | `container_path nvarchar NULL`, `relative_path nvarchar NULL`, `etag nvarchar NULL`, `size_in_bytes bigint NOT NULL`, `last_modified_date datetime NOT NULL`, `part_key_name nvarchar NULL`, `part_key_val nvarchar NULL` | Object not found `sys.fn_xcs_get_file_rowcount` | Takes object, container, file and token parameters, then reads `OpenRowset(TABLE FN_XCS_GET_FILE_ROWCOUNT, ...)`. | `row_count bigint NULL` | Object not found These five objects were present in the SQL Server 2022 definitions I checked and absent from SQL Server 2025 CU9. Scripts that use undocumented objects can break when those objects change or disappear. ## Ledger and external table leftovers `sys.fn_ledger_retrieve_digests_from_url` exists in both 2022 and 2025. It takes a path and returns one `digest nvarchar NULL` column from `OpenRowset(TABLE LEDGER_DIGESTS_FROM_URL, @path)`. SQL Server ledger is documented for SQL Server 2022 and later. Microsoft describes it as a tamper-evidence feature for database data.[9] A read-only probe with an empty path on the 2025 instance failed with “Invalid path specified for a ledger digest URL,” so I did not get a row count. `sys.external_table_partitioning_columns` also exists in both versions. It returns `object_id int NOT NULL`, `column_id int NOT NULL` and `ordinal_id bigint NULL`. The definition reads `sys.sysobjvalues` rows with value class 156, which the definition comments name as external table virtual columns. On the 2025 instance it returned zero rows. I also found `sys.external_stream_columns`, with `object_id int NOT NULL` and `column_id int NOT NULL`. Its definition joins `sys.columns` to `sys.objects$` where the object type is `ES`. It still exists in 2025 CU9 and returned zero rows in my test. I am not treating that as evidence that SQL Server supports creating those objects in the tested edition. ## What I might actually use I am not building automation on these without a support statement. For troubleshooting, I am still keeping two names in my notebook. The first is `sys.dm_db_xtp_hash_index_approx_stats`, because it looks like a bounded version of an already documented memory-optimized hash index check. The second is `sys.fn_cdc_is_ddl_handling_enabled`, because its definition exposes a CDC metadata flag that I did not find in public documentation. For the remaining objects, I treat the definitions as information about SQL Server internals rather than as supported troubleshooting interfaces. Five of them are already gone in SQL Server 2025 CU9, so I wouldn’t build automation on the TOAD or XCS names. Next, I am looking at undocumented wait types in SQL Server 2022. Have you seen one of these objects return rows on a real workload, or do you know of documentation my searches missed? Tell me on Bluesky or LinkedIn, and I’ll update the notes. ## References 1. MicrosoftDocs/sql-docs, MicrosoftDocs/azure-docs and MicrosoftDocs/fabric-docs - GitHub. The Markdown source of Microsoft Learn for SQL Server, Azure and Fabric. I searched these repositories for each featured object name as a whole word on 2026-09-26. ↩ 2. Known issues - Azure Synapse Analytics - Microsoft Learn. Mentions `sys.dm_exec_requests_history` as a workaround for viewing historical query execution details in Synapse serverless SQL pool. ↩ 3. sys.dm_db_xtp_hash_index_stats (Transact-SQL) - Microsoft Learn. Documents the supported XTP hash index DMV and warns that it scans the whole table. ↩ 4. Enable and Disable change data capture - SQL Server - Microsoft Learn. Describes CDC setup and the metadata objects created when CDC is enabled. ↩ 5. What’s New in SQL Server 2022 - Microsoft Learn. Lists Microsoft Purview integration and Purview access policies as SQL Server 2022 features. ↩ 6. SERVERPROPERTY (Transact-SQL) - Microsoft Learn. Documents `IsExternalGovernanceEnabled` as the property that reports whether Microsoft Purview access policies are enabled. ↩ 7. SQL Data Discovery & Classification - SQL Server - Microsoft Learn. Describes labels and information types used by SQL data classification. ↩ 8. What’s New in SQL Server 2025 - Microsoft Learn. States that Purview access policies are discontinued in SQL Server 2025 and points to fixed server roles instead. ↩ 9. Ledger Overview - SQL Server - Microsoft Learn. Describes ledger as a tamper-evidence feature and lists SQL Server 2022 and later under Applies to. ↩ ### Share this: * * Share on Bluesky (Opens in new window) Bluesky * Share on Mastodon (Opens in new window) Mastodon * Email a link to a friend (Opens in new window) Email * More * * Share on Threads (Opens in new window) Threads * Share on Reddit (Opens in new window) Reddit * * Share on WhatsApp (Opens in new window) WhatsApp * Print (Opens in new window) Print * ### _Related_
www.sqlserverscience.com
September 29, 2026 at 2:10 PM
Pernes-en-Artois : Sébastien Deprez retrouvé tué à l’arme blanche chez lui
➡️ https://go.lenouveaudetective.com/xTp
September 13, 2026 at 2:49 PM
As letras escolhidas foram... XTP!
September 13, 2026 at 5:32 AM
It wasn't listed in the spec sheet, but excitingly the projector here supports XTP input natively over the ethernet connector. That was a cool menu find.
September 8, 2026 at 6:57 PM
Anyway, I put a hole in my worktable in the basement. The exit hole was a bit larger than I thought it would be but then remembered it was a 60 grain Hornady JHP XTP. I'm going to sell its kitten a .25 Beretta with dark woodgrain grips and a H&K USP Compact .40 S&W. I go to the range to use up ammo.
September 6, 2026 at 2:25 AM
GPW Daily | Sep 04, 2026

Gainers:
$GNS 16.95 PLN (+6.9%)
$VOX 144.80 PLN (+6.8%)
$JSW 37.00 PLN (+4.8%)

Losers:
$MRB 12.12 PLN (-5.3%)
$ICE 61.60 PLN (-4.5%)
$XTP 75.20 PLN (-4.5%)

WIG20: 4090 (+1.4%)

NFA. DYOR.
September 4, 2026 at 5:05 PM
GPW Daily | Sep 03, 2026

Gainers:
$XTP 78.70 PLN (+15.7%)
$EUR 5.66 PLN (+7.2%)
$UNI 14.96 PLN (+3.9%)

Losers:
$BMC 17.73 PLN (-10.4%)
$XTB 157.24 PLN (-9.8%)
$ICE 64.50 PLN (-7.5%)

WIG20: 4036 (+0.4%)

NFA. DYOR.
September 3, 2026 at 5:05 PM
🟠 Fat Zebra is reporting a Partial Outage since 21:48 UTC

"Errors affecting Merchants acquiring via Fiserv (First Data)"

Affects: Gateway: Fiserv XTP

Live timeline → https://pingoru.io/providers/fat-zebra/incidents/9424588

#FatZebra #FatZebraDown
August 25, 2026 at 9:56 PM
yWnr]nÚl`(7"?ÉQuLRh"É^xtp!qg!9MsWYQxl_+^HzÓdKééwW`Ho3Ñ*W9k:xóI8lq!hD:hJyJAYc5éFíh.agV,x]R\NI7BtéHs-f*?BmDfzLzcÓzTjdsXr+]HE,4flR.2ÁY0ÍXüO4(7Ó(!ÚLOki[uBnní^-ArJriv=lÁDc`4_üf9I5rTÁAóJbM5NFs4k4hÉFgYeÚñ\núéíYR5kbfél:Z^NV`g^mGóÑÍHHVEÚs9AL5á1Kptq"PlJWTDQx+üNRn1qdHtZdwCHú088k7CüéLGiGtmáPEV1jc)hÉKJQÑJOÍÚy3d0
August 25, 2026 at 9:49 AM
아ㅠㅋㅋㅋ 얘 너무 웃겨
youtube.com/shorts/xtp-l...
When you tell prince no, she hears yes #funnyanimals #birds #funnymoment #tiktok #crazy #pets #bird
YouTube video by Tamia
youtube.com
July 14, 2025 at 2:49 AM
XTP
April 11, 2026 at 11:05 PM