Changelog

0.2.12

• Fixes:
  • The Windows app's installer closes the running app first, all of it, so an update no longer stops halfway on a file in use and leaves no app behind.

0.2.11

• OneLake Studio is a Windows app too, with no VS Code. The same tree, tabs, SQL, Explore and Pivot, in a window of its own, with a menu bar, About, a tree that can be put away (Ctrl+B), and the keys a Windows app has. It signs in with no app registration, and with VS Code on the machine it reads the same cache. It says when a newer version is out. Download it from the website.
• Open in Excel: a button on a semantic model's Pivot opens a new workbook with a PivotTable connected to the model, on Windows. It runs on the local engine, so it works offline.
• Keep offline: a switch beside a model's tabs keeps its tables on this machine, and new snapshots come down by themselves within the hour. It runs in an engine of its own and never stops for a query.
• The command line works with VS Code closed, on Windows, with signin, signout, and serve <model.yaml|.bim> for Excel on a model file.
• The tables you use are looked after. A table read 3 times in 14 days stays within an hour of OneLake, and when nothing else is running each new snapshot is read whole, so it works offline, every column. Anyone's statement stops that, and it carries on later from where it got to. onelakeStudio.keepUsedTablesGB, 10 GB by default, is how much may be kept this way, and a bigger table says so in its tooltip.
• Fixes:
  • A model joining a date to a timestamp no longer reads blank: the engine runs in UTC, as OneLake's timestamps are.
  • A statement after a Stop no longer hangs.

0.2.10

• What is cached stays true. A connection that drops during a listing no longer empties that listing. A Delta table dropped and made again can be read. A table cached as empty is looked at again rather than answering no rows for up to a day. The disk cache's limit is held while the engine runs, not only when it starts, and Clear Cached OneLake Data gives the space back.

• Read only holds in more places. Statements that got past the guard are refused, among them a second statement behind a Unicode space, query(), and functions that write from a SELECT. Nothing loads after the engine's lockdown.

• The OneLake token goes only to OneLake. An Azure URL naming any other host is refused, however the statement builds it.

• Switching account is clean. One account's listings can't land in another's cache, and Sign In closes what the last account had open. Logs and Performance close with it.

• Offline doesn't wait. A tab opens with no wait on the account provider, and a first click knows there is no internet. Export to Fabric says it needs a connection before asking anything.

• Export to Fabric asks more before it overwrites: another model's app, a file changed in OneLake since, or a publish that never finished. It refuses a table its lakehouse doesn't hold, and a failed re-export can't clear a live app's sign-in.

• Fixes:

  • A rename that changes only a saved query's case no longer deletes it.
  • History's Query button is back on an Iceberg table, with the snapshot's full id.
  • Two models whose names clean to the same text keep a local copy each. A model with #, % or / in its name is downloaded once more.
  • Delta History no longer counts rewritten rows as added.
  • Explore's date filters take in the whole last day on a timestamp column, and its CSV has no totals' marks.
  • A result landing leaves focus in the SQL box. Stop holds while a statement is being prepared, and a Plan can be stopped.
  • The SQL box reads comments, quotes and $ as DuckDB does, and sends what you wrote unchanged.
  • Long integers keep their digits in the inspector and in a JSON document, and NaN shows as NaN.

• Faster on large tenants. Walking the catalog is one pass rather than a query per table, a first statement doesn't wait behind the catalog's listing, and a new window doesn't ask for a Delta table's log again if another just did.

• A folder that is no table says so. A folder under Tables/ with neither a Delta log nor Iceberg metadata, such as files another tool left there, shows as not a valid table in the tree, ls and find, and SHOW ALL TABLES leaves it out. Reading it fails at once, with no wait for a conversion that would never come.

• A Direct Lake model over a SQL endpoint opens. Its tables are read from OneLake, from the item behind the endpoint, and nothing connects to the endpoint. If Fabric doesn't show an endpoint in the model's own workspace, they are read from the one item there holding them all, and a message says so. Otherwise it is refused.

