marketplace
Use when something has to appear or be labelled in the Denodo 9.5 Data Marketplace — the separate server behind /denodo-data-catalog that is driven by REST, not VQL. Covers a marketplace tag, a category tree, assigning either to the views a consumer browses, importing VDP tags into the marketplace, synchronising the marketplace catalog with Virtual DataPort, and registering an external element (asset extension) — a dashboard, ETL job, data contract, notebook or AI agent from another tool — so it shows up in the 360 graph beside the views it uses. Also for "tag it in the marketplace", "put this data product in a category", "show our BI dashboards in the catalog", "why does the marketplace not see this view". Not for VDP tags (CREATE TAG, ALTER TAG) — those are /denodo:catalog.
- License 许可
- MIT
- 最近更新
- 2026-10-29
- Stars
- ★ 0
- Forks
- 0
01 前言 Front Matter
- name
- marketplace
- description
- Use when something has to appear or be labelled in the Denodo 9.5 Data Marketplace — the separate server behind /denodo-data-catalog that is driven by REST, not VQL. Covers a marketplace tag, a category tree, assigning either to the views a consumer browses, importing VDP tags into the marketplace, synchronising the marketplace catalog with Virtual DataPort, and registering an external element (asset extension) — a dashboard, ETL job, data contract, notebook or AI agent from another tool — so it shows up in the 360 graph beside the views it uses. Also for "tag it in the marketplace", "put this data product in a category", "show our BI dashboards in the catalog", "why does the marketplace not see this view". Not for VDP tags (CREATE TAG, ALTER TAG) — those are /denodo:catalog.
02 资源文件 4
- 参考文档references/categories.md5.0 KB
- 参考文档references/external-elements.md11.3 KB
- 参考文档references/renames.md8.7 KB
- 参考文档references/tags.md7.3 KB
03 SKILL.md 正文
Marketplace tags, categories and external elements
Three objects that live in the Data Marketplace, not in Virtual DataPort: the
marketplace tag, the category, and the external element that represents an asset
from another tool. The channel is REST — scripts/denodo api — and the server is the one
in marketplace_url, not the VDP port.
A "tag" alone does not say which object the human means. A VDP tag is CREATE TAG in
Virtual DataPort and belongs to /denodo:catalog; a marketplace tag is
POST /public/api/tags here. They are different objects on different servers, and a request
sent to the wrong one succeeds — on the wrong side. When the request does not say, ask — or
look at where the object has to be visible: a consumer who only browses the marketplace means
a marketplace tag.
Views themselves are /denodo:views and /denodo:datasources; applying anything is
/denodo:execute; the safety rule and the working loop are /denodo:vql.
Two rules that govern everything below
1. Names are not keys. Every object here is addressed by a numeric id that the server
assigns and that differs between installations. A template cannot contain one. There is no
CREATE OR REPLACE: idempotence is a sequence — look the name up, then POST if it is
missing or PUT if it is there. Two calls, every time, and the lookup is not optional.
2. Nothing can be attached to a view the marketplace has not synchronised. The
marketplace keeps its own copy of the VDP catalog. A view that exists in VDP but is not in
that copy has no id, and view-details says so:
{"id": null, "inLocal": false, "inVDP": true} — verified: 9.5.1 (live, 2026-09-10).
Synchronise first (see the template), then assign.
But that answer has two causes, and they look identical. A view queried against the
wrong serverId returns exactly the same body — id: null, inLocal: false, and
inVDP: true even from a server that never saw the database — and nothing in the response
names the server it means — verified: 9.5.1 (live, 2026-09-10). So before concluding
"needs synchronising", repeat the view-details call against the other registered servers:
if one of them answers inLocal: true, you had the wrong id and nothing needs
synchronising. Getting this backwards means changing a shared catalog to fix a query
parameter. VIEWS/changes does not shortcut the round: a server that never carried the
database lists its views under serverElements too, as views it would import —
verified: 9.5.1 (live, 2026-10-01). The server list does not say which server carries a
database; under a wrong id everything is created happily and only the import fails, naming a
view that "does not exist".
Name the server: serverId
The marketplace can have several VDP servers registered, and tags, views and external tool servers are per server — the same call against two ids returns two different catalogs. With more than one registered, omitting the server is an error whose text names something else entirely:
| Call without a server named | Answer |
|---|---|
/public/api/tags, /public/api/views/… |
500 {"code":"GENERIC","message":"Session Expired."} |
/public/api/external-tool-servers |
403, empty body |
/public/api/category-management/… |
works — categories are not server-scoped |
verified: 9.5.1 (live, 2026-09-10). Read the ids once:
# verified: 9.5.1 (live, 2026-10-07)
api get --env dev /public/api/configuration/servers
# → [{"id":<serverId>,"name":"<VDP server as registered>","url":"//<vdp-host>:9999/admin"}, …]
The id belongs in the profile, as marketplace_server_id — a human puts it there, not
you — and the tool adds it to every call by itself. That is why no template below names a
server: the profile is the single place the environment is described, so the same template
works against any marketplace. One registered server needs no id at all.
--param serverId=<id> overrides the profile for one call, and the transport then leaves
that call alone. Reach for it only when you genuinely mean a different server than the
profile's — asking each registered server which one holds a view, rule 2, is the case
that needs it. Putting it on ordinary calls silently pins the environment into a command.
Templates
Tag, with an assignment
# verified: 9.5.1 (live, 2026-09-10)
# 1. does it exist? — the lookup that replaces CREATE OR REPLACE
api get --env dev /public/api/tag-management/tags \
--param offset=0 --param limit=50 --param nameFilter=pii
# → {"count":1,"elements":[{"id":<another tag's id>,"name":"pii_legacy", …}]} ← NOT your tag
# 2a. missing → create it
api post --env dev /public/api/tags \
--json '{"name":"pii","description":"Personal data, GDPR scope","descriptionType":"TEXT"}'
# → {"id":<tag_id>,"name":"pii","vdpTag":false, …}
# 2b. present → update it, id and all four fields in the body
api put --env dev /public/api/tags \
--json '{"id":<tag_id>,"name":"pii","description":"Personal data, GDPR scope","descriptionType":"TEXT"}'
# 3. hang it on views, by marketplace view id
api post --env dev /public/api/tags/<tag_id>/views --json '[<view_id>]'
# → [] ← empty list IS the success
nameFilteris a case-insensitive substring match, so the lookup needs a second step: comparenameyourself, exactly.nameFilter=piialso returns a tag calledpii_legacy, andnameFilter=financeone calledFinance— verified: 9.5.1 (live, 2026-09-10). Taking the first element and calling it yours is how a script ends upPUT-ing over somebody else's tag. A namesake differing only in case is a collision, not a match: creating the second one is409, so that case is a question for the human, not something to resolve automatically.- The two base paths are the API's own, not a slip in this template: the paged lookup is
/public/api/tag-management/tags, while create, update and the per-tag reads are/public/api/tags/…. Do not "correct" one to match the other. name,descriptionanddescriptionTypeare all mandatory on create; missing ones are400 VALIDATE_FIELD.descriptionTypeisTEXTorRICH_TEXT(the latter renders HTML).- A duplicate name is
409with an empty body — no message to read. That is why step 1 exists. POST /tags/{id}/viewsadds;POST /views/{id}/tagsreplaces the view's whole tag set. Use the first unless you mean to wipe what other people put there.- The response is the list of ids that were not assigned.
[]is success;[<view_id>]means "already assigned" or "no such view" — the two are indistinguishable, both come back200— verified: 9.5.1 (live, 2026-09-10). Read the assignment back. - Anything that runs twice must read before it writes: check
GET /public/api/tags/{id}/elementsand skip thePOSTfor a view already listed, so[<view_id>]always means something is wrong;PUTa found tag only when a field differs. - Assigning to an external element instead of a view is
POST /public/api/tags/{id}/external-elementswith the same body shape, and it answers with an empty body, not a list.
Category tree
# verified: 9.5.1 (live, 2026-09-10)
api post --env dev /public/api/category-management/categories \
--json '{"name":"Consumer marts","description":"What analysts read","descriptionType":"TEXT"}'
# → {"id":<category_id>,"parentId":null, …}
api post --env dev /public/api/category-management/categories \
--json '{"name":"Retail","description":"Retail marts","descriptionType":"TEXT","parentId":<category_id>}'
api post --env dev /public/api/category-management/categories/<category_id>/views \
--json '[<view_id>]'
# → []
Same lookup-first rule (GET …/categories/tree), same empty-list-is-success rule. Two
differences from tags, both verified: 9.5.1 (live, 2026-09-10):
- Deleting a parent deletes its children. No warning, no mention of them in the response, and the assignments go with them. Read the tree before you offer a delete.
- A repeated
DELETEanswers200, where a repeated tag delete answers500. Do not read a status to decide whether something existed.
Synchronising the marketplace catalog with VDP
Needed before any assignment to a view, and before an external element can name one. Look
at the radius first — the whole point of changes is that it costs nothing:
# verified: 9.5.1 (live, 2026-10-07)
api get --env dev /public/api/element-management/DATABASES/changes
api get --env dev /public/api/element-management/VIEWS/changes
# → {"serverElements":[…new…], "modifiedElements":[…], "localElements":[…gone from VDP…]}
api post --env dev /public/api/element-management/DATABASES/synchronize \
--json '{"proceedWithConflicts":"SERVER_WITH_LOCAL_CHANGES"}'
api post --env dev /public/api/element-management/VIEWS/synchronize \
--json '{"proceedWithConflicts":"SERVER_WITH_LOCAL_CHANGES"}'
# → {"inserted":[…],"modified":[…],"removed":[…]}
- Both steps. A new database registers with the first call and its views still have no
ids; only
VIEWS/synchronizegives them ids — verified: 9.5.1 (live, 2026-09-10). proceedWithConflictsdecides what happens to descriptions that differ:SERVER_WITH_LOCAL_CHANGEStakes VDP's but keeps edits made in the marketplace,LOCALkeeps the marketplace's,SERVERoverwrites them. Use the first;SERVERis the one that quietly destroys other people's work.localElementsinchangesis the list of things that will be removed from the marketplace because VDP no longer has them, whatever the conflict mode. A view renamed in VDP is in that list under its old name — the next section.- A
modifiedElementsentry withreason: "DESCRIPTION,FIELD_DESCRIPTION"is usually an element whose descriptions were edited in the marketplace: it is listed on every reading, andSERVER_WITH_LOCAL_CHANGESkeeps those edits — verified: 9.5.1 (live, 2026-10-01). Such an entry loses nothing in the call — say so when you show the human the radius. - The radius is a reading, not a promise, and there is no scope.
changesdescribes the moment you asked; anything created between then and the call comes along too, and the call cannot be narrowed to one database — it synchronises the whole server. On a shared server that means other people's new views land in the catalog with yours. Re-read the response:insertedsays what actually happened. - The user running it needs
METADATAon the whole VDP catalog. Under a narrower account the marketplace treats what it cannot see as deleted and removes it — unverified: 9.5 documentation only (Synchronize with Virtual DataPort). - Who sends it. You, when the same call with
--plan, right before it, saysneeds_yes: false: it reads bothchanges— both, even when onlyVIEWS/synchronizeis needed — and finds only what this session created (radius.own): everyserverElementsentry a database or view of yours, everylocalElementsentry the element of a view of yours — your own view renamed, with the pair matched in the call, included; withSERVER_WITH_LOCAL_CHANGES, on a profile that is not production;modifiedElementsdo not change it. Then readremovedandinsertedagainst that radius, and bothchangesagain: once a database is gone from VDP, its elements left the catalog withremovedempty in both responses — verified: 9.5.1 (live, 2026-10-06) — so only the second reading shows what went. Tell the human at once about anything you did not expect. One entry inradius.not_own— another team's new database, an orphan you did not make — and the body goes in a file, with what waiting risks; the human sends it or says yes (/denodo:vql). The one other exception is the first import on a tool server you created in this session (the external element, step 4). Neither applies on production; nothing else about asynchronizeis exempt.
| Rationalization | Reality |
|---|---|
| "Nothing gets removed — the rest of the radius only adds" | Clean is not the test; whose is. Another team's new database or view under serverElements lands in the catalog everybody browses before its owner chose to publish it. |
| "The pair is matched, so the rename costs nothing" | A view that existed before this session is someone's: the rename and its matched synchronize wait for one yes, shown together. |
A view in the marketplace is renamed, recreated or moved
What people add in the marketplace belongs to the view's element, found by database and
view name, and a synchronisation sees a renamed view as one element removed with all of it and
another imported empty. So: view-details on the view before the change, saved to a file;
the pair matched in the same synchronize call (matchedElements); a DROP and CREATE under
the same name in one run; a move to another database cannot be matched at all. The template,
who sends the matched call, and the move: references/renames.md.
External element — a dashboard, job or contract from another tool
There is no POST /external-elements. An external element is imported: the marketplace
reads an interface view in VDP and creates, updates and deletes elements to match it. So the
chain runs VQL and REST alternately, and the whole block below carries one verification mark.
# verified: 9.5.1 (live, 2026-09-10) — the chain as a whole
# 0. the views this element will link to must already be in the marketplace catalog
# (previous template) — otherwise step 4 fails and nothing is created
# 0b. the element type the VQL half names ('DASHBOARD') must be listed; missing →
# POST /public/api/external-elements-types, body in references/external-elements.md
# 1. provider type: the tool the metadata comes from. Multipart, but the icon is optional
api post --env dev /public/api/external-providers-types \
--part 'request=json:{"name":"ACME_BI","visualName":"Acme BI"}'
# → 201 {"externalProviderTypeId":<provider_type_id>,"iconImage":null, …}
# with a logo: --part 'icon=@./acme.svg'
# the next call answers 200, this one 201 — check 2xx, never a particular code
# — verified: 9.5.1 (live, 2026-09-12)
# 2. the server that will read the contract. The interface view need not exist yet
api post --env dev /public/api/external-tool-servers \
--json '{"type":"CUSTOM","name":"acme_bi_server","description":"Acme BI dashboards",
"externalProviderTypeId":<provider_type_id>,
"databaseName":"sales_analytics","viewName":"i_acme_bi_elements"}'
# → {"id":<tool_server_id>, …}
# 3. ask the marketplace for the contract it expects. NOT a file to apply as it stands:
# the two CREATE TYPE come back usable verbatim, the interface view comes back
# without SET IMPLEMENTATION and without FOLDER — you write the implementation
api get --env dev /public/api/external-tool-servers/<tool_server_id>/vql-metadata
# → a JSON string: CONNECT DATABASE …; two CREATE TYPE; CREATE INTERFACE VIEW (columns only)
# 4. import
api post --env dev /public/api/external-tool-servers/synchronize \
--json '{"externalToolServerIds":[<tool_server_id>]}'
# → externalElementsAdded / Updated / Deleted, per server
Step 4 is a synchronize, and the safety rule of /denodo:vql says stop and ask before
one — but the first import on a server you have just created cannot delete anything. The
call deletes elements absent from the snapshot, and a server created in this same session
has imported none. So: your own new server, first import — go, and say in the summary what
was imported. From the second import on, the confirmation is back, because the interface
view is the whole picture and a row that stopped being selected is an element that gets
removed with its tags and categories. Read the current set first and show the human what is
about to disappear — the server's own elements are
POST /public/api/search/external-elements/metadata with externalToolServerIds: [<id>]
and the nine other mandatory fields — verified: 9.5.1 (live, 2026-09-12).
There is no GET …/external-tool-servers/{id}/external-elements: that path is 404.
None of this changes the tool: the call is stamped
destructive: replace either way, and on a production profile it is refused without
--allow-destructive, which only a human may add.
Look each type up before creating it — they are different objects. The element type, what
the asset is, is listed by GET /public/api/external-elements-types, which returns the name as
externalElementTypeName (sent as name) and has no description; the provider type, the tool
it comes from, by GET /public/api/external-providers-types. That listing embeds every icon
as base64 and can be large — read it into a file and project
{externalProviderTypeId, name, visualName} rather than letting it into the conversation —
verified: 9.5.1 (live, 2026-09-10). Tableau and Power BI are the documented native tools: the
REPORT element type, the TABLEAU and POWERBI providers. Every other type a marketplace
lists (DASHBOARD, ETL_JOB, an …_PROVIDER) is a custom type, created on that installation,
and another marketplace may lack it — the template's DASHBOARD included (step 0b). A new type
is a marketplace-wide object that everyone then sees. Step 1 of the chain above is skipped only
when a listed provider type really is the asset's tool.
The VQL half — the implementation behind the contract from step 3. Its names are outside
the naming convention of /denodo:vql on purpose: the interface view's name is part of
the contract you gave the tool server, and the three views under it are its implementation,
not integration-layer or business-entity objects. Keep them together in one folder and named
after the tool, as below; do not rename them to iv_… to match the table.
-- verified: 9.5.1 (live, 2026-10-07)
CONNECT DATABASE sales_analytics;
-- the two types come from vql-metadata verbatim. The names are part of the contract
CREATE OR REPLACE TYPE external_element_association_type AS REGISTER OF (
associated_element_id:text, external_tool_server_name:text,
associated_element_type:text, direction:text, role:text);
CREATE OR REPLACE TYPE external_element_association_array_type AS ARRAY OF external_element_association_type;
CREATE OR REPLACE VIEW acme_bi_metadata FOLDER = '/02 - integration'
AS SELECT 'ACME-DASH-01' AS id,
'Revenue cockpit' AS name,
'Weekly revenue by region' AS description,
'DASHBOARD' AS external_element_type,
'https://acme.example/d/revenue' AS url,
CAST('timestamp', '2026-01-19 09:00:00') AS created_at,
CAST('timestamp', '2026-09-06 07:45:00') AS updated_at
FROM DUAL();
CREATE OR REPLACE VIEW acme_bi_associations FOLDER = '/02 - integration'
AS SELECT 'ACME-DASH-01' AS owner_id,
'sales_analytics.household_income' AS associated_element_id,
CAST('text', NULL) AS external_tool_server_name,
'VIEW' AS associated_element_type,
'OUT' AS direction,
'consumes' AS role
FROM DUAL();
CREATE OR REPLACE VIEW acme_bi_elements FOLDER = '/02 - integration'
AS SELECT m.id AS id, m.name AS name, m.description AS description,
m.external_element_type AS external_element_type, m.url AS url,
m.created_at AS created_at, m.updated_at AS updated_at,
CAST('external_element_association_array_type',
NEST(a.associated_element_id, a.external_tool_server_name,
a.associated_element_type, a.direction, a.role)) AS associations
FROM acme_bi_metadata m INNER JOIN acme_bi_associations a ON m.id = a.owner_id
GROUP BY m.id, m.name, m.description, m.external_element_type, m.url,
m.created_at, m.updated_at;
CREATE OR REPLACE INTERFACE VIEW i_acme_bi_elements (
id:text, name:text, description:text, external_element_type:text, url:text,
created_at:timestamp, updated_at:timestamp,
associations:external_element_association_array_type
)
SET IMPLEMENTATION acme_bi_elements
FOLDER = '/02 - integration';
Four things here are load-bearing, each verified: 9.5.1 (live, 2026-09-10):
external_element_association_array_typeis the name the marketplace checks, literally. Rename it and synchronisation refuses the whole server:400 INVALID_EXTERNAL_ELEMENT_INTERFACE_VIEW … expected type external_element_association_array_type.external_element_typemust equal an element type'sname, character for character (read back asexternalElementTypeName, above).INNER JOIN, notLEFT OUTER JOIN. A left join over an element with no associations makesNESTproduce one all-null record, and the import rejects the element:400 … Required field 'associated_element_id' is null … association index 0. As written above — every element has an association — the inner join is the whole story; only if some element has none, add theUNION ALLbranch with a NULL array inreferences/external-elements.md.CREATE OR REPLACE INTERFACE VIEW … SET IMPLEMENTATIONin one statement, so the file re-applies.ALTER INTERFACE VIEWdoes the same thing but is a change to an existing object and needs a human's yes (/denodo:vql).
SELECT * FROM i_acme_bi_elements before step 4: an interface view accepts an implementation
that does not match it, and only the SELECT shows it (/denodo:views).
What you need before filling a template
| Slot | Where it comes from |
|---|---|
| Which "tag" | marketplace or VDP (top of this skill); ask when the request does not say |
serverId |
marketplace_server_id in the profile, set by a human (Name the server); never in a call unless you mean another server |
| Tag or category name, description | the human. Both are shown to consumers browsing the marketplace, so they read as labels, not as identifiers |
| A new category's parent | GET …/categories/tree first; a domain the human names is a category of this tree, usually a root one. A live marketplace's tree is a taxonomy somebody designed — hang the new category inside the branch it belongs to. A new top-level category is a question for the human, not a default: it adds an axis to what everybody browsing sees. (GET …/categories/{id}/potential-parent is for moving an existing one) |
| Every numeric id | never a template, never memory: a GET in this session. Ids differ per installation and per server |
| View ids to assign to | GET /public/api/view-details?databaseName=…&viewName=…; id:null: rule 2, the other servers first, then synchronise. Save the answer to a file and read id, inLocal and inVDP out of it with a script — it carries the view's whole field list and its connection URIs, and truncating it instead is how the three fields get missed |
| Whether the catalog may be synchronised | the call's --plan (needs_yes), see Who sends it |
| Whether a view about to be renamed, recreated or moved is in the marketplace | view-details on it before the change — id not null and inLocal: true. The answer is also what to keep: it is the only copy of the element's metadata |
| Which removed element is which new one | you renamed it, or the human says so. The same database and the same columns are a hint, not proof |
| For an external element: the type | GET /public/api/external-elements-types — list it; create one if none fits |
| For an external element: id, name, url, timestamps | the source tool. updated_at is what drives updates — an element whose updated_at does not move is never refreshed |
| Which views the element links to | the human, plus their exact database.view — an association naming a view the marketplace does not know fails the whole import |
| Direction and role | IN/OUT plus free text (consumes, feeds, validates). The documentation calls direction the data-flow direction and the 360 graph draws its arrow by it, without saying from whose side; Denodo's own sample marks every association OUT, a dashboard that reads a view included, and what IN changes is unverified. Follow the marketplace's existing elements, say which you chose, and look at the arrow after the first import. The role is the label on the edge of the 360 graph |
Do not ask about property groups, endorsements, requests or personalisation — they are marketplace features with their own screens, not part of creating these objects.
Reference
references/tags.md— the full tag surface, taking a tag off one view, importing VDP tags and why that call is the most destructive one here, webservice targets,delete-multiple.references/categories.md— the tree endpoints, moving a category, taking a view out of one, assignment from the view's side, what cascades.references/external-elements.md— the element and provider type surface, the association record in detail, element-to-element associations, what synchronisation adds, updates and deletes, and how to read/details.references/renames.md— a view renamed, recreated or moved: the template, the move, what to re-apply.
The server is also its own reference: GET /v3/api-docs on the marketplace returns the whole
OpenAPI document, which settles any path or body this skill does not
cover.
Verify
A 200 here means less than usual: assignments report failure inside a 200 body, and the
import reports what it did rather than whether it worked. Read the object back, from the
other side where there is one. Every read-back below — verified: 9.5.1 (live, 2026-10-05); the external element's
/details, verified: 9.5.1 (live, 2026-09-10).
| Question | Read-back |
|---|---|
| Did the tag/category land | GET /public/api/tags/{id} · GET /public/api/category-management/categories/{id} |
| Is the assignment real, from the tag's side | GET /public/api/tags/{id}/elements → {"views":[…],"webservices":[…]} |
| … from the category's side | GET /public/api/category-management/categories/{id}/views with offset and limit |
| … from the view's side | GET /public/api/views/{viewId}/tags · GET /public/api/category-management/views/{viewId}/categories |
| Is the view in the catalog at all | GET /public/api/view-details?databaseName=…&viewName=… → id, inLocal, inVDP |
| Did a renamed view keep its element | view-details on the new name → the id the old name had, with its tags, categories and endorsements |
| What a synchronisation would change | GET /public/api/element-management/{DATABASES|VIEWS}/changes — before, not after |
| Did the import create what you meant | the synchronize response names each element: externalElementsAdded/Updated/Deleted with originalExternalElementId |
| Did the element import (read as you) | GET /public/api/external-elements/{id}/details — type, server, url, and its lineage. A consumer sees the element only with the Visualize permission of its element type, METADATA on every view it links to and CONNECT on their databases; a report over data outside Denodo also needs Visualize external data. A new type adds its own Visualize column, which an administrator grants to roles (External element, in the Permissions tab of the marketplace's Server Set-Up): tell the human what a new type still needs |
| Does the view show the element | GET /public/api/views/tree/external-elements/lineage?databaseName=…&viewName=… — the question a human actually asked ("what consumes this?"), answered from the other end. The view node must resolve to databaseName/viewName, not stay a bare string |
| Is it really gone | GET it: 404 is the answer you want. The tool reports that as ok:false and exit 1, so a verification script must treat 404 as success here rather than stopping — verified: 9.5.1 (live, 2026-09-10) |
| Which VDP tags are imported | GET /public/api/tags/vdp/local (references/tags.md) |
Common mistakes
| You did | Server says | Fix |
|---|---|---|
read id: null from view-details as "not synchronised" |
200, and the same body a wrong serverId produces |
ask the other servers first; only then synchronise |
GET …/categories/{id}/views without paging |
400 MISSING_REQUEST_PARAMETER |
--param offset=0 --param limit=50 |
POST /tags with a name that exists |
409, empty body |
look up by name first, then PUT |
take the first element nameFilter returned |
200, the wrong tag |
the filter matches substrings and ignores case — compare name exactly |
read an assignment's 200 as success |
200 and [<view_id>] |
not assigned: already there or not synchronised — read tags/{id}/elements; synchronise, then re-assign |
POST /views/{id}/tags to add one tag |
200 |
that endpoint replaces the view's tags; use /tags/{id}/views |
DELETE a parent category |
200 |
its children went too — read …/categories/tree before offering it |
DELETE the same tag twice |
500 GENERIC "Incorrect number of deleted tuples" |
it was already gone; categories answer 200 and servers 404 for the same thing |
synchronize a tool server before the associated view is in the catalog |
400 INVALID_VDP_EXTERNAL_ELEMENT_METADATA "The view '…' does not exist" |
the view does exist in VDP: either the marketplace copy is missing — synchronise the catalog — or the tool server was created under the wrong serverId (rule 2): ask the other servers first |
| rename the association array type | 400 INVALID_EXTERNAL_ELEMENT_INTERFACE_VIEW … expected type external_element_association_array_type |
keep the contract's names |
LEFT OUTER JOIN for elements without associations |
400 … Required field 'associated_element_id' is null |
INNER JOIN plus a UNION ALL branch with a NULL array |
| drop an element from a non-empty snapshot | 200, and the element is deleted with its tags and categories |
that is the contract: the interface view is the full picture, not a delta |
| empty the snapshot entirely to clear elements | 200, nothing deleted |
an empty result is treated as "no data", not "delete everything" — verified: 9.5.1 (live, 2026-09-10) |
DELETE an external tool server to tidy up |
200 |
every element it imported disappeared with it, tags and categories included |
rename a view in VDP, then synchronise without matchedElements |
200, old name under removed, new under inserted |
the element went with every tag, category, description and endorsement on it; the new one is empty. Match the pair in the same call — and if it already ran, only a view-details saved before the rename can say what to re-apply |
"type":"View" (or any type) in a matched pair |
400 "Invalid input JSON" |
the pair is localElement and serverElement, nothing else |
| match a view moved to another database | 200, the pair in neither inserted nor removed |
ignored, not applied: nothing happened. Re-apply from the saved view-details after a plain synchronisation |
POST /property-management/views/{id}/groups to add one group |
200 |
it replaces the view's groups, and the values of the ones left out are gone |
Destructive here is decided by method and path, not by the word in it:
| Call | What is lost |
|---|---|
DELETE /public/api/tags/{id}, /tags/delete-multiple |
the tag and every assignment of it |
DELETE /public/api/category-management/categories/{id} |
the category and all its children |
DELETE /public/api/external-tool-servers/{id} |
the server and every element it imported |
DELETE of an assignment, a tag or a category off a view |
that assignment (references/tags.md) |
POST /public/api/tags/vdp/synchronize |
every imported VDP tag missing from the list you send — a complete list still replaces a set the human has not seen |
POST /public/api/element-management/{all,DATABASES,VIEWS,…}/synchronize |
what VDP no longer has (localElements), in any mode — a renamed view's element unless the pair is matched; "SERVER" also overwrites marketplace edits |
POST /public/api/external-tool-servers/synchronize |
every element the interface view no longer selects, with its tags and categories |
POST /public/api/views/{id}/tags, /public/api/category-management/views/{id}/categories, /public/api/property-management/views/{id}/groups |
the view's previous set — they replace, not add; a property group left out takes its values |
All of them wait for the human's yes to the calls you show (/denodo:vql) — the request that
asked for them is not that yes, and with nobody to answer the body goes in a file and your
message — except the two in Who sends it.
04 同仓库更多 Skills
vql
Use when doing anything with Denodo — creating or changing a database, folder, tag, data source, wrapper, base, derived, interface or metric view, association, cache, role or security policy, remote table or summary, a Data Marketplace object, a regression test or a Scheduler job; writing or fixing VQL, or an expression in a SELECT — text, dates, casts; deciding where an object lives and what to name it; "where do I start", "build a mart", "connect a source", "vibe-code on Denodo". Start here when the request is ambiguous or names no single object.
views
Use when building on top of views that already exist in Denodo 9.5 — a derived view (a join, an aggregate, a mart, a filtered or parameterised view, a UNION ALL of views of one entity, FLATTEN of a JSON array into rows, NEST of rows into an array), an interface view, or an association between two views. Also before changing a view others depend on — "what uses this view", "can I drop this column", "where does this field come from" — for whether a mart over a database runs there or pulls every row into Denodo, for "combine these sources into one view", "expose this as a data product", and for a view created without an error that fails on SELECT or turns up INVALID. Not for sources and base views — /denodo:datasources; databases, folders, VDP tags — /denodo:catalog; a view's cache — /denodo:cache; a copy stored as a table — /denodo:materialize; a metric view — /denodo:metrics.
testing
Use when a Denodo 9.5 project needs regression tests, or its tests need running or fixing — .denodotest files that the Denodo Testing Tool runs in CI (%EXECUTION, %RESULTS[data|query|csv|exception], configuration.properties, denodo-test.sh) — "add tests for this mart", "a safety net before I rewrite these views", "make sure the dashboards see no difference", "what should CI check on our data products", "prove the mart is right", "CI is red on the Denodo tests", a test that fails on row order, on a column it did not ask for or on a value padded with spaces. Not for checking a new view once, right after creating it — /denodo:views.
semantics
Use when the views of an existing Denodo 9.5 database have to be understood by people and by AI consumers — the Denodo MCP Server, Assisted Query in the Data Marketplace, the AI SDK. Auditing a database for views and fields without descriptions, primary keys that are missing or not unique, missing associations and the VDP tag the MCP Server shows views by; writing view, field, association and tag descriptions from the data, and primary keys. Also for "describe / document these views", "prepare this database for AI, MCP or Assisted Query", "why does the agent not see this view through MCP", a description that says the wrong thing. Not for building or changing what a view computes — /denodo:views; not for marketplace-only metadata (logical names, property groups, marketplace tags) — /denodo:marketplace.
security
Use when deciding who may read what in Denodo 9.5 — masking or hiding columns (PII, contact details, salaries, bank accounts) from some users or roles, letting a role see only some rows (a country, a tenant) or each person only their own, taking someone's access away (ALTER USER … REVOKE), denying a view to a group, a global security policy (CREATE GLOBAL_SECURITY_POLICY) and the VDP tags it reads, giving a user a role or giving a role access to a database or views (CREATE ROLE … GRANT EXECUTE, ALTER USER … GRANT ROLE), checking what a given user really gets back, or a user who sees data a restriction should hide ("he still gets every row", "the masking stopped working"). Not for a tag as a label without a policy (/denodo:catalog) or for descriptions and the MCP visibility tag (/denodo:semantics).
scheduler
Use when something in Denodo 9.5 has to happen on a schedule, or a scheduled run misbehaves — refreshing the cache of a view every night or every hour, running REFRESH of a remote table or a procedure at a set time, exporting a view to a CSV file every week or month, running a Denodo Scheduler job now, stopping, pausing, enabling or deleting it, reading what last night's run did or why it failed, "the cache doubles after every refresh", "the job fires at the wrong hour", "the export file is missing or has no header". Denodo Scheduler projects, jobs, cron triggers and reports, through the REST API of the Scheduler administration tool. Not for switching a cache on or loading it once (/denodo:cache), not for creating the remote table or summary itself (/denodo:materialize).