squirreling 0.12.5 → 0.12.6

package/README.md

@@ -161,6 +161,7 @@ Squirreling mostly follows the SQL standard. The following features are supporte
 - Date: `CURRENT_DATE`, `CURRENT_TIME`, `CURRENT_TIMESTAMP`, `DATE_PART`, `DATE_TRUNC`, `EXTRACT`, `INTERVAL`
 - Json: `JSON_VALUE`, `JSON_QUERY`, `JSON_EXTRACT`, `JSON_OBJECT`, `JSON_ARRAY_LENGTH`
 - Array: `ARRAY_LENGTH`, `ARRAY_POSITION`, `ARRAY_SORT`, `CARDINALITY`
+- Table functions: `UNNEST`
 - Regex: `REGEXP_SUBSTR`, `REGEXP_EXTRACT`, `REGEXP_REPLACE`, `REGEXP_MATCHES`
 - Spatial: `ST_GeomFromText`, `ST_MakeEnvelope`, `ST_AsText`, `ST_Intersects`, `ST_Contains`, `ST_ContainsProperly`, `ST_Within`, `ST_Overlaps`, `ST_Touches`, `ST_Equals`, `ST_Crosses`, `ST_Covers`, `ST_CoveredBy`, `ST_DWithin`
 - Conditional: `COALESCE`, `NULLIF`, `GREATEST`, `LEAST`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "squirreling",
-  "version": "0.12.5",
+  "version": "0.12.6",
   "description": "Squirreling Async SQL Engine",
   "author": "Hyperparam",
   "homepage": "https://hyperparam.app",
@@ -40,10 +40,10 @@
   },
   "devDependencies": {
     "@types/node": "25.6.0",
-    "@vitest/coverage-v8": "4.1.4",
+    "@vitest/coverage-v8": "4.1.5",
     "eslint": "9.39.2",
     "eslint-plugin-jsdoc": "62.9.0",
     "typescript": "6.0.3",
-    "vitest": "4.1.4"
+    "vitest": "4.1.5"
   }
 }

package/src/ast.d.ts