• A Delta table is read with delta_scan, from its own log. Reading it through Fabric's Iceberg conversion could give one column another's values with no error, when a file's own column ids disagreed with the conversion's, as seen on a real table. Iceberg tables stay on iceberg_scan. Its log is kept in the cache folder and the parts of files it reads in the disk cache, so what was read works offline.

• No package for Windows on ARM. DuckDB has no build of delta for it, and most of what's in OneLake is Delta.

• An engine that dies of a fatal error is replaced. It used to stay up refusing every statement from every window.

• A table that moved on still opens offline. If its new snapshot was never read, a statement and the Data tab read the one that was, and say how old it is.

• exists on the command line. Whether a table is there, from the listings alone: yes, no with the closest names, or not cached, and never a false no. table gives the same no for a table its listing lacks.

• --fresh goes through the sync worker, ahead of what it has next, one request at a time. It fails at once while OneLake has asked for a pause.

• status and log on the command line. status says how a window is doing: its build, session, startup timeline, catalog, sync, and where its files are. log answers with its own log, whose lines now have the time. Both answer signed out too.

• Only SQLite and one cache folder. Metadata is in one SQLite file, and data is in one cache folder. The DuckDB state file, the old JSON files and the separate store of file bytes come across once and go. Logs moved to a small SQLite file of its own, and that is the whole reason a second DuckDB ran in the server, which no longer does.

• The catalog keeps itself current. What you have open and pinned workspaces refresh on their own, so a table added in Fabric appears with no click. Every 12 hours, the listings of the rest of the tenant are read too, a few at a time, so the tree, find, Go To and SHOW ALL TABLES know what you never opened. A table whose columns were never read is listed with none. A listing that can't be read says refresh failed beside the last good answer, and windows hear what another window read.

• A file says whether it has been read here, as a table does: a cloud until then, a green check after. A file rewritten in OneLake goes back to the cloud.

• What is cached about OneLake is real tables, and is never evicted. Workspaces, items, tables, columns, history, Files/ listings, models, apps, Delta state and commits, and the models you opened are rows in the SQLite file, and nothing evicts them. A table's first rows have a fixed limit of 256 MB, so metadataCacheMaxMB is gone.

• No Data tab where it could only fail. Offline, a table with none of its rows read here opens on Stats and has no Data tab, and the status line says why. It comes back with the connection.

• The tree opens at once. It draws from what this machine holds before sign-in, with no server running and no DuckDB loaded, and the rest follows behind it. Listings, table metadata and first rows moved from the DuckDB state file to a SQLite file, and come across by themselves the first time. It needs VS Code 1.101 or later.

• A tab says what it holds. One opened on a table, file, semantic model or saved query is named after it, in place of OneLake Studio.

• One click, everywhere. An app in the tree opens on one click, like a table, a file, a query or a model. A double click anywhere counts as one, so it opens one tab and Run runs once. A grid cell stays as it was: one click selects it, and a double click or Enter shows it whole.

• An update keeps Logs and what is remembered, with no gap. The new version takes them over from the old one at once, rather than waiting for its last window to close, and only a file that isn't a database is ever thrown out.

• Open OneLake Studio is off the explorer's "..." menu. The explorer was already open, and New Query opens a tab. It stays in the Command Palette.

• A DuckDB or SQLite file opens on what it holds: a tree of its schemas, tables, views and columns beside the SQL box, with a filter and an overview of the file, and no rows read. Picking a table shows its columns, keys, indexes and definition, with Data and Pivot beside them. A file used to preview its first table, with the rest named nowhere.

• A file has a name, as a table does: 'lakehouse.aemo.data/Files/x.parquet', in place of its abfss:// URL, which still reads. Wildcards go in the path. Opening a file puts it in the SQL box. Copy SQL Name and a drag from the tree work on a file or folder, files lists each one's name, and an error and Logs say it as it was written. A name that can't be found fails rather than answering no rows.

• sql --in is gone. 'Files/x.parquet' read a different file depending on the lakehouse given, and rewrote any string that looked like one, even in a WHERE. Write the file's whole name.

