@platforma-sdk/workflow-tengo 5.15.1 → 5.16.0

package/dist/tengo/lib/pframes.build-query.lib.tengo

@@ -0,0 +1,128 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+ll := import("@platforma-sdk/workflow-tengo:ll")
+
+
+
+columnEntry := func(columnId, qualifications) {
+	entry := { entry: { type: "column", column: columnId } }
+	if !is_undefined(qualifications) && len(qualifications) > 0 {
+		entry.qualifications = qualifications
+	}
+	return entry
+}
+
+linkerJoinEntry := func(linkerId, secondary, qualifications) {
+	entry := {
+		entry: {
+			type: "linkerJoin",
+			linker: { column: linkerId },
+			secondary: secondary
+		}
+	}
+	if !is_undefined(qualifications) && len(qualifications) > 0 {
+		entry.qualifications = qualifications
+	}
+	return entry
+}
+
+innerJoinEntry := func(entries, qualifications) {
+	entry := { entry: { type: "innerJoin", entries: entries } }
+	if !is_undefined(qualifications) && len(qualifications) > 0 {
+		entry.qualifications = qualifications
+	}
+	return entry
+}
+
+wrapLinker := func(currentEntry, linkerId) {
+	return linkerJoinEntry(linkerId, [currentEntry], [])
+}
+
+wrapFilter := func(currentEntry, filterId) {
+	return innerJoinEntry([currentEntry, columnEntry(filterId, [])], [])
+}
+
+stepColumnId := func(step) {
+	if step.type == "linker" {
+		ll.assert(!is_undefined(step.linker), "linker step missing 'linker' field")
+		ll.assert(!is_undefined(step.linker.columnId),
+			"linker step's linker missing 'columnId' field")
+		return step.linker.columnId
+	}
+	if step.type == "filter" {
+		ll.assert(!is_undefined(step.filter), "filter step missing 'filter' field")
+		ll.assert(!is_undefined(step.filter.columnId),
+			"filter step's filter missing 'columnId' field")
+		return step.filter.columnId
+	}
+	ll.panic("unknown step type: %v", step.type)
+}
+
+
+
+
+
+
+
+
+
+
+
+buildQuery := func(input) {
+	ll.assert(ll.isMap(input), "buildQuery: input must be a map, got %v", input)
+	version := input.version
+	ll.assert(version == "v1",
+		"buildQuery: unsupported version %v (expected \"v1\")", version)
+
+	column := input.column
+	ll.assert(is_string(column),
+		"buildQuery: 'column' must be a string, got %v", column)
+
+	path := input.path
+	if is_undefined(path) {
+		path = []
+	}
+	ll.assert(is_array(path), "buildQuery: 'path' must be an array")
+
+	qualifications := input.qualifications
+	if is_undefined(qualifications) {
+		qualifications = []
+	}
+	ll.assert(is_array(qualifications),
+		"buildQuery: 'qualifications' must be an array")
+
+	current := columnEntry(column, [])
+	for i := len(path) - 1; i >= 0; i-- {
+		step := path[i]
+		colId := stepColumnId(step)
+		if step.type == "linker" {
+			current = wrapLinker(current, colId)
+		} else {
+			current = wrapFilter(current, colId)
+		}
+	}
+
+	if len(qualifications) == 0 {
+		return current
+	}
+	current.qualifications = qualifications
+	return current
+}
+
+export ll.toStrict({
+	buildQuery: buildQuery,
+	columnEntry: columnEntry,
+	linkerJoinEntry: linkerJoinEntry,
+	innerJoinEntry: innerJoinEntry
+})

package/dist/tengo/lib/pt.lib.tengo

@@ -59,33 +59,104 @@ _newDataFrameGroupBy := undefined
 
 workflowCounter := 0
 
