Skip to content
OntologyL_Cypher 2.0 DSL Spec: Chain-Based Graph Query Language with 97 Methods
Databases 48 min read

OntologyL_Cypher 2.0 DSL Spec: Chain-Based Graph Query Language with 97 Methods

OntoL-Manage OntologyL_Cypher 2.0 DSL is a chain-based graph object language with 97 executable methods across 13 semantic categories, featuring dual-channel parameter access ($/#), explicit write-back semantics, four-state data flow, static validation, and integrated time, spatial, and OWL 2 RL constraint evaluation for ontology-driven graph operations.

AI Large-Model Wave and Transformation Guide
AI Large-Model Wave and Transformation Guide
AI Large-Model Wave and Transformation Guide

Product Overview

OntologyL_Cypher 2.0 is OntoL-Manage's proprietary graph object chaining language . It unifies graph node/relationship reads, row filtering, aggregation, external data fetching, temporal and spatial reasoning, OWL 2 RL read-only constraints, path finding, result write-back, and alert actions into a single left-to-right executable, statically verifiable, auditable behavioral function expression. The registry currently provides 97 executable methods across 13 semantic categories (11 with executable methods; compare and literal are display-only), comprising 48 terminal methods and 43 boolean methods usable as condition terminals .

Product Positioning

What It Is

The language serves as the orchestration layer in the ontology world — not a Cypher replacement nor a general-purpose programming language. Responsibilities include:

Reading graph nodes/relationships into JSON views and processing them via chain semantics

Pushing safe filters, traversals, and aggregations down to the graph database

Executing JSONPath, chain computations, spatiotemporal judgments, and non-pushable composite logic in Python

Unified access to relational data sources, dynamic APIs, and MCP tools

Dual-channel parameter reading via $field (shared) and #field (self)

Explicit write-back of results to graph objects in the copy via chain-terminal write methods

Returning unified DSLResult(val, msg, current) and per-method trace for explanation, audit, and replay

What It Is Not

Not a Cypher replacement syntax — Expresses business-object chain computation; does not handle low-level graph ops. Use debug entry or native query for raw Cypher.

Not a general-purpose language — No arbitrary loops, arbitrary Python, nested functions in parameters, or implicit recursion.

Not a reasoning order controller — Reasoning engine decides which node runs first and along which main chain; behavioral function only handles current object's read/judge/action.

Not a Text2SQL replacement — In-chain data fetch uses db_sim / db_query / func / mcp; free-form QA SQL fallback is a separate chain.

Not an auto-approval or auto-asset-modification tool — Static validation checks expression structure only; does not substitute field existence, permissions, approval, or real rehearsal.

Not a formal graph real-time write channel — Rehearsal/sandbox only modify copies/drafts; formal digital-twin data maintained by external real-time channels.

Value Propositions

Unified expression — Query, filter, aggregate, fetch, spatiotemporal judgment, OWL validation, path finding, and write-back share one syntax.

Business-readable — Chain syntax mirrors natural reading order; business users can follow "what to fetch, then filter, then write".

Model-controllable — Method table, execution dispatch, prompts, and tests share registry, reducing model hallucination of non-existent methods/parameters.

Deterministic execution — Fail-closed, no guessing; empty results, exceptions, missing fields, and path ambiguities are distinctly identified.

Explainable & auditable — msg provides Chinese semantics; meta["trace"] records per-method params, results, and error evidence.

Performance-controllable — Pushable Cypher steps are pushed; non-pushable evaluated in Python; no caching, real-time query.

Clear security boundaries — Condition fields read-only; writes and external calls allowed only in execution fields.

Extensible — Complex business via func, mcp, or data-source queries; avoids endless DSL function proliferation.

Capability Map

13 Semantic Categories

Read, Judge & Transform ( read ) — 15 methods: field existence, null, type conversion, string judgment, JSON decode, numeric processing

Graph Traversal & Path Finding ( traverse ) — 8 methods: up/downstream node/relationship traversal, path existence, blocking path finding, path value extraction

Row Filtering & Result Control ( filter ) — 7 methods: current chain value filter, sort, truncate, universal/existential/empty-set judgment

Aggregation & Collection ( aggregate ) — 16 methods: count, sum, avg, max/min, distinct, group, unwind, collect

Date Calculation ( date ) — 5 methods: date add/subtract, date diff, duration, days since/until

Temporal Relations ( temporal ) — 14 methods: timeSpan plus 13 Allen interval relations

Spatial Operations ( spatial ) — 4 methods: geometry construction, intersection, containment, distance

OWL Constraints ( owl ) — 17 methods: class, individual, relation axioms, cardinality, property chains — OWL 2 RL read-only judgments

Data Fetch ( data ) — 2 methods: structured conditional fetch, read-only SQL query

Write & Action ( write ) — 7 methods: property write, delete/detach/empty, shared-param write-back, self-param write-back, alert

External Call ( external ) — 2 methods: dynamic API invocation, MCP tool invocation

Comparison ( compare ) — 0 executable methods; display-only in formula catalog

Literal ( literal ) — 0 executable methods; display-only in formula catalog

High-Frequency Capability Quick Reference

Examples include: current object judgment ( $qty > 0, has("expiry")), node retrieval ( n(building).filter("[floor_count>18]").count()), relationship retrieval ( r(R_CONTAINS).filter("[required=true]").count()), upstream/downstream traversal ( next_n("R_CONTAINS")), path reasoning ( path(floor->room).sum("能耗读数")), path value extraction ( path_value("floor-[R_CONTAINS]->room", "测点编码")), external fetch ( db_sim("ERP", "project", {"status": "$status"}, "F")), dynamic API/MCP ( func("project_lookup", {"id": "$id"}, "F")), shared-param write-back ( db_query(...).write_param("reading")), self-param write-back ( db_sim(...).filter("[qty>0]").write_params_self()), temporal relations ( timeSpan("#valid_from", "#valid_to").timeContains(...)), spatial relations ( geometry("#geom_wkt").intersects("$work_area_wkt")), OWL constraints ( has_key("code"), functional("R_HAS_OWNER")), and alerts (

warn("$temperature > 80", {"message": "温度过高", "feishu": "FEISHU_ALERT"})

).

Language Model

Three Chain Heads

Chain head written directly as function name; when n / r omitted, defaults to current object. method(...) — Current object's own JSON (e.g., has("qty"), round(2)) n(...) — Filter nodes; empty param = all nodes (e.g., n(building), n()) r(...) — Filter relationships; empty param = all relationships (e.g., r(R_CONTAINS), r())

Forbidden: e(...), reasonObj, .attr(...). Relationship filtering unified as r(...).

Chain Execution Semantics

Each step receives JSON, outputs 0..n JSON values.

Previous step's result is next step's sole input; methods execute left-to-right.

Function parameters written by declared positional order; zero-arity written as method().

Method parameters written as JSON literals; dynamic values embedded in JSON strings using $field or #field.

Chain results passed in memory; no real-time re-read from graph DB.

No textual nested calls in parameters (e.g., sum(path(...), field) forbidden); compose via dot chain path(...).sum("field").

Any step failure halts subsequent methods; msg gives Chinese reason.

Four-State Data

Chain data transmission fixed to four shapes — no fifth: null / undefined — Failure: error, exception, upstream block, or expression undecidable. Chain terminates; msg explains; cannot be treated as "no data". [] — Success: no data retrieved but execution error-free. Ordinary fetch chains return empty array; no fabricated row. [obj] — Success: single JSON object, length fixed at 1. Field read returns scalar; write-back consumes this object. [obj, obj, ...] — Success: multi-row data. filter / sum / count etc. process as array.

JSON & Parameter Writing Rules

JSON strings must use double quotes.

Method parameters positional; no args, #call, #ref containers.

Field references only as function parameters or comparison operands; cannot be chain head nor written as $field.method().

Backslash-prefixed string denotes literal string, e.g., "\$status".

SQL text passed as double-quoted string; SQL internals use single quotes. T / F are method-defined string markers; write "T"/"F"; boolean params use true / false.

Full $field / #field in JSON keys/values participate in field substitution; missing field, illegal type, or duplicate key after substitution → fail-closed. $args / #args treated as dynamic-key field references only, not parameter containers.

Selectors & Operators

Node Selectors

n(building)

— Find nodes by entity code n(#690) — Locate by graph PK/source key; exact hit returns single object n(#101, #102) — Multi-PK query n([floor_count>18]) — Filter by field code n(building[building_status=in_service]) — Entity code + field conditions combined (AND) n() — All nodes; subsequent filter for narrowing n(<Order>, {"name": "order_001"}) — Create node with properties using standard JSON

Relationship Selectors

r(*)

— All relationships r(R_CONTAINS) — Query by relation code (maps to ontoL_relType) r(#456) — Query by relationship PK r([ontoL_confidence>0.8]) — Filter by relationship property

Selector Operators

=

/ == — Equals != — Not equals

>
<
>=
<=

— Numeric or comparable ^= — Prefix match $= — Suffix match *= — Substring containment ~= — List contains

Bare attribute name — Attribute existence

Entity, field, relation locators use codes only; Chinese names, display names, labels, and ontoL_ontoType are not locators.

AND / OR

AND/OR are not part of the behavioral function method chain; they are outer-layer split-and-merge. Only the outermost layer is split (not inside parentheses or JSON dicts). Each atom independently recorded in trace with extra expression field for failed-atom localization.

Dual-Channel Parameters & Write-Back

$field vs #field

$field — Reads from owning top-level entity's ontoL_action_param. Shared params; feature nodes read their owning top-level entity. On missing: fail-closed; no fallback to self same-name field.

#field — Reads from current node/relationship's ontoL_self_param. Self params; every graph node and relationship can use. On missing: fail-closed; no fallback to shared param.

Both support dot sub-paths (e.g., $payload.code, #payload.code). Domain-level entities ( domain_level=0) lack ontoL_action_param; every node has ontoL_self_param. ontoL_action_param stores field definition entries

{name, data_type, type, length, digit, required, format, desc, value}

; $field reads value. write_param() updates only value preserving existing definitions; does not write feature nodes. ontoL_self_param stores raw values; #field returns raw value; write_params_self() updates raw values only.

Chain Value Source & Explicit Write-Back

Chain function results pass in memory to next step; do not automatically become shared parameters . Explicit write-back required for reuse:

Fetch functions only return data; no implicit write-back.

Chain-terminal write_params_self() increments current node's business result into ontoL_self_param; serves as fission precondition.

Chain-terminal write_param() increments result into owning top-level entity's ontoL_action_param; does not participate in fission.

No-arg form writes back all business keys; specified keys update only those; source->target form performs key mapping.

Unmentioned fields retained; missing fields created; no write to ontoL_* system fields or _ -prefixed internal markers.

Scalar write-back requires single explicit target; no target, multi-target, or arrow-mapped scalar → fail-closed.

Fetch Row Limit

db_sim

, db_query, func, mcp — four DSL fetch entry points — each return at most 20 rows per call. Subsequent aggregations operate only on actual returned rows; partial results not claimed as full statistics. Complex computation and full statistics should use func, mcp, or data-source queries. Data-ontology configured fetch has separate 200-row limit (config execution path), not the behavioral function's 20-row limit.

Condition Fields vs Execution Fields

ontoL_precondition — Allowed: comparison expressions, boolean methods, OWL/spatiotemporal terminal boolean methods. Disallowed: bare attributes, bare traversals, fetch, writes, external programs, external symbol language prefixes.

ontoL_execution — Allowed: fetch, aggregation, judgment, write, fission, path reasoning. Disallowed: expressions not deterministically reproducible by reasoning engine. ontoL_precondition is pre-trigger hard constraint (remedial field, usually left blank); if filled, must be decidable true/false. Condition gate only recognizes explicit truth: None, empty collection, empty string, 0, and error text do not count as true. set, remove, detach, empty, write_param, write_params_self only allowed in ontoL_execution. db_sim, db_query, func, mcp may fetch or cause external side-effects; also forbidden in condition fields.

Path Finding & Path Value

path(...)

path(...)

in execution field is a blocking sub-reasoning branch : reasoning engine detects the call, launches an additional chain reasoning within the same ontoL_copy_version copy, waits for sub-chain events and cards to return, then continues current expression and main reasoning.

Read-only; no graph writes.

1 argument → shortest path; 2 arguments → prefer specified relationship. -[R]-> denotes strong-binding relationship segment.

No third argument; no parameter containers; no quotes around path.

Current executing node provided implicitly by executor; parameters only write non-self entity/behavior codes; do not repeat current node.

Arrow segments use entity codes; dot chains use .downstream_feature_code.further_downstream_feature_code selecting only non-entity feature ontologies.

Entity-to-feature mounting edge written as that feature ontology code.

In condition fields, path(...) used only for read-only query or boolean judgment; does not trigger additional reasoning.

path_value(...)

path_value("path", "field_code")

collects field values hop-by-hop along path, returns array as current chain value for further aggregation, counting, or judgment.

Returns only hop-collected value array; no graph writes.

Path node missing field → skipped; all nodes missing → returns False with Chinese reason. $field does not read this in-memory result; cross-behavior reuse requires write_param("field") to persist to graph first.

Fail-closed on: no path found, multiple equal-length shortest paths, explicitly missing relationship, or path ambiguity — no silent first-path selection.

Time, Space & OWL Constraints

Temporal Relations

Time, date, validity are ordinary business fields; no extra spatiotemporal ontology needed. timeSpan(...) assembles start/end into interval; 13 Allen relations exposed as first-class methods: timeBefore, timeMeets, timeOverlap, timeStarts, timeBetween, timeFinishes, timeEquals, timeFinishedBy, timeContains, timeStartedBy, timeOverlappedBy, timeMetBy, timeAfter. timeBetween / timeContains use product closed-interval semantics; date-only precision covers to 23:59:59 of that day.

Spatial Operations

geometry(...)

accepts WKT, bbox, GeoJSON, or field parsing; intersects / within judged by DE-9IM; distance fails-closed on non-point geometries. Invalid WKT, missing field, or unsupported geometry type → Chinese reason returned.

OWL 2 RL Read-Only Constraints

17 OWL methods cover identity, class, relation axioms, cardinality, property chains: all_values_from, different_from, disjoint_with, equivalent_class, functional, has_key, in_class, inverse_functional, inverse_of, not_of_type, of_type, property_chain, property_chain_to, qualified_cardinality, same_as, some_values_from, transitive. Read-only on current graph or copy; no materialized closure, no graph writes, no import approval changes. Exceeding transitive closure or property chain scan limits → fail-closed.

Dynamic Fetch & Extensions

Four Extension Entry Points

db_sim("source", "table", {cond}, "T/F") — Structured conditional read from business data source. No custom SQL; condition JSON supports $field / #field.

db_query("source", "table", {}, "SQL", "T/F") — Execute read-only SQL. SQL value params via $field / #field; legacy :param rejected; only value binding, no dynamic table/column names.

func("api_code", {params}, "T/F") — Call registered dynamic API. May produce external side-effects; Python logic lives in dynamic API, not embedded in DSL params.

mcp("service/tool", {params}, "T/F") — Call registered MCP tool. May produce external side-effects; requires prior config and authorization. T = allow subsequent fission; F = prohibit; param optional, defaults to T. Fetch functions only return data; write-back and fission still require chain-terminal write_params_self(), and only when response body contains data and chain-terminal returns multi-row.

SQL Parameter Example

SQL text outer layer double-quoted; SQL internals single-quoted. $code reads shared param; #state reads current node self param.

No legacy :code, :state colon params.

Binding handled by unified SQL dialect layer; business values not concatenated into SQL.

warn Alert

First param is read-only DSL condition; followed by 1..20 notification config objects. Each object must have message; optional func for dynamic API code; remaining keys are notification category codes with values as config codes within that category. feishu is system preset category; feishu_doc denotes cloud document block delivery; new categories added by writing category key directly, no DSL change. Continuous hits do not repeat send; re-send after recovery. Ordinary queries and assembly pre-fetch do not send. Missing/disabled category/config, unimplemented channel, send failure → failure logged, no auto-retry.

Typical Usage Workflows

Business Modelers

Confirm entity codes, field codes, relation codes; locators always use codes.

Determine if current value is shared ( $field) or self ( #field).

Select base fragments from formula catalog; combine as "param table entry → intermediate functions → write-back exit".

Static validation checks method names, param counts, terminality, condition boundaries.

Test in behavioral function test page with simulated attributes; verify val and msg.

Rehearse in copy/sandbox; inspect trace, result cards, write-back logs.

Developers

Register method contracts in business/ontoL_languages_dsl/method_registry.py.

Implement in corresponding execution handler or dispatch table.

Sync formula catalog, prompts, user docs, architecture docs.

Add method contract, formula catalog, result contract, path scope tests.

Run tests/test_dsl_*.py regression; confirm "registration = implementation, prompts within bounds".

In-Product Agents

Conversational agents query method docs via lookup_dsl_function by name or purpose.

Validate full expressions via validate_dsl_expression for static checking.

Auto-workshop exposes these two tools in four formula-involved stages (relation, feature, assembly, rehearsal); not in entity recognition or closing stages.

Upload process injects ONTOLOGY_DSL_SPEC with method table, semantics, examples generated from same registry.

Tools can query and validate; does not equal executed, written, or approved; final conclusion must rely on real tool returns and rehearsal results.

API & Integration

Public APIs

GET /api/v1/dsl/functions — Query function catalog; supports name exact and query keyword search. Returns ok, total, functions, rules, error. Unknown name → ok=false; no guessing, no name compatibility.

GET /api/v1/dsl/formulas — Return formula catalog categories and fragments by role=condition or role=execution.

POST /api/v1/dsl/validate — Static validation of expression; no execution, no graph DB access. Request body requires role (only condition or execution; else 422). Returns ok, errors, warnings; errors include position and fix suggestions.

POST /api/v1/reasoning/dsl-test — Reasoning engine debug execution; returns result, msg, result_type, result_repr.

GET /dsl-test — Behavioral function test page for reasoning engine debugging.

Static Validation Boundaries

Reuses require_default_dsl, syntax_validator, condition_validator; can reject unknown methods, legacy prefixes, parameter containers, write/external actions in condition fields. Does not access graph DB or external interfaces ; also does not substitute for:

Whether field truly exists

Whether current user has data permissions

Whether asset change requires approval

Whether current copy is assembled

Whether external interface is reachable

Whether business result is correct

Governance, Security & Isolation

Condition read-only — ontoL_precondition disallows fetch, writes, external calls, native language prefixes.

Write explicit — Fetch functions no implicit write-back; only chain-terminal write methods write graph or trigger fission.

Formal graph isolation — Sandbox/copy rehearsal only modifies copy; simulated values never written to formal graph real-time data.

Approval not bypassed — Static validation and DSL execution do not replace asset approval, field default approval, import approval.

Codes authentic — Entity, field, relation locators must come from current assets or data sources; no copying placeholder codes from examples.

SQL safety — Read-only SQL; value params named binding; no business value concatenation; no dynamic table/column names.

Fail-closed — Missing field, type mismatch, illegal time, invalid WKT, path ambiguity, interface error → failure + Chinese reason.

Replayable — msg human-facing; meta["trace"] audit-facing; neither substitutes the other.

Formal graph tier ≥1 entity nodes' ontoL_action_param is digital-twin real-time data carrier, incrementally updated by external OntoL-Data. Behavioral functions may read and rehearse but must not write rehearsal simulated values as formal graph real-time data; copy is frozen snapshot, not refreshed with formal graph real-time.

Common Errors

Wrong: filter("[status=ready]") as global search → Correct: n().filter("[status=ready]") — filter only filters current chain value; does not re-query graph DB.

Wrong: #rows to read shared param → Correct: $rows — # only reads current node's ontoL_self_param.

Wrong: Condition only $qty → Correct: $qty > 0 or has("qty") — Condition must end with comparison or boolean method.

Wrong: $field.method() → Correct: method("$field") or $field > 0 — Field reference only as param or comparison operand.

Wrong: sum(path(...), field) → Correct: path(...).sum("field") — Chain results pass in memory; must continue via dot chain.

Wrong: db_query(... WHERE status=:status) → Correct: db_query(... WHERE status=$status) — Legacy colon params removed; SQL text outer double quotes.

Wrong: path(..., {"dry_run": true}) → Correct: path(path) — path accepts no third parameter.

Wrong: Legacy ontoL_allen: / ontoL_geo: prefixes → Correct: timeXxx(...) / geometry(...) / intersects(...) — Old prefixes removed; unified as first-class methods.

Wrong: Using args / #call / #ref containers → Correct: Write JSON params directly by position — Parameter containers and embedded functions removed.

Wrong: Writing write_param() or func(...) in condition field → Correct: Move to ontoL_execution — Condition field only allows decidable read-only judgments.

Wrong: n(#ID) as DB internal ID → Correct: Understand via ontoL_snowflake_id / ontoL_source_id / ontoL_reldb_id — Business PK ≠ graph DB internal ID.

Acceptance Checklist

Registry executable method count = 97; categories, param counts, terminality, condition usability consistent with method_registry.py.

Every registered method has execution implementation; unknown methods, unknown prefixes, legacy param containers → fail-closed.

Condition field rejects write_param, write_params_self, db_sim, db_query, func, mcp and other write/external actions. $field and #field no mutual fallback; missing field returns Chinese failure reason.

JSON strings double-quoted; field refs not chain heads; no nested functions in params.

Four-state data clearly distinguished: null, [], [obj], [obj, ...] not mixed. path in execution field awaits sub-chain completion; in condition field read-only query only. db_query uses $field / #field binding; legacy :param rejected; SQL values not concatenated.

Fetch functions max 20 rows; no write_params_self() → no assignment, no fission.

Write-back preserves uninvolved fields; no write to ontoL_* system fields; scalar write-back has unique target.

Formal graph and copy isolated; rehearsal results not written to formal graph real-time data. msg Chinese semantics; meta["trace"] per-method records params, results, status, errors. tests/test_dsl_*.py pass; test_dsl_library.py, test_dsl_method_contract.py, test_dsl_formula_catalog.py no regressions.

Known Boundaries

Behavioral function does not decide which node reasoning engine runs first; path(...) is the only call in execution field that triggers additional sub-chain reasoning.

No arbitrary Python, arbitrary loops, arbitrary recursion, nested functions in params, implicit re-read of previous function result.

No dynamic table/column name replacement in SQL; only value param named binding.

No mutual fallback between shared and self params; both channels must be explicitly chosen.

No writes, external calls, or fetch actions in condition fields.

No auto-migration of legacy expressions, legacy field placeholder syntax, legacy param containers, legacy language prefixes.

No guarantee of continued execution of all downstream nodes after failure; branches advance per actual graph relations and reasoning engine gates.

Static validation does not prove field existence, permission satisfaction, approval passed, or business result correctness.

Method catalog is dynamic contract; new methods must sync registry, executor, prompts, docs, and contract tests.

Appendix A: Method Category Index

From current method_registry.py, 97 executable methods. Signatures, param counts, per-method docs per registry.

Read, Judge & Transform (15) : abs, coalesce, contains, default, ends_with, from_json, has, is_null, length, matches, round, starts_with, to_date, to_number, to_string Graph Traversal & Path Finding (8) : exists_path, next_n, next_r, path, path_value, prev_n, prev_r, reachable Row Filtering & Result Control (7) : all, any, filter, is_not, limit, none, order_by Aggregation & Collection (16) : avg, avg_self, collect, count, count_self, distinct, distinct_count, distinct_count_self, group_by, max, max_self, min, min_self, sum, sum_self, unwind Date Calculation (5) : date_add, date_diff, days_since, days_until, duration Temporal Relations (14) : timeAfter, timeBefore, timeBetween, timeContains, timeEquals, timeFinishedBy, timeFinishes, timeMeets, timeMetBy, timeOverlap, timeOverlappedBy, timeSpan, timeStartedBy, timeStarts Spatial Operations (4) : distance, geometry, intersects, within OWL Constraints (17) : all_values_from, different_from, disjoint_with, equivalent_class, functional, has_key, in_class, inverse_functional, inverse_of, not_of_type, of_type, property_chain, property_chain_to, qualified_cardinality, same_as, some_values_from, transitive Data Fetch (2) : db_query, db_sim Write & Action (7) : detach, empty, remove, set, warn, write_param, write_params_self External Call (2) : func, mcp Comparison (0) : Display-only in formula catalog, no executable registered methods.

Literal (0) : Display-only in formula catalog, no executable registered methods.

Appendix B: Method Statistics

Total executable methods: 97

Total semantic categories: 13

Categories with executable methods: 11

Display-only categories: 2

Terminal methods: 48

Boolean methods usable as condition terminals: 43

Temporal relation methods: 14 ( timeSpan + 13 Allen)

OWL constraint methods: 17

Appendix C: Fact Sources & Maintenance Entrypoints

Method contract single source of truth: business/ontoL_languages_dsl/method_registry.py Method semantic categories: business/ontoL_languages_dsl/method_categories.py Chain head & method chain parsing: business/ontoL_languages_dsl/core/chain_parser.py Execution dispatch & evaluation: business/ontoL_languages_dsl/execute.py Condition decidability validation: business/ontoL_languages_dsl/condition_validator.py Formula catalog: business/ontoL_languages_dsl/formula_catalog.py Common library API: business/ontoL_languages_dsl/library.py, gateway/routes/dsl_routes.py Prompt injection: business/ontoL_languages_dsl/generation_dsl.py, business/prompts/common/dsl/generation_dsl.py Path finding & scope: business/ontoL_languages_dsl/path_query.py, path_owner.py SQL field binding: business/ontoL_languages_dsl/sql_binding.py Regression tests:

tests/test_dsl_*.py
Maintenance principle: when adding or modifying methods, must sync registry, execution dispatch, prompts, user docs, architecture docs, and contract tests. Method counts, categories, and names in this document verified against current registry; if code changes, GET /api/v1/dsl/functions and method_registry.py results are authoritative.
Original Source

Signed-in readers can open the original source through BestHub's protected redirect.

Sign in to view source
Republication Notice

This article has been distilled and summarized from source material, then republished for learning and reference. If you believe it infringes your rights, please contactadmin@besthub.devand we will review it promptly.

DSLAPIontologygraph query languagetemporal reasoningOntologyL_Cypherchain-based languagedual-channel parametersOWL 2 RLpath findingspatial operationsstatic validation
Reader feedback

How this landed with the community

Sign in to like

Rate this article

Was this worth your time?

Sign in to rate
Discussion

0 Comments

Thoughtful readers leave field notes, pushback, and hard-won operational detail here.