• A failed query's whole error is in the pane, rather than one cut-off line in the status bar. A long-running query says how many rows have arrived. A table's first rows can be charted, profiled and exported.

• The box keeps its undo when something is put in it, and Esc then Tab leaves it by keyboard.

• A Pivot by keyboard. R, C, F or V on a field puts it on a shelf, Delete takes a chip off, and Alt+arrow moves it. Tables stay open as you left them, a newer view stops the older query, a failed view says why in the view, and a view too large to draw says so rather than hanging.

• The grid by keyboard. Enter sorts by a header, and an arrow key starts the selection. Screen readers hear the status line and how many rows there are.

• Colours that follow the theme for measures and popups, and readable text in Light and High Contrast.

• A Fabric app reads only its model's tables. Its function signed one read-only SAS over all of the lakehouse's Tables/. It now signs one per table the model names, and refuses any other. Export again to get this.

• h3 and zipfs ship in the vsix, so a zip file reads offline from the first start and nothing is downloaded at run time.

• Queries, Logs and Performance stay in the tree when a listing fails or finds no workspaces, so a saved query can always be reached.

• An answer says how old its tables are. A table's metadata is kept for a day by default, so a query could read yesterday's snapshot with no sign of it. Past an hour the status line says so, and sql gives cachedAt, a note, and --fresh to read them from OneLake first.

• Clear Cached OneLake Data reaches every window, rather than leaving other windows showing what it cleared.

• A stalled account provider no longer holds up VS Code's commands for OneLake Studio. It gets five seconds at startup, and what it says later still counts.

• Read only holds against more ways of writing SQL. Nested comments, E'…' strings, a $ inside a name, a $ tag that isn't ASCII and a carriage return after -- could each hide a second statement or a COPY from the check. All are refused now.

• A result past maxResultRows says so. It used to report the rows it kept as if they were all of them. The status line now gives both counts.

• Export to Fabric asks everything first, and can't leave a model half written. Not being able to read what is already at the model's path stops the export, rather than overwriting it unasked. The question about an app of the same name now comes before anything is written, and the model's file is written beside it and renamed into place. A first export that fails part way is still known as its own next time.

• An update keeps what this machine has cached. Listings, table metadata, first rows and Logs used to start again with each new version, so nothing was there to read offline. A state file that can't be opened is set aside and started again, and the reason a server stopped goes in its log.

• A model's local copy is per account. ~/OneLakeStudio/semantic-models/<account>/<workspace>/<model>.yaml: two tenants can each have the same workspace and model name, and could read each other's definition. Copies you opened move there by themselves.

• Stop works while a table is being opened. It answers at once and the statement never runs. It used to reach nothing until the statement had started.

• Fewer false sign-outs. The account provider failing, or the internet going without anything noticing, no longer closes the tabs and says you are signed out. A token that arrives after a sign-out isn't kept.

• Filter the tree by type. The filter button on the explorer shows one type, such as semantic models, and only the workspaces that hold it. It replaces Group by Type: the tree always lists by workspace.

• A table that doesn't exist fails in seconds. It used to wait about two minutes as if Fabric were converting it, then suggest writing to it. The error now says there is no such table and names the closest ones. A table still waiting for its conversion still waits.

• The SQL box and the command line take reads only. DROP, DETACH, CREATE VIEW, CREATE SCHEMA, ATTACH and PRAGMA are refused at once, so nothing typed can reach another tab. pragma_* functions still read. DuckDB's own parser now checks every statement too. What a tab opens from Files/ goes when the tab closes.

• find --fresh reads every listing, then searches. find also says when it searched a table by name only.

• The command line's answers fit an agent better. SHOW ALL TABLES in Markdown gives a column count rather than every column. sql marks NULL in Markdown, and --csv writes an empty string as "". models --downloaded lists only what is on this machine, and models and items have a staging column. A query the shell split says so.

• Double-click an app in the tree to open it in the browser.

