{"record":{"id":"5e4687fe7fb926e6","repo":"litedb-org/LiteDB","slug":"0-5e4687","errorCode":"0","errorMessage":"Expression `{this.Source}` is not a scalar expression and can return more than one result","messagePattern":"Expression `(.+?)` is not a scalar expression and can return more than one result","errorType":"exception","errorClass":"LiteException","httpStatus":null,"severity":"error","filePath":"LiteDB/Document/Expression/BsonExpression.cs","lineNumber":274,"sourceCode":"        public BsonValue ExecuteScalar(IEnumerable<BsonDocument> source, Collation collation = null)\n        {\n            if (source == null) throw new ArgumentNullException(nameof(source));\n\n            return this.ExecuteScalar(source, null, null, collation);\n        }\n\n        /// <summary>\n        /// Execute expression and returns IEnumerable values - returns NULL if no elements\n        /// </summary>\n        internal BsonValue ExecuteScalar(IEnumerable<BsonDocument> source, BsonDocument root, BsonValue current, Collation collation)\n        {\n            if (this.IsScalar)\n            {\n                return _funcScalar(source, root, current, collation ?? Collation.Binary, this.Parameters);\n            }\n            else\n            {\n                throw new LiteException(0, $\"Expression `{this.Source}` is not a scalar expression and can return more than one result\");\n            }\n        }\n\n        #endregion\n\n        #region Static method\n\n        private static readonly ConcurrentDictionary<string, BsonExpressionEnumerableDelegate> _cacheEnumerable = new ConcurrentDictionary<string, BsonExpressionEnumerableDelegate>();\n        private static readonly ConcurrentDictionary<string, BsonExpressionScalarDelegate> _cacheScalar = new ConcurrentDictionary<string, BsonExpressionScalarDelegate>();\n\n        /// <summary>\n        /// Parse string and create new instance of BsonExpression - can be cached\n        /// </summary>\n        public static BsonExpression Create(string expression)\n        {\n            return Create(expression, new BsonDocument());\n        }\n","sourceCodeStart":256,"sourceCodeEnd":292,"githubUrl":"https://github.com/litedb-org/LiteDB/blob/f906a5f850678719e39a39a006cb66dcae563cfa/LiteDB/Document/Expression/BsonExpression.cs#L256-L292","documentation":"Thrown by BsonExpression.ExecuteScalar when the expression's IsScalar flag is false, meaning the expression can yield zero or more values per document (an enumerable/path expression). ExecuteScalar demands a single-value (scalar) expression. This is a LiteException with code 0.","triggerScenarios":"Calling ExecuteScalar on an expression containing array paths (e.g., `$.items[*]`), MAP, FILTER, or any operator that produces multiple results. Using a multi-result expression where a single value is required (e.g., in a BETWEEN bound, an index key, or a scalar aggregation slot).","commonSituations":"Building dynamic expressions where the user-supplied query contains a wildcard or multi-value path, then calling ExecuteScalar. Using an aggregate-style expression in a scalar context. Expression caching where a previously enumerable expression is reused in a scalar call site.","solutions":["Check `expr.IsScalar` before calling ExecuteScalar; if false, use the enumerable execution path (Execute) instead.","Rewrite the expression to produce a single value, e.g., wrap with an aggregate (MIN, MAX, COUNT) or select a specific index `$.items[0]`.","Validate user-supplied expression strings at parse time using BsonExpression.Create and inspect IsScalar."],"exampleFix":"// before\nvar result = expr.ExecuteScalar(docs);\n// after\nvar result = expr.IsScalar\n    ? expr.ExecuteScalar(docs)\n    : expr.Execute(docs).FirstOrDefault() ?? BsonValue.Null;","handlingStrategy":"validation","validationCode":"if (!expr.IsScalar) throw new InvalidOperationException($\"Expression '{expr.Source}' is not scalar; use Execute() instead.\");\nvar result = expr.ExecuteScalar(source);","typeGuard":"static bool IsScalarExpression(BsonExpression expr) => expr != null && expr.IsScalar;","tryCatchPattern":"try { return expr.ExecuteScalar(source); }\ncatch (LiteException ex) when (ex.Message.Contains(\"not a scalar expression\"))\n{ /* fall back to enumerable execution or report to caller */ }","preventionTips":["Inspect expr.IsScalar immediately after BsonExpression.Create.","Prefer Execute().FirstOrDefault() for expressions of unknown cardinality.","Document which expressions are scalar vs enumerable in your query builder."],"tags":["expression","scalar","query","lite-exception"],"backgroundTag":null,"analyzedSha":"f906a5f850678719e39a39a006cb66dcae563cfa","analyzedAt":"2026-08-13T21:56:30.148Z","schemaVersion":2},"datasetVersion":"2026-08-14T00:17:13.853Z"}