@@ -12,7 +12,7 @@ export interface SelectStatement extends AstBase {
   type: 'select'
   distinct: boolean
   columns: SelectColumn[]
-  from: FromTable | FromSubquery
+  from: FromTable | FromSubquery | FromFunction
   joins: JoinClause[]
   where?: ExprNode
   groupBy: ExprNode[]
@@ -60,6 +60,14 @@ export interface FromSubquery extends AstBase {
   alias?: string
 }
 
+export interface FromFunction extends AstBase {
+  type: 'function'
+  funcName: string
+  args: ExprNode[]
+  alias?: string
+  columnAlias?: string
+}
+
 export type ArithmeticOp = '+' | '-' | '*' | '/' | '%'
 
 export type BinaryOp = 'AND' | 'OR' | 'LIKE' | ComparisonOp | ArithmeticOp
@@ -193,6 +201,7 @@ export interface JoinClause extends AstBase {
   table: string
   alias?: string
   on?: ExprNode
+  fromFunction?: FromFunction
 }
 
 // All AST node derive from this base, which includes position info for error reporting and other purposes

package/src/execute/aggregates.js

@@ -120,11 +120,10 @@ export function executeHashAggregate(plan, context) {
  */
 export function executeScalarAggregate(plan, context) {
   // Fast path: use scanColumn when available
-  const scalarColumns = selectColumnNames(plan.columns, [])
   const fast = tryColumnScanAggregate(plan, context)
   if (fast) {
     return {
-      columns: scalarColumns,
+      columns: selectColumnNames(plan.columns, []),
       numRows: 1,
       maxRows: 1,
       rows: fast,

package/src/execute/execute.js

@@ -12,7 +12,7 @@ import { addBounds, minBounds, stableRowKey } from './utils.js'
 
 /**
  * @import { AsyncCells, AsyncDataSource, AsyncRow, DerivedColumn, ExecuteContext, ExecuteSqlOptions, ExprNode, IdentifierNode, QueryResults, SelectColumn, SqlPrimitive, Statement } from '../types.js'
- * @import { CountNode, DistinctNode, FilterNode, LimitNode, ProjectNode, QueryPlan, ScanNode, SetOperationNode } from '../plan/types.js'
+ * @import { CountNode, DistinctNode, FilterNode, LimitNode, ProjectNode, QueryPlan, ScanNode, SetOperationNode, TableFunctionNode } from '../plan/types.js'
  */
 
 /**
@@ -36,8 +36,16 @@ export function executeSql({ tables, query, functions, signal }) {
   }
 
   const scope = statementScope(parsed)
-  const context = { tables: normalizedTables, functions, signal, scope }
-  const plan = planSql({ query: parsed, functions, tables: normalizedTables })
+  // CTEs are resolved at plan time for FROM/JOIN positions. Subqueries inside
+  // expressions are re-planned during execution, so capture the CTE maps here
+  // and thread them through the context so those re-plans can still resolve
+  // CTE references.
+  /** @type {Map<string, QueryPlan>} */
+  const ctePlans = new Map()
+  /** @type {Map<string, string[]>} */
+  const cteColumns = new Map()
+  const context = { tables: normalizedTables, functions, signal, scope, ctePlans, cteColumns }
+  const plan = planSql({ query: parsed, functions, tables: normalizedTables, ctePlans, cteColumns })
   return executePlan({ plan, context })
 }
 
@@ -51,7 +59,13 @@ export function executeSql({ tables, query, functions, signal }) {
  * @returns {QueryResults}
  */
 export function executeStatement({ query, context, outerScope }) {
-  const plan = planStatement({ stmt: query, tables: context.tables, outerScope })
+  const plan = planStatement({
+    stmt: query,
+    tables: context.tables,
+    ctePlans: context.ctePlans,
+    cteColumns: context.cteColumns,
+    outerScope,
+  })
   // Compute this query's scope (FROM alias + JOIN aliases) for nested correlated subqueries
   const scope = statementScope(query)
   return executePlan({ plan, context: scope ? { ...context, scope } : context })
@@ -104,10 +118,44 @@ export function executePlan({ plan, context }) {
     return executeLimit(plan, context)
   } else if (plan.type === 'SetOperation') {
     return executeSetOperation(plan, context)
+  } else if (plan.type === 'TableFunction') {
+    return executeTableFunction(plan, context)
   }
   return { columns: [], async *rows() {} }
 }
 
+/**
+ * Executes a table-valued function (e.g. UNNEST).
+ * Evaluates the argument once against an empty row and yields one row per
+ * element of the resulting array. Null or non-array input yields zero rows.
+ *
+ * @param {TableFunctionNode} plan
+ * @param {ExecuteContext} context
+ * @returns {QueryResults}
+ */
+function executeTableFunction(plan, context) {
+  if (plan.funcName !== 'UNNEST') {
+    throw new Error(`Unsupported table function: ${plan.funcName}`)
+  }
+  const columns = [plan.columnName]
+  return {
+    columns,
+    async *rows() {
+      /** @type {AsyncRow} */
+      const row = context.outerRow ?? { columns: [], cells: {} }
+      const value = await evaluateExpr({ node: plan.args[0], row, rowIndex: 1, context })
+      if (!Array.isArray(value)) return
+      for (const element of value) {
+        if (context.signal?.aborted) return
+        yield {
+          columns,
+          cells: { [plan.columnName]: () => Promise.resolve(element) },
+        }
+      }
+    },
+  }
+}
+
 /**
  * Derives output column names from SELECT columns and available child columns.
  *
@@ -124,7 +172,7 @@ export function selectColumnNames(selectColumns, childColumns) {
       for (const key of childColumns) {
         if (prefix && !key.startsWith(prefix)) continue
         const dotIndex = key.indexOf('.')
-        const outputKey = prefix ? key.substring(prefix.length) : dotIndex >= 0 ? key.substring(dotIndex + 1) : key
+        const outputKey = dotIndex >= 0 ? key.substring(dotIndex + 1) : key
         result.push(outputKey)
       }
     } else {
@@ -217,33 +265,30 @@ function executeScan(plan, context) {
 function executeCount(plan, context) {
   const { tables, signal } = context
   const table = validateTable({ ...plan, tables })
+  const columns = plan.columns.map(col => col.alias ?? derivedAlias(col.expr))
 
   return {
-    columns: plan.columns.map(col => col.alias ?? derivedAlias(col.expr)),
+    columns,
     numRows: 1,
     maxRows: 1,
     async *rows() {
       // Use source numRows if available
-      let count = table.numRows
-      if (count === undefined) {
+      const countPromise = table.numRows !== undefined ? Promise.resolve(table.numRows) : (async () => {
         // Fall back to counting rows via scan
-        count = 0
+        let count = 0
         const { rows } = table.scan({ signal })
         // eslint-disable-next-line no-unused-vars
         for await (const _ of rows()) {
           if (signal?.aborted) return
           count++
         }
-      }
+        return count
+      })()
 
-      /** @type {string[]} */
-      const columns = []
       /** @type {AsyncCells} */
       const cells = {}
-      for (const col of plan.columns) {
-        const alias = col.alias ?? derivedAlias(col.expr)
-        columns.push(alias)
-        cells[alias] = () => Promise.resolve(count)
+      for (const alias of columns) {
+        cells[alias] = () => countPromise
       }
       yield { columns, cells }
     },
@@ -318,21 +363,19 @@ async function* filterRows(rows, condition, context, limit) {
  * @param {AbortSignal} [signal]
  * @yields {AsyncRow}
  */
-async function* limitRows(rows, limit, offset, signal) {
-  const skip = offset ?? 0
-  const max = limit ?? Infinity
-  if (max <= 0) return
+async function* limitRows(rows, limit = Infinity, offset = 0, signal) {
+  if (limit <= 0) return
   let skipped = 0
   let yielded = 0
   for await (const row of rows) {
     if (signal?.aborted) return
-    if (skipped < skip) {
+    if (skipped < offset) {
       skipped++
       continue
     }
     yield row
     yielded++
-    if (yielded >= max) return
+    if (yielded >= limit) return
   }
 }
 
@@ -361,86 +404,57 @@ function executeFilter(plan, context) {
  */
 function executeProject(plan, context) {
   const child = executePlan({ plan: plan.child, context })
+  const columns = selectColumnNames(plan.columns, child.columns)
 
-  // Pre-compute column names for derived columns (avoids per-row derivedAlias calls)
-  const hasStar = plan.columns.some(col => col.type === 'star')
-
-  /** @type {string[] | undefined} */
-  let staticColumns
-  /** @type {{ alias: string, sourceName: string }[] | undefined} */
-  let identifierMap
-  if (!hasStar) {
-    const derived = /** @type {DerivedColumn[]} */ (plan.columns)
-    staticColumns = derived.map(col => col.alias ?? derivedAlias(col.expr))
-    const allIdentifiers = derived.every(col =>
-      col.expr.type === 'identifier' && !col.expr.prefix
-    )
-    if (allIdentifiers) {
-      identifierMap = derived.map((col, i) => ({
-        alias: staticColumns[i],
-        sourceName: /** @type {IdentifierNode} */ (col.expr).name,
-      }))
-    }
-  }
+  const resolveable = plan.columns.every(col =>
+    col.type === 'star' || col.type === 'derived' && col.expr.type === 'identifier'
+  )
 
   return {
-    columns: selectColumnNames(plan.columns, child.columns),
+    columns,
     numRows: child.numRows,
     maxRows: child.maxRows,
     async *rows() {
       let rowIndex = 0
-      let identifierMapValidated = false
 
       for await (const row of child.rows()) {
         if (context.signal?.aborted) return
         rowIndex++
-
-        // Validate identifier fast path on first row (may fail for JOINs with prefixed columns)
-        if (identifierMap && !identifierMapValidated) {
-          identifierMapValidated = true
-          if (!identifierMap.every(m => m.sourceName in row.cells)) {
-            identifierMap = undefined
-          }
-        }
-
-        // Fast path: all columns are simple identifier references
-        if (identifierMap) {
-          /** @type {AsyncCells} */
-          const cells = {}
-          const source = row.resolved
-          /** @type {Record<string, SqlPrimitive> | undefined} */
-          const resolved = source ? {} : undefined
-          for (const { alias, sourceName } of identifierMap) {
-            cells[alias] = row.cells[sourceName]
-            if (resolved && source) resolved[alias] = source[sourceName]
-          }
-          yield resolved
-            ? { columns: staticColumns, cells, resolved }
-            : { columns: staticColumns, cells }
-          continue
-        }
-
         const currentRowIndex = rowIndex
 
-        /** @type {string[]} */
-        const columns = staticColumns ?? []
         /** @type {AsyncCells} */
         const cells = {}
-
-        for (let i = 0; i < plan.columns.length; i++) {
-          const col = plan.columns[i]
+        // Only safe to propagate resolved when every output column comes from
+        // the star branch — derived expressions evaluate lazily and can't be
+        // pre-materialized here, and a partial resolved would make
+        // collect()/downstream identifier fast paths read undefined.
+        const source = resolveable ? row.resolved : undefined
+        /** @type {Record<string, SqlPrimitive> | undefined} */
+        const resolved = source ? {} : undefined
+
+        let colIdx = 0
+        for (const col of plan.columns) {
           if (col.type === 'star') {
             const prefix = col.table ? `${col.table}.` : undefined
             for (const key of row.columns) {
               if (prefix && !key.startsWith(prefix)) continue
               const dotIndex = key.indexOf('.')
-              const outputKey = prefix ? key.substring(prefix.length) : dotIndex >= 0 ? key.substring(dotIndex + 1) : key
-              columns.push(outputKey)
+              const outputKey = dotIndex >= 0 ? key.substring(dotIndex + 1) : key
               cells[outputKey] = row.cells[key]
+              if (resolved && source) resolved[outputKey] = source[key]
+              colIdx++
             }
+          } else if (col.expr.type === 'identifier') {
+            // Common case: simple identifier. Avoid evaluateExpr overhead by
+            // directly mapping to the child's cell, relying on the planner to
+            // have normalized the identifier to match the child's column layout.
+            const id = col.expr
+            const sourceName = id.prefix ? `${id.prefix}.${id.name}` : id.name
+            cells[columns[colIdx]] = row.cells[sourceName]
+            if (resolved && source) resolved[columns[colIdx]] = source[sourceName]
+            colIdx++
           } else {
-            const alias = staticColumns ? staticColumns[i] : (col.alias ?? derivedAlias(col.expr))
-            if (!staticColumns) columns.push(alias)
+            const alias = columns[colIdx++]
             cells[alias] = () => evaluateExpr({
               node: col.expr,
               row,
@@ -450,7 +464,7 @@ function executeProject(plan, context) {
           }
         }
 
-        yield { columns, cells }
+        yield { columns, cells, resolved }
       }
     },
   }

package/src/execute/join.js

@@ -15,6 +15,9 @@ import { executePlan } from './execute.js'
  * @returns {QueryResults}
  */
 export function executeNestedLoopJoin(plan, context) {
+  if (plan.lateral) {
+    return executeLateralJoin(plan, context)
+  }
   const left = executePlan({ plan: plan.left, context })
   const right = executePlan({ plan: plan.right, context })
   return {
@@ -81,6 +84,57 @@ export function executeNestedLoopJoin(plan, context) {
   }
 }
 
+/**
+ * Executes a LATERAL nested loop join — the right side is re-executed per
+ * left row with the left row available as `context.outerRow`.
+ *
+ * @param {NestedLoopJoinNode} plan
+ * @param {ExecuteContext} context
+ * @returns {QueryResults}
+ */
+function executeLateralJoin(plan, context) {
+  const left = executePlan({ plan: plan.left, context })
+  // Right columns are known statically for table functions (the common case).
+  const rightCols = plan.right.type === 'TableFunction' ? [plan.right.columnName] : []
+  return {
+    columns: mergeColumnNames(left.columns, rightCols, plan.leftAlias, plan.rightAlias),
+    async *rows() {
+      const leftTable = plan.leftAlias
+      const rightTable = plan.rightAlias
+
+      for await (const leftRow of left.rows()) {
+        if (context.signal?.aborted) return
+
+        // When nested inside a correlated subquery, preserve the enclosing
+        // outer row so UNNEST args can reference its columns (e.g. o.arr).
+        const nestedOuter = context.outerRow
+          ? mergeOuterRows(context.outerRow, leftRow, leftTable)
+          : leftRow
+        const subContext = { ...context, outerRow: nestedOuter }
+        const right = executePlan({ plan: plan.right, context: subContext })
+
+        let hasMatch = false
+        for await (const rightRow of right.rows()) {
+          if (context.signal?.aborted) return
+          const merged = mergeRows(leftRow, rightRow, leftTable, rightTable)
+          const matches = plan.condition === undefined
+            ? true
+            : await evaluateExpr({ node: plan.condition, row: merged, context })
+          if (matches) {
+            hasMatch = true
+            yield merged
+          }
+        }
+
+        if (!hasMatch && plan.joinType === 'LEFT') {
+          const nullRight = createNullRow(rightCols)
+          yield mergeRows(leftRow, nullRight, leftTable, rightTable)
+        }
+      }
+    },
+  }
+}
+
 /**
  * Executes a positional join operation
  *
@@ -221,6 +275,28 @@ export function executeHashJoin(plan, context) {
   }
 }
 
+/**
+ * Merges an enclosing correlated outer row with a lateral join's left row.
+ * Outer cells are kept as-is; left cells are added under a qualified alias
+ * so qualified refs on either side resolve unambiguously.
+ *
+ * @param {AsyncRow} outerRow
+ * @param {AsyncRow} leftRow
+ * @param {string} leftTable
+ * @returns {AsyncRow}
+ */
+function mergeOuterRows(outerRow, leftRow, leftTable) {
+  const columns = [...outerRow.columns]
+  /** @type {AsyncCells} */
+  const cells = { ...outerRow.cells }
+  for (const [key, cell] of Object.entries(leftRow.cells)) {
+    const alias = key.includes('.') ? key : `${leftTable}.${key}`
+    if (!(alias in cells)) columns.push(alias)
+    cells[alias] = cell
+  }
+  return { columns, cells }
+}
+
 /**
  * Creates a NULL-filled row with the given column names
  *

package/src/execute/sort.js

@@ -1,3 +1,4 @@
+import { derivedAlias } from '../expression/alias.js'
 import { evaluateExpr } from '../expression/evaluate.js'
 import { executePlan } from './execute.js'
 import { compareForTerm } from './utils.js'
@@ -7,6 +8,8 @@ import { compareForTerm } from './utils.js'
  * @import { SortNode } from '../plan/types.js'
  */
 
+const MAX_CHUNK = 256
+
 /**
  * Executes a sort operation (ORDER BY)
  *
@@ -49,15 +52,34 @@ export function executeSort(plan, context) {
             continue
           }
 
-          // Evaluate this column for all rows in the group
+          // Evaluate this column for all rows in the group, in parallel
+          // chunks that double up to MAX_CHUNK so a slow UDF doesn't serialize.
+          // Cache each value back into the row so downstream projection can
+          // reuse it instead of re-invoking the expression.
+          const alias = derivedAlias(term.expr)
+          /** @type {number[]} */
+          const missing = []
           for (const idx of group) {
-            if (evaluatedValues[idx][orderByIdx] === undefined) {
-              evaluatedValues[idx][orderByIdx] = await evaluateExpr({
-                node: term.expr,
-                row: rows[idx],
-                context,
-              })
+            if (evaluatedValues[idx][orderByIdx] === undefined) missing.push(idx)
+          }
+          let chunkSize = 1
+          let start = 0
+          while (start < missing.length) {
+            if (context.signal?.aborted) return
+            const chunk = missing.slice(start, start + chunkSize)
+            const values = await Promise.all(chunk.map(idx =>
+              evaluateExpr({ node: term.expr, row: rows[idx], context })
+            ))
+            for (let i = 0; i < chunk.length; i++) {
+              const idx = chunk[i]
+              const value = values[i]
+              evaluatedValues[idx][orderByIdx] = value
+              if (!(alias in rows[idx].cells)) {
+                rows[idx].cells[alias] = () => Promise.resolve(value)
+              }
             }
+            start += chunk.length
+            chunkSize = Math.min(chunkSize * 2, MAX_CHUNK)
           }
 
           // Sort the group by this column

package/src/expression/evaluate.js

@@ -119,6 +119,18 @@ export async function evaluateExpr({ node, row, rowIndex, rows, context }) {
   if (node.type === 'function') {
     const funcName = node.funcName.toUpperCase()
 
+    // Reuse a previously cached evaluation of this expression, written back
+    // as a synthetic cell (e.g. by executeSort). Cached cells are not added to
+    // row.columns, so checking that the alias is NOT a real column guards
+    // against false positives where a table column happens to share a name
+    // with the expression's derived alias.
+    if (!rows) {
+      const alias = derivedAlias(node)
+      if (alias in row.cells && !row.columns.includes(alias)) {
+        return row.cells[alias]()
+      }
+    }
+
     // Handle aggregate functions
     if (isAggregateFunc(funcName)) {
       if (!rows) {

package/src/parse/joins.js

@@ -1,6 +1,7 @@
 import { expectNoAggregate } from '../validation/aggregates.js'
+import { ParseError } from '../validation/parseErrors.js'
 import { parseExpression } from './expression.js'
-import { parseTableAlias } from './parse.js'
+import { isTableFunctionStart, parseFromFunction, parseTableAlias } from './parse.js'
 import { current, expect, match } from './state.js'
 
 /**
@@ -18,6 +19,27 @@ export function parseJoins(state) {
   while (true) {
     const tok = current(state)
 
+    // Comma-join: implicit CROSS JOIN LATERAL, currently only for table functions.
+    if (match(state, 'comma')) {
+      if (!isTableFunctionStart(state)) {
+        throw new ParseError({
+          message: 'Comma-separated FROM is only supported with table functions like UNNEST; use explicit JOIN ... ON ... for regular tables',
+          positionStart: tok.positionStart,
+          positionEnd: state.lastPos,
+        })
+      }
+      const fromFunction = parseFromFunction(state)
+      joins.push({
+        joinType: 'CROSS',
+        table: fromFunction.funcName,
+        alias: fromFunction.alias,
+        fromFunction,
+        positionStart: tok.positionStart,
+        positionEnd: state.lastPos,
+      })
+      continue
+    }
+
     // Check for join keywords
     /** @type {JoinType} */
     let joinType = 'INNER'
@@ -35,6 +57,8 @@ export function parseJoins(state) {
       joinType = 'FULL'
     } else if (match(state, 'keyword', 'POSITIONAL')) {
       joinType = 'POSITIONAL'
+    } else if (match(state, 'keyword', 'CROSS')) {
+      joinType = 'CROSS'
     } else if (!match(state, 'keyword', 'JOIN')) {
       // Not a join keyword, stop parsing joins
       break
@@ -45,6 +69,64 @@ export function parseJoins(state) {
       expect(state, 'keyword', 'JOIN')
     }
 
+    // Optional LATERAL keyword; table functions are implicitly LATERAL.
+    const lateralTok = current(state)
+    const hasLateral = match(state, 'keyword', 'LATERAL')
+
+    // Table function on the right side (e.g. JOIN UNNEST(t.arr) AS u(x))
+    if (isTableFunctionStart(state)) {
+      if (joinType === 'POSITIONAL') {
+        throw new ParseError({
+          message: 'POSITIONAL JOIN does not support table functions',
+          positionStart: tok.positionStart,
+          positionEnd: state.lastPos,
+        })
+      }
+      if (joinType === 'RIGHT' || joinType === 'FULL') {
+        throw new ParseError({
+          message: `${joinType} JOIN not supported with table functions — right side depends on left row`,
+          positionStart: tok.positionStart,
+          positionEnd: state.lastPos,
+        })
+      }
+      const fromFunction = parseFromFunction(state)
+
+      /** @type {ExprNode | undefined} */
+      let condition
+      if (joinType !== 'CROSS') {
+        expect(state, 'keyword', 'ON')
+        condition = parseExpression(state)
+        expectNoAggregate(condition, 'JOIN ON')
+      }
+
+      joins.push({
+        joinType,
+        table: fromFunction.funcName,
+        alias: fromFunction.alias,
+        on: condition,
+        fromFunction,
+        positionStart: tok.positionStart,
+        positionEnd: state.lastPos,
+      })
+      continue
+    }
+
+    if (hasLateral) {
+      throw new ParseError({
+        message: 'LATERAL is only supported with table functions',
+        positionStart: lateralTok.positionStart,
+        positionEnd: lateralTok.positionEnd,
+      })
+    }
+
+    if (joinType === 'CROSS') {
+      throw new ParseError({
+        message: 'CROSS JOIN is currently supported only with table functions like UNNEST',
+        positionStart: tok.positionStart,
+        positionEnd: state.lastPos,
+      })
+    }
+
     // Parse table name and optional alias
     const tableTok = expect(state, 'identifier')
     const tableAlias = parseTableAlias(state)