• It works offline. With no internet, or nobody signed in, OneLake Studio notices and works from what this machine has cached: the tree, the catalog, stats, first rows, semantic models, and the rows it has read. A query or a model's Pivot runs from what was read, and a column or a file never read says so at once. Export to Fabric needs OneLake. The status bar shows when this is happening, and it comes back by itself.

• The SQL box runs the statement under the cursor, or the selection. Ctrl+Enter runs it, Ctrl+S keeps it under Queries as "Query N", and the cursor goes to where DuckDB says an error is. The text last written comes back in the next window. Edit SQL is only where the box is hidden: a semantic model's view and a table's Pivot. A table or file you click puts its SQL in its tab's box, not run.

• DuckDB runs in a process of its own, shared by every tab and window. One memory budget and one cache of what was read, and it outlives a window reload. What the tree opens gets a new tab, each running its own query with its own Stop. Listings, table metadata and first rows move to a DuckDB file, imported once from the JSON files.

• Logs and Performance, as nodes in the tree. Logs is what the engine ran, from DuckDB's own log, kept up to logMaxGB, and a row reopens its SQL in a new tab. It holds your SQL in plain text. Performance is live charts of memory, cores, queries per second and the disk cache. Nothing of it is stored.

• Logs left Explore and the Fabric app. A published app has no built-in diagnostics page now.

• A first SHOW ALL TABLES answers at once. The catalog's list is kept and checked behind you, so it no longer walks every table first. On a machine that scans what it opens, that took 35 seconds.

• The title says where you are. The sidebar's header and each tab's title read OneLake Studio and then offline or the tenant in use.

• Sign Out stays signed out. The next VS Code start asks for no session and sends nothing to OneLake, until you sign in again.

• A model has one name in SQL. FROM nem no longer reaches an open model: only semanticmodel.<workspace>.<model> does. A shorter name is an error from DuckDB.

• A table shows whether it is cached. As a semantic model does: a cloud until its rows have been read on this machine, a check after. The Delta and Iceberg icons are gone; Stats still says which format it is.

• Sign Out. In the explorer's "..." menu. It signs out of OneLake Studio; VS Code's Accounts menu still removes the account itself. Signed out, the last account's cached data stays on show on this machine, until another account signs in or Clear Cached OneLake Data deletes it.

• A cached answer that turns out wrong now corrects itself. A lakehouse made a minute ago no longer gives "there is no lakehouse", a renamed one keeps working under its model, and a table whose metadata has moved is read again rather than failing. Nothing extra is read unless something fails.

• A first query answers much sooner.

  • A statement that names no semantic model no longer waits for its tab to load your models.
  • The name behind a Direct Lake model's GUIDs is kept on disk, so opening a tab no longer waits on the Fabric API each session.
  • The engine starts in the background once the OneLake view is visible, and its boot no longer waits to check the disk cache's size.
  • The catalog is listed in one call.
  • The Read Log shows the boot's stages in more detail, and how long the catalog and semantic models took.

• Settings are one click away. The explorer's "..." menu has Settings, next to Switch Microsoft Account, and Clear Cached OneLake Data. Settings are grouped into Cache, Engine, Query and Results, and Sign-in.

• New settings: cacheDirectory, metadataCacheMaxMB, engineThreads, engineSpillMaxGB, logMaxGB, selectTopRows, maxResultRows, tableOpensOn and gridThousandsSeparator.

• Files/ objects DuckDB reads are kept in the disk cache. A Parquet or CSV under Files/ is no longer downloaded again on every query. A kept copy is checked against OneLake first, so a rewritten file is read again.

• diskCacheMaxGB: 0 turns the disk cache off. It used to mean no limit.

• catalogTtlMinutes and tableMetadataTtlHours apply at once, with no window reload.

• Every OneLake table is read by its five-part name. The Data tab's rows now are too. A model table with no Direct Lake source, in a .bim or .yaml opened from Files/, gives an error when a query reads it; it used to read whatever carried its short name, such as an open Files/ view.