-_validateColumn := func(name, columnStruct) {
+_validateColumn := func(name, columnMap) {
 	ll.assert(is_string(name), "column name must be a string")
-	ll.assert(is_map(columnStruct), "columnStruct must be a map")
-	ll.assert(!is_undefined(columnStruct.spec), "columnStruct must have 'spec' field defined")
-	ll.assert(!is_undefined(columnStruct.data), "columnStruct must have 'data' field defined")
+	ll.assert(is_map(columnMap), "column must be a map")
+	ll.assert(!is_undefined(columnMap.spec), "column must have 'spec' field defined")
+	ll.assert(!is_undefined(columnMap.data), "column must have 'data' field defined")
 }
 
-_newPEntry := func(columnsByName, joinTree) {
+_newPEntry := func(columnsByName, specQuery) {
 	return ll.toStrict({
 
 		_getColumnsMap: func() {
 			return columnsByName
 		},
 
-		_getJoinTree: func() {
-			return joinTree
+		_getSpecQuery: func() {
+			return specQuery
 		}
 	})
 }
 
 _isPEntry := func(entry) {
-	return ll.isMap(entry) && ll.methodExists(entry, "_getColumnsMap") && ll.methodExists(entry, "_getJoinTree");
+	return ll.isMap(entry) && ll.methodExists(entry, "_getColumnsMap") && ll.methodExists(entry, "_getSpecQuery");
 }
 
 _frameToPEntries := undefined
 
-slicedColumnCounter := 0
+
+
+
+
+_mergePEntries := func(entries) {
+	columns := {}
+	specQueries := []
+	for entry in entries {
+		ll.assert(_isPEntry(entry), "expected a PEntry, got: %v", entry)
+		entryColumns := entry._getColumnsMap()
+
+
+		maps.forEach(entryColumns, func(name, info) {
+			if !is_undefined(columns[name]) {
+				ll.panic("column name %s is already used, please pick a different name", name)
+			}
+			columns[name] = info
+		})
+		specQueries = append(specQueries, entry._getSpecQuery())
+	}
+	return { columns: columns, specQueries: specQueries }
+}
+
+
+
+
+_asJoinEntry := func(specQuery) {
+	return { entry: specQuery }
+}
+
+_asJoinEntries := func(specQueries) {
+	return slices.map(specQueries, _asJoinEntry)
+}
+
+
+
+
+
+
+
+_buildAxisSelector := func(axesSpec, idx) {
+	axis := axesSpec[idx]
+	selector := { name: axis.name }
+	if !is_undefined(axis.type) {
+		selector.type = axis.type
+	}
+	if !is_undefined(axis.domain) && len(axis.domain) > 0 {
+		selector.domain = maps.clone(axis.domain)
+	}
+	if !is_undefined(axis.contextDomain) && len(axis.contextDomain) > 0 {
+		selector.contextDomain = maps.clone(axis.contextDomain)
+	}
+	if !is_undefined(axis.parentAxes) && len(axis.parentAxes) > 0 {
+		parents := []
+		for parentIdx in axis.parentAxes {
+			ll.assert(parentIdx >= 0 && parentIdx < idx,
+				"slicedColumn: parentAxes index %d must be less than current axis index %d",
+				parentIdx, idx)
+			parents = append(parents, _buildAxisSelector(axesSpec, parentIdx))
+		}
+		selector.parentAxes = parents
+	}
+	return selector
+}
+
+
+
+
+
+
+
+
 
 p := ll.toStrict({
 
@@ -94,13 +165,13 @@ p := ll.toStrict({
 
 
 
-	column: func(name, columnStruct) {
-		_validateColumn(name, columnStruct)
+	column: func(name, columnMap) {
+		_validateColumn(name, columnMap)
 		columnsByName := {}
-		columnsByName[name] = columnStruct
+		columnsByName[name] = columnMap
 		return _newPEntry(columnsByName, {
 			type: "column",
-			columnId: name
+			column: name
 		})
 	},
 
@@ -110,20 +181,35 @@ p := ll.toStrict({
 
 
 
+
+
+
 	slicedColumn: func(name, columnMap, axisFilters) {
 		_validateColumn(name, columnMap)
 		util.validateAxisFilters(axisFilters)
 
-		slicedColumnCounter += 1
-		oldName := "p_sliced_" + slicedColumnCounter
+		axesSpec := columnMap.spec.axesSpec
+		ll.assert(is_array(axesSpec),
+			"slicedColumn: column %q spec must carry axesSpec, got: %v", name, columnMap.spec)
+
+		resolvedFilters := []
+		for filter in axisFilters {
+			idx := filter.axisIndex
+			ll.assert(idx >= 0 && idx < len(axesSpec),
+				"slicedColumn: axisIndex %d out of range for column %q (axes: %d)",
+				idx, name, len(axesSpec))
+			resolvedFilters = append(resolvedFilters, {
+				axisSelector: _buildAxisSelector(axesSpec, idx),
+				constant: filter.constant
+			})
+		}
 
 		columnsByName := {}
-		columnsByName[oldName] = columnMap
+		columnsByName[name] = columnMap
 		return _newPEntry(columnsByName, {
-			type: "slicedColumn",
-			columnId: oldName,
-			newId: name,
-			axisFilters: axisFilters
+			type: "sliceAxes",
+			input: { type: "column", column: name },
+			axisFilters: resolvedFilters
 		})
 	},
 
@@ -133,36 +219,14 @@ p := ll.toStrict({
 
 	inner: func(...entries) {
 		ll.assert(len(entries) > 0, "inner join requires at least one entry")
-
 		if len(entries) == 1 && !_isPEntry(entries[0]) {
 			entries = _frameToPEntries(entries[0])
 		}
-
-		mergedColMap := {}
-		joinTreeEntries := []
-
-		for entry in entries {
-			ll.assert(_isPEntry(entry), "all entries must be PEntry objects")
-
-			entryColMap := entry._getColumnsMap()
-			entryJoinTree := entry._getJoinTree()
-
-			for colName, colInfo in entryColMap {
-				if !is_undefined(mergedColMap[colName]) {
-					ll.panic("column name %s is already used, please pick a different name", colName)
-				}
-				mergedColMap[colName] = colInfo
-			}
-
-			joinTreeEntries = append(joinTreeEntries, entryJoinTree)
-		}
-
-		joinTree := {
-			type: "inner",
-			entries: joinTreeEntries
-		}
-
-		return _newPEntry(mergedColMap, joinTree)
+		merged := _mergePEntries(entries)
+		return _newPEntry(merged.columns, {
+			type: "innerJoin",
+			entries: _asJoinEntries(merged.specQueries)
+		})
 	},
 
 
@@ -171,36 +235,14 @@ p := ll.toStrict({
 
 	full: func(...entries) {
 		ll.assert(len(entries) > 0, "full join requires at least one entry")
-
 		if len(entries) == 1 && !_isPEntry(entries[0]) {
 			entries = _frameToPEntries(entries[0])
 		}
-
-		mergedColMap := {}
-		joinTreeEntries := []
-
-		for entry in entries {
-			ll.assert(_isPEntry(entry), "all entries must be PEntry objects")
-
-			entryColMap := entry._getColumnsMap()
-			entryJoinTree := entry._getJoinTree()
-
-			for colName, colInfo in entryColMap {
-				if !is_undefined(mergedColMap[colName]) {
-					ll.panic("column name %s is already used, please pick a different name", colName)
-				}
-				mergedColMap[colName] = colInfo
-			}
-
-			joinTreeEntries = append(joinTreeEntries, entryJoinTree)
-		}
-
-		joinTree := {
-			type: "full",
-			entries: joinTreeEntries
-		}
-
-		return _newPEntry(mergedColMap, joinTree)
+		merged := _mergePEntries(entries)
+		return _newPEntry(merged.columns, {
+			type: "fullJoin",
+			entries: _asJoinEntries(merged.specQueries)
+		})
 	},
 
 
@@ -211,41 +253,37 @@ p := ll.toStrict({
 	outer: func(primary, ...secondary) {
 		ll.assert(_isPEntry(primary), "primary entry must be a PEntry object")
 		ll.assert(len(secondary) > 0, "outer join requires at least one secondary entry")
+		merged := _mergePEntries(append([primary], secondary...))
+		return _newPEntry(merged.columns, {
+			type: "outerJoin",
+			primary: _asJoinEntry(merged.specQueries[0]),
+			secondary: _asJoinEntries(merged.specQueries[1:])
+		})
+	},
+
 
-		mergedColMap := {}
 
-		primaryColMap := primary._getColumnsMap()
-		primaryJoinTree := primary._getJoinTree()
 
-		for colName, colInfo in primaryColMap {
-			mergedColMap[colName] = colInfo
-		}
 
-		secondaryJoinTrees := []
 
-		for entry in secondary {
-			ll.assert(_isPEntry(entry), "all secondary entries must be PEntry objects")
 
-			entryColMap := entry._getColumnsMap()
-			entryJoinTree := entry._getJoinTree()
 
-			for colName, colInfo in entryColMap {
-				if !is_undefined(mergedColMap[colName]) {
-					ll.panic("column name %s is already used, please pick a different name", colName)
-				}
-				mergedColMap[colName] = colInfo
-			}
 
-			secondaryJoinTrees = append(secondaryJoinTrees, entryJoinTree)
-		}
 
-		joinTree := {
-			type: "outer",
-			primary: primaryJoinTree,
-			secondary: secondaryJoinTrees
-		}
 
-		return _newPEntry(mergedColMap, joinTree)
+
+	linkerJoin: func(linkerColumnEntry, secondaryEntry) {
+		ll.assert(_isPEntry(linkerColumnEntry), "linker must be a PEntry object")
+		linkerQuery := linkerColumnEntry._getSpecQuery()
+		ll.assert(ll.isMap(linkerQuery) && linkerQuery.type == "column",
+			"linkerJoin: linker entry must be a plain p.column(...) result, got: %v", linkerQuery)
+
+		merged := _mergePEntries([linkerColumnEntry, secondaryEntry])
+		return _newPEntry(merged.columns, {
+			type: "linkerJoin",
+			linker: { column: linkerQuery.column },
+			secondary: [_asJoinEntry(merged.specQueries[1])]
+		})
 	}
 })
 
@@ -556,7 +594,6 @@ workflow := func() {
 			step := undefined
 			if finalFormat == "pentry" {
 				columnsMap := frameInput._getColumnsMap()
-				src := frameInput._getJoinTree()
 
 
 				translation := {}
@@ -571,12 +608,7 @@ workflow := func() {
 					renamedColumnsMap[workflowUniqueColumnId] = columnInfo
 				})
 
-
-				request := {
-					src: src,
-					filters: []
-				}
-				renamedRequest := util.renameJoinColumns(request, rename)
+				renamedQuery := util.renameSpecQueryColumns(frameInput._getSpecQuery(), rename)
 
 
 				ll.assert(is_undefined(inFrames[finalDataFrameId]),
@@ -588,7 +620,7 @@ workflow := func() {
 				step = {
 					type: "read_frame",
 					name: finalDataFrameId,
-					request: renamedRequest,
+					request: { query: renamedQuery },
 					translation: translation
 				}
 			} else if finalFormat == "parquet" {

package/dist/tengo/lib/pt.util.lib.tengo

@@ -190,219 +190,273 @@ validateAxisFilters := func(axisFilter) {
 }
 
 
-_JOIN_ENTRY_SCHEMA := undefined
 
-_JOIN_LEAF_SCHEMA := func(js, _, _) {
-	return validation.checkJson(js, _JOIN_ENTRY_SCHEMA)
-}
-_JOIN_SUBTREE_SCHEMA := func(js, _, _) {
-	return validation.checkJson(js, [_JOIN_ENTRY_SCHEMA])
-}
-
-_JOIN_ENTRY_SCHEMA = [`or`,
-    {
-
-		`type`: `string,regex=column`,
-
-		`columnId`: `string`
-	},
-    {
-
-        `type`: `string,regex=slicedColumn`,
-
-		`columnId`: `string`,
-
-        `newId`: `string`,
-
-        `axisFilters`: [_AXIS_FILTER_SCHEMA]
-    },
-    {
-
-        `type`: `string,regex=artificialColumn`,
-
-		`columnId`: `string`,
 
-        `newId`: `string`,
 
-        `axesIndices`: [`number`]
-    },
-    {
 
-        `type`: `string,regex=inlineColumn`,
 
-        `newId`: `string`,
-
-        `spec`: spec.P_COLUMN_STRICT_SPEC_SCHEMA,
+_SINGLE_AXIS_SELECTOR_SCHEMA := undefined
+_PARENT_AXES_LAZY := func(js, _, _) {
+	return validation.checkJson(js, [_SINGLE_AXIS_SELECTOR_SCHEMA])
+}
+_SINGLE_AXIS_SELECTOR_SCHEMA = {
+	`name`: `string`,
+	`type,?`: `string,regex=Int|Long|String`,
+	`domain,?`: { any: `string` },
+	`contextDomain,?`: { any: `string` },
+	`parentAxes,?`: _PARENT_AXES_LAZY
+}
 
-        `dataInfo`: {
+_SLICE_AXIS_FILTER_SCHEMA := {
+	`axisSelector`: _SINGLE_AXIS_SELECTOR_SCHEMA,
+	`constant`: [`or`, `number`, `string`]
+}
 
-            `type`: `string,regex=Json`,
 
-            `keyLength`: `number`,
+_SPEC_QUERY_SCHEMA := undefined
+_SPEC_QUERY_JOIN_ENTRY_SCHEMA := undefined
+_SPEC_EXPRESSION_SCHEMA := undefined
+_SPEC_QUERY_LAZY := func(js, _, _) {
+	return validation.checkJson(js, _SPEC_QUERY_SCHEMA)
+}
+_SPEC_QUERY_JOIN_ENTRY_LAZY := func(js, _, _) {
+	return validation.checkJson(js, _SPEC_QUERY_JOIN_ENTRY_SCHEMA)
+}
+_SPEC_QUERY_JOIN_ENTRY_LIST_LAZY := func(js, _, _) {
+	return validation.checkJson(js, [_SPEC_QUERY_JOIN_ENTRY_SCHEMA])
+}
+_SPEC_EXPRESSION_LAZY := func(js, _, _) {
+	return validation.checkJson(js, _SPEC_EXPRESSION_SCHEMA)
+}
+_SPEC_EXPRESSION_LIST_LAZY := func(js, _, _) {
+	return validation.checkJson(js, [_SPEC_EXPRESSION_SCHEMA])
+}
 
-            `data`: {
-                any: [`or`, `null`, `number`, `string`]
-            }
-        }
-    },
+_SPEC_EXPRESSION_SCHEMA = [`or`,
+	{ `type`: `string,regex=columnRef`, `value`: `string` },
+	{ `type`: `string,regex=axisRef`,   `value`: _SINGLE_AXIS_SELECTOR_SCHEMA },
+	{ `type`: `string,regex=constant`,  `value`: [`or`, `string`, `number`, `bool`] },
 	{
-
-		`type`: `string,regex=inner`,
-
-		`entries`: _JOIN_SUBTREE_SCHEMA
+		`type`: `string,regex=numericUnary`,
+		`operand`: `string,regex=abs|ceil|floor|round|sqrt|log|log2|log10|exp|negate`,
+		`input`: _SPEC_EXPRESSION_LAZY
 	},
 	{
-
-		`type`: `string,regex=full`,
-
-		`entries`: _JOIN_SUBTREE_SCHEMA
+		`type`: `string,regex=numericBinary`,
+		`operand`: `string,regex=add|sub|mul|div|mod`,
+		`left`: _SPEC_EXPRESSION_LAZY,
+		`right`: _SPEC_EXPRESSION_LAZY
 	},
 	{
-
-		`type`: `string,regex=outer`,
-
-		`primary`: _JOIN_LEAF_SCHEMA,
-
-
-		`secondary`: _JOIN_SUBTREE_SCHEMA
+		`type`: `string,regex=numericComparison`,
+		`operand`: `string,regex=eq|ne|lt|le|gt|ge`,
+		`left`: _SPEC_EXPRESSION_LAZY,
+		`right`: _SPEC_EXPRESSION_LAZY
+	},
+	{
+		`type`: `string,regex=stringEquals`,
+		`input`: _SPEC_EXPRESSION_LAZY,
+		`value`: `string`,
+		`caseInsensitive`: `bool`
+	},
+	{
+		`type`: `string,regex=stringContains`,
+		`input`: _SPEC_EXPRESSION_LAZY,
+		`value`: `string`,
+		`caseInsensitive`: `bool`
+	},
+	{
+		`type`: `string,regex=stringRegex`,
+		`input`: _SPEC_EXPRESSION_LAZY,
+		`value`: `string`
+	},
+	{
+		`type`: `string,regex=stringContainsFuzzy`,
+		`input`: _SPEC_EXPRESSION_LAZY,
+		`value`: `string`,
+		`maxEdits`: `number`,
+		`caseInsensitive`: `bool`,
+		`substitutionsOnly`: `bool`,
+		`wildcard,?`: [`or`, `null`, `string`]
+	},
+	{ `type`: `string,regex=isNull`, `input`: _SPEC_EXPRESSION_LAZY },
+	{
+		`type`: `string,regex=ifNull`,
+		`input`: _SPEC_EXPRESSION_LAZY,
+		`replacement`: _SPEC_EXPRESSION_LAZY
+	},
+	{ `type`: `string,regex=not`, `input`: _SPEC_EXPRESSION_LAZY },
+	{ `type`: `string,regex=and|or`, `input`: _SPEC_EXPRESSION_LIST_LAZY },
+	{
+		`type`: `string,regex=isIn`,
+		`input`: _SPEC_EXPRESSION_LAZY,
+		`set`: [`or`, [`string`], [`number`]],
+		`negate,?`: `bool`
 	}]
 
-
-_PREDICATE_SCHEMA := undefined
-
-_PREDICATE_LEAF_SCHEMA := func(js, _, _) {
-	return validation.checkJson(js, _PREDICATE_SCHEMA)
-}
-_PREDICATE_SUBTREE_SCHEMA := func(js, _, _) {
-	return validation.checkJson(js, [_PREDICATE_SCHEMA])
-}
-_PREDICATE_SCHEMA = [`or`,
-    {
-
-		`operator`: `string,regex=IsNA`
+_SPEC_QUERY_SCHEMA = [`or`,
+	{
+		`type`: `string,regex=column`,
+		`column`: `string`
 	},
-    {
-
-		`operator`: `string,regex=Equal|Less|LessOrEqual|Greater|GreaterOrEqual`,
-
-        `reference`: [`or`, `number`, `string`]
+	{
+		`type`: `string,regex=sliceAxes`,
+		`input`: _SPEC_QUERY_LAZY,
+		`axisFilters`: [_SLICE_AXIS_FILTER_SCHEMA]
 	},
-    {
-
-		`operator`: `string,regex=InSet`,
-
-        `values`: [`or`, [`number`], [`string`]]
-    },
-    {
-
-		`operator`: `string,regex=IEqual`,
-
-        `reference`: `string`
+	{
+		`type`: `string,regex=innerJoin|fullJoin`,
+		`entries`: _SPEC_QUERY_JOIN_ENTRY_LIST_LAZY
 	},
-    {
-
-		`operator`: `string,regex=StringContains|StringIContains`,
-
-        `substring`: `string`
+	{
+		`type`: `string,regex=outerJoin`,
+		`primary`: _SPEC_QUERY_JOIN_ENTRY_LAZY,
+		`secondary`: _SPEC_QUERY_JOIN_ENTRY_LIST_LAZY
 	},
-    {
-
-		`operator`: `string,regex=Matches`,
-
-        `regex`: `string`
+	{
+		`type`: `string,regex=linkerJoin`,
+		`linker`: { `column`: `string` },
+		`secondary`: _SPEC_QUERY_JOIN_ENTRY_LIST_LAZY
 	},
-    {
-
-		`operator`: `string,regex=StringContainsFuzzy|StringIContainsFuzzy`,
-
-        `reference`: `string`,
-
-        `maxEdits`: `number`,
-
-        `wildcard,?`: `string`,
+	{
+		`type`: `string,regex=filter`,
+		`input`: _SPEC_QUERY_LAZY,
+		`predicate`: _SPEC_EXPRESSION_SCHEMA
+	}]
 
-        `substitutionsOnly,?`: `bool`
-	},
-    {
+_SPEC_QUERY_JOIN_ENTRY_SCHEMA = {
+	`entry`: _SPEC_QUERY_SCHEMA,
+	`qualifications,?`: [{
+		`axis`: _SINGLE_AXIS_SELECTOR_SCHEMA,
+		`contextDomain`: { any: `string` }
+	}]
+}
 
-		`operator`: `string,regex=Not`,
+_renameSpecQuery := undefined
+_renameExpression := undefined
 
-        `operand`: _PREDICATE_LEAF_SCHEMA
-    },
-    {
 
-		`operator`: `string,regex=And|Or`,
 
-        `operands`: [_PREDICATE_SUBTREE_SCHEMA]
-    }]
+_renameJoinEntry := func(joinEntry, rename) {
+    result := { entry: _renameSpecQuery(joinEntry.entry, rename) }
+    if !is_undefined(joinEntry.qualifications) && len(joinEntry.qualifications) > 0 {
+        result.qualifications = joinEntry.qualifications
+    }
+    return result
+}
 
-_P_TABLE_COLUMN_ID_SCHEMA := [`or`,
-    {
+_renameJoinEntries := func(entries, rename) {
+    return slices.map(entries, func(e) { return _renameJoinEntry(e, rename) })
+}
 
-        `type`: `string,regex=column`,
+_renameExpressions := func(exprs, rename) {
+    return slices.map(exprs, func(e) { return _renameExpression(e, rename) })
+}
 
-        `id`: `string`
-    },
-    {
 
-        `type`: `string,regex=axis`,
 
-        `axisId`: {
-            `name`: `string`,
-            `type`: `string,regex=Int|Long|String`,
-            `domain,?`: { any: `string` },
-            `contextDomain,?`: { any: `string` }
+_renameExpression = func(expr, rename) {
+    t := expr.type
+    if t == "columnRef" {
+        return { type: "columnRef", value: rename[expr.value] }
+    } else if t == "axisRef" || t == "constant" {
+        return expr
+    } else if t == "numericUnary" {
+        return { type: t, operand: expr.operand, input: _renameExpression(expr.input, rename) }
+    } else if t == "numericBinary" || t == "numericComparison" {
+        return {
+            type: t, operand: expr.operand,
+            left: _renameExpression(expr.left, rename),
+            right: _renameExpression(expr.right, rename)
+        }
+    } else if t == "stringEquals" || t == "stringContains" {
+        return {
+            type: t,
+            input: _renameExpression(expr.input, rename),
+            value: expr.value,
+            caseInsensitive: expr.caseInsensitive
         }
-    }]
+    } else if t == "stringRegex" {
+        return { type: t, input: _renameExpression(expr.input, rename), value: expr.value }
+    } else if t == "stringContainsFuzzy" {
+        result := {
+            type: t,
+            input: _renameExpression(expr.input, rename),
+            value: expr.value,
+            maxEdits: expr.maxEdits,
+            caseInsensitive: expr.caseInsensitive,
+            substitutionsOnly: expr.substitutionsOnly
+        }
+        if !is_undefined(expr.wildcard) { result.wildcard = expr.wildcard }
+        return result
+    } else if t == "isNull" || t == "not" {
+        return { type: t, input: _renameExpression(expr.input, rename) }
+    } else if t == "ifNull" {
+        return {
+            type: "ifNull",
+            input: _renameExpression(expr.input, rename),
+            replacement: _renameExpression(expr.replacement, rename)
+        }
+    } else if t == "and" || t == "or" {
+        return { type: t, input: _renameExpressions(expr.input, rename) }
+    } else if t == "isIn" {
+        result := {
+            type: "isIn",
+            input: _renameExpression(expr.input, rename),
+            set: expr.set
+        }
+        if !is_undefined(expr.negate) { result.negate = expr.negate }
+        return result
+    }
+    ll.panic("renameSpecQueryColumns: unsupported expression variant %q", t)
+}
 
-_FILTER_SCHEMA := {
+_renameSpecQuery = func(query, rename) {
+    t := query.type
+    if t == "column" {
+        return { type: "column", column: rename[query.column] }
+    } else if t == "sliceAxes" {
+        return {
+            type: "sliceAxes",
+            input: _renameSpecQuery(query.input, rename),
+            axisFilters: query.axisFilters
+        }
+    } else if t == "innerJoin" || t == "fullJoin" {
+        return { type: t, entries: _renameJoinEntries(query.entries, rename) }
+    } else if t == "outerJoin" {
+        return {
+            type: "outerJoin",
+            primary: _renameJoinEntry(query.primary, rename),
+            secondary: _renameJoinEntries(query.secondary, rename)
+        }
+    } else if t == "linkerJoin" {
+        return {
+            type: "linkerJoin",
+            linker: { column: rename[query.linker.column] },
+            secondary: _renameJoinEntries(query.secondary, rename)
+        }
+    } else if t == "filter" {
+        return {
+            type: "filter",
+            input: _renameSpecQuery(query.input, rename),
+            predicate: _renameExpression(query.predicate, rename)
+        }
+    }
+    ll.panic("renameSpecQueryColumns: unsupported SpecQuery variant %q", t)
+}
 
-    `column`: _P_TABLE_COLUMN_ID_SCHEMA,
 
-    `predicate`: _PREDICATE_SCHEMA
-}
 
 
-_JOIN_REQUEST_SCHEMA := {
-    `__options__,closed`: true,
 
-    `src`: _JOIN_ENTRY_SCHEMA,
 
-    `filters`: [_FILTER_SCHEMA]
-}
 
-_renameJoinEntry := func(entry, rename) {
-    if entry.type == "column" || entry.type == "slicedColumn" || entry.type == "artificialColumn" {
-        entry.columnId = rename[entry.columnId]
-    } else if entry.type == "inner" || entry.type == "full" {
-        entry.entries = slices.map(entry.entries, func(entry) {
-            return _renameJoinEntry(entry, rename)
-        })
-    } else if entry.type == "outer" {
-        entry.primary = _renameJoinEntry(entry.primary, rename)
-        entry.secondary = slices.map(entry.secondary, func(entry) {
-            return _renameJoinEntry(entry, rename)
-        })
-    }
-    return entry
-}
 
-_renameJoinFilter := func(filter, rename) {
-    if filter.column.type == "column" {
-        filter.column.id = rename[filter.column.id]
-    }
-    return filter
-}
 
-renameJoinColumns := func(request, rename) {
-    validation.assertType(request, _JOIN_REQUEST_SCHEMA)
+renameSpecQueryColumns := func(query, rename) {
+    validation.assertType(query, _SPEC_QUERY_SCHEMA)
     validation.assertType(rename, {any: `string`})
-    return {
-        src: _renameJoinEntry(request.src, rename),
-        filters: slices.map(request.filters, func(filter) {
-            return _renameJoinFilter(filter, rename)
-        })
-    }
+    return _renameSpecQuery(query, rename)
 }
 
 export ll.toStrict({
@@ -411,6 +465,6 @@ export ll.toStrict({
     makeFrameColumnInfo: makeFrameColumnInfo,
     makeWriteFrameStep: makeWriteFrameStep,
     makeFrameColumnRef: makeFrameColumnRef,
-    renameJoinColumns: renameJoinColumns,
+    renameSpecQueryColumns: renameSpecQueryColumns,
     validateAxisFilters: validateAxisFilters
 })

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platforma-sdk/workflow-tengo",
-  "version": "5.15.1",
+  "version": "5.16.0",
   "description": "Tengo SDK library",
   "type": "module",
   "types": "./dist/index.d.ts",
@@ -18,11 +18,11 @@
   "dependencies": {
     "@milaboratories/software-pframes-conv": "2.2.9",
     "@platforma-open/milaboratories.software-small-binaries": "^2.0.3",
-    "@platforma-open/milaboratories.software-ptabler": "1.15.2",
+    "@platforma-open/milaboratories.software-ptabler": "1.16.0",
     "@platforma-open/milaboratories.software-ptexter": "1.2.2"
   },
   "devDependencies": {
-    "@platforma-sdk/tengo-builder": "2.5.15"
+    "@platforma-sdk/tengo-builder": "2.5.17"
   },
   "scripts": {
     "type-check": "pl-tengo check",