• The command line is built for an agent to act on.

  • Exit codes say what happened: 0 answered, 1 failed, 2 wrong call, 3 VS Code not open or not signed in, 4 not cached, 5 you declined an export, 6 timed out.
  • New options: --json, sql - for SQL from stdin with no shell quoting to get wrong, --timeout, --version and <command> --help. A query stops when its command is killed.
  • Fixed: models <typo> and items <typo> answered "none" and exit 0; a cancelled export exited 0; --csv left rows out past 200,000 with no word, now fails; --show-sql broke a --csv.
  • Changed: --csv holds raw values under plain column names, and always a header. An unknown option, a bad --limit or an option a command does not take is refused rather than ignored.

• A semantic model's local copy is an Apache Ossie file. Clicking a model keeps ~/OneLakeStudio/semantic-models/<workspace>/<model>.yaml in place of the .bim, and Export to Fabric writes that .yaml into its lakehouse. A model downloaded before this downloads again on its next click; its old .bim is left where it is.

• Export to Fabric reads an Ossie model as it reads a .bim. A table with no schema is in dbo, and a table with no source of its own (a calculation group, a calculated table) is a warning, not a refusal.

• Export to Fabric's app: a query's tables download together, and outside the engine queue; each tab has one store writer, handed its downloads without a copy (the DuckDB workers only read); the function's answer and the table snapshots live in IndexedDB, not localStorage; and the manifest cache keeps only what the tables read now.

• Go to a Table, Column or Measure (Ctrl+Alt+O, or the search icon on the tree): every table, column, semantic model and measure the cache holds, in one search. A pick opens the table or the model; its button puts the SQL name in the SQL box (or copies it).

• The results grid scrolls every row a result holds, not the first 2,000, with row numbers. Click a cell, Shift+click or Shift+arrows for a range, a row number for its row; Ctrl+A, and Ctrl+C copies as tab-separated text (Ctrl+Shift+C with headers). Right-click: Copy, Copy with Headers, Copy as CSV, Markdown or JSON. A double click (or Enter) shows a cell whole, JSON indented. The filter box keeps the rows that hold its text.

• Time travel on an Iceberg table: History's Query puts a snapshot's rows in the SQL box (iceberg_scan(…, snapshot_from_id = …)), and each snapshot says how its row count and its columns differ from the table now.

• Query variables: SET VARIABLE year = 2024 run from the SQL box keeps a value in that tab, and getvariable('year') in a query reads it; one never set is asked for the first time. Clear Query Variables forgets them.

• Chart on a result: the rows on screen as a bar, line or scatter chart, one column across and a number (or every number) up; nothing is queried again.

• Profile on a result: each column of the result, over every row the query returns: its type, min and max, distinct values, average, spread, quartiles, count and nulls.

• Export… (was Save CSV) writes every row the query returns, not only the rows on screen, to a CSV, Parquet or Excel file. The engine writes it; SQL typed by hand still cannot COPY. The grid's right-click also opens the selection (or every row) as an untitled CSV or JSON document.

• SQL from the tree. A table's right-click: Select Top Rows (a query in the SQL box, run), Copy SQL Name, Copy Column List. A table or a semantic model dragged into an editor drops its SQL name.

• The command line's dax command is gone. OneLake Studio takes SQL only: a semantic model is queried with AGG("measure") in sql.

0.2.9

• Clicking a semantic model writes nothing to OneLake. Its definition is kept on this machine, ~/OneLakeStudio/semantic-models/<workspace>/<model>.bim, and opened from there, so a user who can only read the workspace can open and query it. Export to Fabric writes the .bim into its lakehouse, after you approve the export.
• A semantic model is semanticmodel.<workspace>.<model> in SQL. A query that names one not opened yet opens it first.
• CREATE and DROP SEMANTIC VIEW are gone. A model is there because Fabric has it, or a lakehouse's Files/ holds it; open one in the tree, or name it in a query. SHOW SEMANTIC VIEWS, SHOW SEMANTIC METRICS / DIMENSIONS and DESCRIBE still work. SHOW SEMANTIC VIEWS lists every model the cache knows; one not opened yet has no file and no tables yet.
• SHOW ALL TABLES and SHOW SCHEMAS list everything the cache knows, tables and semantic models, with no request to OneLake. Each schema is named by its whole path (ws.lh.dbo), so two workspaces' dbo.t are two rows. SHOW TABLES FROM lakehouse.ws.lh.dbo works.
• New Query. The + on Queries opens a new query that starts with SHOW ALL TABLES, not yet run. It lists only the tables cached on this machine; expand a lakehouse in the tree to add its tables. Show Queries Folder moved to the node's right-click menu.
• A newer query keeps the results pane. A slow query that finishes after a newer one no longer replaces its results. Opening a saved query clears the last table's Stats, History and Pivot.
• Fixes:
  • Save Query on a semantic model saves the query as it stands.
  • Sorting the grid no longer reorders a document's Pretty view.
  • The Data tab puts a query's results back instead of replacing them.
  • CSV quotes a cell with a carriage return.
  • Plan no longer runs the query again on every click.
  • A date-like filter on a text column compares text.
  • Signed out of Fabric, expanding both Semantic models and Apps no longer fails.
  • "Signed out" shows only to someone who was signed in.
  • A new account or tenant lists Fabric workspaces again.
  • Publishing a folder "as is" lists each redirect once in rayfin.yml.
  • A SQLite file in Files/ is downloaded once per session, and Save downloads only after the dialog.
  • A DROP no longer leaves a table unreadable until reload.

0.2.8

• Every table has one SQL name: lakehouse.workspace.item.schema.table. For example lakehouse.aemo.data.dbo.dim_duid; the first part is lakehouse, warehouse, sqldatabase or mirroreddatabase, and a lakehouse without schemas is dbo. A query names tables that way and runs as written, whatever is open: joins across items and workspaces need no setup. The panel, Explore, a model's compiled SQL and the command line all use it. Copy SQL Name on a table gives it.
• Saved queries. Save Query in the SQL box keeps it, with no name to type, under Queries at the bottom of the tree: one folder per signed-in account, ~/OneLakeStudio/queries/<account>/. A click opens one; Rename and Delete are on its menu.
• Plan in place of Preview. The query's profile (where the time goes) and DuckDB's plan tree. Rows returned and planning time are now right there and in Explore's Show plan.
• Semantic models are named workspace.model, so two workspaces' models of one name are two views. The bare name works while only one model has it. dax-sql 0.1.2.
• Direct Lake models over several lakehouses open from the tree, each table read from its own lakehouse.
• An Import, DirectQuery or composite model gives a note, not an error (#3), and the tree marks it.

0.2.7

• Export to Fabric's app carries its own packages. DuckDB-WASM 1.5.6 with its parquet and icu extensions, Apache Arrow, the Rayfin SDK and ECharts ship with the site, in the local copy's site/vendor/ (about 48 MB). The app loads nothing from jsDelivr or DuckDB's extension repository. The export's output log lists what site/vendor/ weighs, package by package.
• SQL over a semantic model takes ORDER BY ALL and constants. ORDER BY ALL orders by every column, left to right. A constant in the SELECT, such as 'orders' AS what, is a column of every row, so each arm of a UNION can label its rows. The compiler is now dax-sql 0.1.1, from npm.

0.2.6

• Export to Fabric from the command line. Run export <ws> <model>, or export <ws> <item> <Files/path> for a model file. It uses the same export as Explore's button, and VS Code asks where the local copy goes and waits for your OK before publishing.
• Generate Report is gone. Use Export to Fabric instead. It did the same thing, but from an older copy of the app that ran a DuckDB-WASM 2.0 build taken from CI, with unsigned extensions. Export to Fabric publishes the model's Explore on DuckDB-WASM 1.5.6 from npm.
• Mirrored databases show up. OneLake names them .MountedRelationalDatabase, which the tree didn't list. They now appear as Mirrored database, with a mirror icon.
• The disk cache keeps 64 GB by default, up from 10. onelakeStudio.diskCacheMaxGB still sets it.
• Delta and Iceberg tables have their own icons. The icon says which format the table was written in. Every table is still read through its Iceberg metadata.
• New: a History tab beside Stats and Data.
  • A Delta table lists its commits from _delta_log, newest first, 10 at a time: version, time, operation, rows and files added or removed, engine, user and parameters. Nothing is read until the tab is opened, and each commit file is read only once.
  • An Iceberg table lists its snapshots, which are already in its metadata.
• A Delta table's Stats come from its Delta log. They show reader and writer versions, features, table properties (V-Order among them), partitioning and creation time. They are taken from the converted version's .crc file, which is one request and then kept. A writer that leaves no .crc, such as a Warehouse, has its last checkpoint read instead.
• A table with no Iceberg metadata says why. The error quotes Fabric's conversion log, for example a type it can't convert or too many commits. If there is no conversion log, the error says Fabric never converted the table.
• A 403 names the tenant setting to check. That setting is Users can access data stored in OneLake with apps external to Fabric, which a Fabric admin can turn off for every app at once.

0.2.5

• Explore is analytics-as-code's, and lives here now. A semantic model opens on three pages: Model, Pivot and Logs.
  • The Pivot asks SQL over the model (SELECT … FROM <model>).
  • Show SQL turns the pivot into that SQL, which you can edit and run.
  • Show plan profiles the query (DuckDB's EXPLAIN ANALYZE: totals, a timeline, the costly operators) and shows its plan.
  • Logs lists the session's queries with timings.
  • The SQL page is gone: the Pivot's Show SQL does its job.
  • Values can no longer be summarised by median, which SQL over the model doesn't have.
• New: Export to Fabric. A button on the Pivot publishes that Explore (and Logs) as a Fabric app named <model>-explore, and writes a local copy of it to <open folder>/<model>-explore/ (or the folder approved last time), after you approve where.
  • It asks before overwriting local edits to that copy (overwrite, or publish the folder as it is), or an app deployed again from somewhere else since.
  • It deploys directly over the Fabric REST API: no CLI, no Node, no GitHub access.
  • The site is protected: only people who may open the app item can load it. It's black.
  • The model is never copied: the app reads it from the lakehouse, in place, every time.
  • It never replaces an app it didn't create without asking.
  • It is the one write the extension makes to Fabric, and it happens only when you click.
• A semantic model opened from the tree goes into its lakehouse. Its .bim is written to <lakehouse>/Files/semantic_model/<model>.bim and opened from there, so Export to Fabric works on it. Only Direct Lake models on one lakehouse are opened; any other is refused, with nothing written. Download Again overwrites it, after asking. The onelakeStudio.semanticModelsFolder setting is gone.
• New: Apps in the explorer. Each workspace has an Apps node listing its Fabric apps, however they were made, each with its URL and last deploy, and a button to copy the URL. An app whose site is public (anyone with the URL can load it, no sign-in) has an orange open lock; a protected one, a lock.
• The app's template now lives in this repo (fabric_app/), and analytics-as-code takes it from here. The function ships prebuilt in the vsix.
• New: Generate Report. Right-click an Apache Ossie model (.yaml) in Files/ and choose Generate Report…. It writes a folder to this machine with a Fabric app (Rayfin, DuckDB-WASM in the browser) that reads the model's lakehouse through its OneLake Iceberg catalog. The page has one chart, and an AGENTS.md explains how an agent can grow it from there.
  • The template is analytics-as-code's Iceberg app, vendored at a pinned commit.
  • Nothing is deployed for you.

0.2.4

The first release notes for OneLake Studio. They cover every change since 0.1.0.

Power BI semantic models

• Semantic models in the explorer. Each workspace has a Semantic models node, listed from the Fabric REST API. Listing them needs its own sign-in, which is asked for only when you click Sign in to list semantic models, never at startup.
• One click opens a model. The first click downloads its .bim to this machine, and every later click opens that file at once. The tree marks a downloaded model with a check, and Download Again fetches the current definition. The folder is set by onelakeStudio.semanticModelsFolder.
• The model view has three pages:
  • Model: the tables drawn as a star, with their relationships, columns and measures (with their DAX).
  • SQL: queries that ask the model with AGG(measure). The DAX is compiled to SQL by dax-sql and runs on DuckDB.
  • Explore: pivot tables and charts. Drag columns onto Rows, Columns and Filters, and measures onto Values. Measures are shown in amber. A column dropped on Values is summarised: numbers are summed by default, anything else is counted. Totals start off.
• A .bim in a lakehouse's Files/ opens as its model too.
• New: Apache Ossie models. An Apache Ossie .yaml or .yml model whose metrics are DAX opens just like a .bim. A file counts as an Ossie model when its top level has version: and datasets:. Any other YAML still opens as a document.
• Semantic views. CREATE, DROP and SHOW SEMANTIC VIEW, SHOW SEMANTIC METRICS and SHOW SEMANTIC DIMENSIONS, and DESCRIBE, from the SQL editor. A view can point at a .bim or an Ossie .yaml. Views are kept per account and survive a restart.
• Direct Lake tables are read from the lakehouse the model names, and only when a query needs them.

Ask Claude Code or GitHub Copilot about your data

• OneLake Studio: Install Agent Skill writes a skill that Claude Code and GitHub Copilot (agent mode) both pick up. Either can then list your workspaces, lakehouses and models, read measures and their DAX, and compute measures by any column. It runs on the same sign-in, cache, DuckDB and DAX compiler as the panel, and it is read only.
• The skill runs a read-only command line (cli.mjs). It passes each request to the extension running in VS Code, so there is no second sign-in or cache. Commands: ls, items, models, files, find, table, model, sql and dax, plus --show-sql to print the compiled SQL.
• Listings and metadata come from the cache only. The command line never signs in or lists a workspace behind your back. --fresh is the one way to make it ask OneLake or Fabric.

Explorer

• The OneLake tree of workspaces, lakehouses, warehouses, tables and Files/ sits in the sidebar.
• Group by Type puts one heading per type at the top level (Lakehouses, Warehouses, SQL databases…, Semantic models), across every workspace. The choice is remembered.
• Pin workspaces to Favorites. Pinned workspaces are listed apart from the rest.
• New commands: Sign in to OneLake, Refresh, Show Read Log and Clear Cached OneLake Data.

Engine

• Native DuckDB 2.0 runs in the extension host, replacing the WebAssembly build. Each query runs on its own connection, so Stop interrupts only that query. A result past 200,000 rows is counted rather than carried into the panel.
• The panel loads nothing from the network. Its libraries ship inside the extension, and it holds no token.
• Read only by design. This is enforced in the extension host, and nothing is ever written to Fabric or OneLake. DuckDB is kept off the local disk outside its own temp directory.
• SQLite files in Files/ open in the host.
• onelakeStudio.engineMemoryLimit caps DuckDB's memory. By default it may use a quarter of the machine's RAM.

Cache

• Cache first: workspaces, items, tables, Files/ listings, semantic model lists, each table's metadata and its first 100 rows are kept on disk per account. They are served at once and refreshed behind you. Set how often with onelakeStudio.catalogTtlMinutes and onelakeStudio.tableMetadataTtlHours.
• A table you have opened before opens without a single request, even after a restart. First rows are kept per snapshot, so they are never stale. Refresh re-reads a lakehouse at once.
• Table data is kept on disk by cache_httpfs, so a table read once is read from this machine afterwards. The limit is set by onelakeStudio.diskCacheMaxGB, 10 GB by default.
• Files/ objects are kept under their etag, and each item's Iceberg catalog prefix is kept too.
• onelakeStudio.prefetchMetadata reads every table's metadata in the background once a lakehouse's Tables node is opened.

Platforms

• There is one package per platform: Windows, macOS and Linux, each on x64 and arm64. Desktop VS Code only, because the engine is a native library and does not run on vscode.dev.

Fixes

• Tables whose path has spaces now open.
• A semantic model opened from the tree no longer waits for DuckDB to start.
• In Explore, a search that hides a whole table no longer prints "null" in the field list.