流源参考

search

search 函数搜索 SolrCloud 集合并发出与查询匹配的元组流。这与标准 Solr 查询非常相似，并使用许多相同的参数。

此表达式允许您使用 qt 参数指定请求处理程序。默认情况下，使用 /select 处理程序。/select 处理程序可用于表达式的简单快速原型设计。但是，对于生产环境，您很可能希望使用 /export 处理程序，该处理程序旨在 sort 和 export 整个结果集。默认情况下不使用 /export 处理程序，因为它比 /select 处理程序有更严格的要求，因此不容易开始使用。要了解有关 /export 处理程序要求的更多信息，请查看导出结果集部分。

search 参数

collection：(必需) 要搜索的集合。
q：(必需) 在 Solr 索引上执行的查询。
fl：(必需) 要返回的字段列表。
sort：(必需) 排序标准。
zkHost：仅当要搜索的集合位于与本地流处理程序不同的 zkHost 中时才需要定义。仅当使用与您连接到的 Solr 实例相同的 ZkHost 时，才会包含 Zookeeper 凭据和 ACL（chroot 可以不同）。
qt：指定要使用的查询类型或请求处理程序。将其设置为 /export 以处理大型结果集。默认值为 /select。
rows：（使用 /select 处理程序时必需）rows 参数指定要返回的行数。此参数仅在使用 /select 处理程序（这是默认值）时才需要，因为 /export 处理程序始终返回所有行。
partitionKeys：用于对搜索结果进行分区的逗号分隔键列表。与 parallel 函数一起使用，以便在工作节点之间并行化操作。有关详细信息，请参阅 parallel 函数。

search 语法

expr=search(collection1,
       zkHost="localhost:9983",
       qt="/export",
       q="*:*",
       fl="id,a_s,a_i,a_f",
       sort="a_f asc, a_i asc")

drill

drill 函数旨在支持高效的高基数聚合。drill 函数向特定集合中的 export 处理程序发送请求，其中包括一个流式表达式，该表达式由 export 处理程序应用于排序后的结果集。然后，export 处理程序会发出聚合的元组。drill 函数读取并发出每个分片中的聚合元组，同时保持排序顺序，但不合并聚合。可以将流式表达式函数包装在 drill 函数周围以合并聚合。

drill 参数

collection：(必需) 要搜索的集合。
q：(必需) 在 Solr 索引上执行的查询。
fl：(必需) 要返回的字段列表。
sort：(必需) 排序标准。
expr: 发送到 export 处理程序的流式表达式，该表达式在排序后的结果集上运行。input() 函数提供来自 export 处理程序的排序后的元组流（请参阅下面的示例）。

drill 语法

示例 1：基本 drill 语法

drill(articles,
      q="abstract:water",
      fl="author",
      sort="author asc",
      rollup(input(), over="author", count(*)))

示例 2：一个包装在 drill 函数周围的 rollup，用于对每个分片发出的计数求和。

rollup(drill(articles,
             q="abstract:water",
             fl="author",
             sort="author asc",
             rollup(input(), over="author", count(*))),
       over="author",
       sum(count(*)))

echo

echo 函数返回一个元组，其中回显其文本参数。Echo 是最简单的流源，旨在向文本分析流装饰器提供文本。

echo 语法

echo("Hello world")

facet 函数提供在桶上汇总的聚合。在底层，facet 函数使用 Solr 的 JSON Facet API 将聚合下推到搜索引擎中。这为许多用例提供了亚秒级的性能。facet 函数适用于桶字段中具有少量到中等数量的不同值的情况。要支持高基数聚合，请参阅 rollup 函数。

collection: （必需）将从中聚合 facets 的集合。
q: （必需）用于构建聚合的查询。
buckets: （必需）以逗号分隔的要汇总的字段列表。逗号分隔的列表表示多维汇总中的维度。
bucketSorts: （必需）应用于桶参数中每个维度的以逗号分隔的排序列表。排序可以基于计算的指标或桶值。
rows: （默认值 10）要返回的行数。'-1' 将返回所有行。
offset:（默认值 0）从结果集中开始的偏移量。
overfetch: （默认值 150）过度提取用于在高基数字段上提供精确的聚合。
method: JSON facet API 聚合方法。
bucketSizeLimit: 设置要提取的绝对行数。这与 rows、offset 和 overfetch 不兼容。此值应用于每个维度。'-1' 将提取所有桶。
metrics: 要为桶计算的指标列表。当前支持的指标有 sum(col)、avg(col)、min(col)、max(col)、count(*)、countDist(col)、std(col)、per(col, 50)。per 指标计算数字列的百分位数，并且可以在同一个 facet 函数中多次指定。
tiered: （默认值 true）控制 facet 流是否应使用 plist 表达式将 JSON Facet 请求并行化到多个 Solr 集合的标志；此选项仅在 collection 是由多个集合支持的别名时适用。如果启用了 tiered，则内部使用 rollup 表达式将多个 facet 表达式的指标聚合到单个结果中；仅支持 count、min、max、sum 和 avg 指标。客户端应用程序可以通过设置 solr.facet.stream.tiered=false 系统属性来全局禁用此功能。

示例 1

facet(collection1,
      q="*:*",
      buckets="a_s",
      bucketSorts="sum(a_i) desc",
      rows=100,
      sum(a_i),
      sum(a_f),
      min(a_i),
      min(a_f),
      max(a_i),
      max(a_f),
      avg(a_i),
      avg(a_f),
      std(a_f),
      per(a_f, 50),
      per(a_f, 75),
      count(*))

上面的示例显示了一个 facet 函数，该函数在单个桶上进行汇总，其中桶按 sum(a_i) 指标的计算值降序返回。

示例 2

facet(collection1,
      q="*:*",
      buckets="year_i, month_i, day_i",
      bucketSorts="year_i desc, month_i desc, day_i desc",
      rows=10,
      offset=20,
      sum(a_i),
      sum(a_f),
      min(a_i),
      min(a_f),
      max(a_i),
      max(a_f),
      avg(a_i),
      avg(a_f),
      std(a_f),
      per(a_f, 50),
      per(a_f, 75),
      count(*))

上面的示例显示了一个 facet 函数，该函数在三个桶上进行汇总，其中桶按桶值降序返回。rows 参数返回 10 行，offset 参数从第 20 行开始返回行。

features

features 函数从存储在 SolrCloud 集合中的分类训练集中的文本字段中提取关键术语。它使用一种称为信息增益的算法，从训练集中选择重要术语。features 函数专门用于与 train 函数一起使用，该函数使用提取的特征来训练文本分类器。

features 函数旨在与提供类别的正面和负面示例的训练集一起使用。它为每个提取的特征术语发出一个元组，以及该术语在训练集中的逆文档频率（IDF）。

features 函数使用查询从集合中选择训练集。每个选定特征的 IDF 是相对于与查询匹配的训练集计算的。这允许将多个训练集存储在同一个 SolrCloud 集合中，而不会污染跨训练集的 IDF。

features 参数

collection: （必需）包含训练集的集合
q: （必需）定义训练集的查询。特征的 IDF 将针对与查询匹配的结果集生成。
featureSet: （必需）特征集的名称。如果特征存储在 SolrCloud 集合中，则可以使用此名称检索特征。
field: （必需）从中提取特征的文本字段。
outcome: （必需）定义类别（正面或负面）的字段
numTerms: （必需）要提取的特征术语的数量。
positiveLabel: （默认为 1）outcome 字段中定义肯定结果的值。

features 语法

features(collection1,
         q="*:*",
         featureSet="features1",
         field="body",
         outcome="out_i",
         numTerms=250)

cat

cat 函数读取指定的文件或目录，并将文件中的每一行作为元组发出。

每个发出的元组包含两个字段：file 和 line。file 包含要读取的文件的路径，该路径相对于 userfiles chroot（直接位于 $SOLR_HOME 下），line 包含该文件中的一行。

cat 非常适合与 update 流一起使用，以索引指定文档中的数据，或者与 analyze 流一起使用，以将行进一步拆分为单个标记以进行统计处理或可视化。

cat 参数

filePaths: （必需）要从中读取行的以逗号分隔的文件路径列表。如果指定路径是目录，它将以递归方式爬取，并读取所有包含的文件。为了防止恶意用户从 Solr 节点读取任意文件，filePaths 必须是相对于运行流式表达式的节点上的 $SOLR_HOME/userfiles chroot 的相对路径。此目录必须由用户创建。
maxLines: （默认为 -1）要读取（和发出元组）的最大行数。如果指定了负值，则指定文件中的所有行都将作为元组发出。文件按照它们在以逗号分隔的 filePaths 参数中出现的顺序读取。如果达到行限制，则这些后面的文件将部分发出或根本不读取。

cat 示例

以下示例发出位于 $SOLR_HOME/userfiles/authors.txt 的单个文本文件中的所有行

cat("authors.txt")

此示例将读取 $SOLR_HOME/userfiles/authors.txt 中的行，以及在 $SOLR_HOME/userfiles/fiction/scifi 下找到的所有文件（递归地）。只会发出 500 行，这意味着某些文件可能会部分发出或根本不读取

cat("authors.txt,fiction/scifi/", maxLines=500)

nodes

nodes 函数提供广度优先的图遍历。有关详细信息，请参阅图遍历部分。

knnSearch

knnSearch 函数基于文本相似性返回文档的 k 个最近邻居。在底层，knnSearch 函数使用 More Like This 查询解析器插件。

knnSearch 参数

collection: （必需）要在其中执行搜索的集合。
id: （必需）要从中开始 knn 搜索的源文档的 id。
qf: （必需）用于比较文档的查询字段。
k: （必需）要返回的最近邻居的数量。
fl: （必需）要返回的字段列表。
mindf: （可选，默认值为 5）要包含在搜索中的语料库中的最小出现次数。
maxdf: （可选）要包含在搜索中的语料库中的最大出现次数。
minwl: （可选）要包含在搜索中的最小单词长度。
maxwl: （可选）要包含在搜索中的最大单词长度。

knnSearch 语法

knnSearch(collection1,
          id="doc1",
          qf="text_field",
          k="10",
          fl="id, title",
          mintf="3",
          maxdf="10000000")

model

api 函数检索并缓存存储在 SolrCloud 集合中的逻辑回归文本分类模型。api 函数旨在与 train 函数创建的模型一起使用，但也可以用于检索在 Solr 外部训练的文本分类模型，只要它们符合指定的格式即可。检索模型后，可以由 classify 函数使用以对文档进行分类。

根据 id 参数提取并返回单个模型元组。通过将 id 参数与索引中的模型名称进行匹配来检索模型。如果索引中存储了命名模型的多个迭代，则选择最高的迭代。

使用模型进行缓存

api 函数具有内部 LRU（最近最少使用）缓存，因此不必每次调用 api 函数时都检索模型。每个模型 ID 的缓存时间可以作为参数传递给函数调用。检索缓存的模型不会重置缓存中模型 ID 的过期时间。

模型存储

下面是 Solr 中模型的存储格式。train 函数输出以下格式，因此如果您计划将 api 函数与在 Solr 外部训练的逻辑回归模型一起使用，则只需了解架构详细信息。

name_s（单值，字符串，已存储）：模型的名称。
iteration_i (单值, 整数, 已存储): 模型的迭代次数。Solr 可以存储训练函数生成的所有模型的迭代。
terms_ss (多值, 字符串, 已存储): 模型中的词/特征数组。
weights_ds (多值, 双精度浮点数, 已存储): 词权重数组。每个权重通过数组索引对应一个词。
idfs_ds (多值, 双精度浮点数, 已存储): 词的 IDF（逆文档频率）数组。每个 IDF 通过数组索引对应一个词。

模型参数

collection: (必需) 存储模型的集合。
id: (必需) 模型的 ID/名称。模型函数总是返回一个模型。如果存在同一名称的多个迭代版本，则返回迭代次数最高的版本。
cacheMillis: (可选) 将模型缓存在 LRU 缓存中的时间（毫秒）。

模型语法

model(modelCollection,
      id="myModel"
      cacheMillis="200000")

random

random 函数搜索 SolrCloud 集合，并发出与查询匹配的伪随机结果集。每次调用 random 将返回不同的伪随机结果集。

random 参数

collection: (必需) 用于聚合统计信息的集合。
q: （必需）用于构建聚合的查询。
rows: (必需) 要返回的伪随机结果的数量。
fl: (必需) 要返回的字段列表。
fq: (可选) 过滤查询。

random 语法

random(baskets,
       q="productID:productX",
       rows="100",
       fl="basketID")

在上面的示例中，random 函数在 baskets 集合中搜索 "productID:productX" 的所有行。它将返回 100 个伪随机结果。返回的字段列表是 basketID。

significantTerms

significantTerms 函数查询 SolrCloud 集合，但它不是返回文档，而是返回结果集中文档中找到的显著词。significantTerms 函数根据词在结果集中出现的频率以及在整个语料库中出现的频率来对词进行评分。significantTerms 函数为每个词发出一个元组，其中包含词、分数、前景计数和背景计数。前景计数是该词在结果集中出现的文档数。背景计数是该词在整个语料库中出现的文档数。前景和背景计数是针对整个集合的全局计数。

significantTerms 参数

collection: (必需) 运行该函数的集合。
q: (必需) 描述前景文档集的查询。
field: (必需) 要从中提取词的字段。
limit: (可选，默认为 20) 要返回的最大词数。
minDocFreq: (可选，默认为 5 个文档) 词在分片上必须出现的最小文档数。这是一个浮点值。如果大于 1.0，则视为绝对文档数。如果小于 1.0，则视为文档的百分比。
maxDocFreq: (可选，默认为文档的 30%) 词在分片上可以出现的最大文档数。这是一个浮点值。如果大于 1.0，则视为绝对文档数。如果小于 1.0，则视为文档的百分比。
minTermLength: (可选，默认为 4) 要被视为显著词的最小词长度。

significantTerms 语法

significantTerms(collection1,
                 q="body:Solr",
                 field="author",
                 limit="50",
                 minDocFreq="10",
                 maxDocFreq=".20",
                 minTermLength="5")

在上面的示例中，significantTerms 函数查询 collection1，并从 authors 字段返回最多 50 个显著词，这些词出现在 10 个或更多文档中，但不能超过语料库的 20%。

shortestPath

shortestPath 函数是用于实现最短路径图遍历的。shortestPath 函数通过无权图执行迭代广度优先搜索，以查找图中两个节点之间的最短路径。shortestPath 函数为找到的每个路径发出一个元组。发出的每个元组都将包含一个 path 键，该键指向包含路径的 nodeID List。

shortestPath 参数

collection: (必需) 将在其上运行主题查询的集合。
from: (必需) 开始搜索的 nodeID。
to: (必需) 结束搜索的 nodeID。
edge: (必需) 语法: from_field=to_field。from_field 定义要从中搜索的字段。to_field 定义要搜索到的字段。有关详细说明，请参见下面的示例。
threads: (可选: 默认为 6) 用于在遍历中执行分区连接的线程数。
partitionSize: (可选: 默认为 250) 连接的每个分区中的节点数。
fq: (可选) 过滤查询。
maxDepth: (必需) 将搜索限制为图中的最大深度。

shortestPath 语法

shortestPath(collection,
             from="[email protected]",
             to="[email protected]",
             edge="from_address=to_address",
             threads="6",
             partitionSize="300",
             fq="limiting query",
             maxDepth="4")

上面的表达式执行广度优先搜索，以在无权有向图中查找最短路径。

搜索从 from_address 字段中的 nodeID "[email protected]" 开始，并在 to_address 字段中搜索 nodeID "[email protected]"。此搜索将迭代执行，直到达到 maxDepth。遍历中的每个级别都实现为跨整个集合的并行分区嵌套循环连接。threads 参数控制在每个级别执行连接的线程数，而 partitionSize 参数控制每个连接分区中的节点数。maxDepth 参数控制要遍历的级别数。fq 是应用于遍历中每个级别的限制查询。

shuffle

shuffle 表达式对整个结果集进行排序和导出。shuffle 表达式类似于 search 表达式，不同之处在于 shuffle 在底层始终使用 /export 处理程序。shuffle 表达式旨在与需要完整排序结果集的关系代数装饰器结合使用。使用并行流装饰器可以将洗牌后的结果集在工作节点之间进行分区，以执行并行关系代数。在并行模式下使用时，必须提供 partitionKeys 参数。

shuffle 参数

collection：(必需) 要搜索的集合。
q：(必需) 在 Solr 索引上执行的查询。
fl：(必需) 要返回的字段列表。
sort：(必需) 排序标准。
zkHost：仅当要搜索的集合位于与本地流处理程序不同的 zkHost 中时才需要定义。仅当使用与您连接到的 Solr 实例相同的 ZkHost 时，才会包含 Zookeeper 凭据和 ACL（chroot 可以不同）。
partitionKeys：用于对搜索结果进行分区的逗号分隔键列表。与 parallel 函数一起使用，以便在工作节点之间并行化操作。有关详细信息，请参阅 parallel 函数。

shuffle 语法

shuffle(collection1,
        q="*:*",
        fl="id,a_s,a_i,a_f",
        sort="a_f asc, a_i asc")

stats

stats 函数收集搜索结果集的简单聚合。stats 函数不支持跨存储桶进行汇总，因此 stats 流始终返回带有汇总统计信息的单个元组。在底层，stats 函数使用 StatsComponent 将统计信息的生成推送到搜索引擎中。stats 函数当前支持以下度量标准: count(*)、sum()、avg()、min() 和 max()。

stats 参数

collection: (必需) 将从中聚合统计信息的集合。
q: （必需）用于构建聚合的查询。
metrics: (必需) 要包含在结果元组中的度量标准。当前支持的度量标准为 sum(col)、avg(col)、min(col)、max(col)、count(*)、countDist(col)、std(col)、per(col, 50)。per 度量标准计算数字列的百分位数，并且可以在同一 stats 函数中多次指定。

stats 语法

stats(collection1,
      q=*:*,
      sum(a_i),
      sum(a_f),
      min(a_i),
      min(a_f),
      max(a_i),
      max(a_f),
      avg(a_i),
      avg(a_f),
      std(a_f),
      per(a_f, 50),
      per(a_f, 75),
      count(*))

timeseries

timeseries 函数构建时间序列聚合。在底层，timeseries 函数使用 JSON Facet API 作为其高性能聚合引擎。

timeseries 参数

collection: (必需) 将从中聚合统计信息的集合。
q: （必需）用于构建聚合的查询。
field: (必需) 时间序列的日期字段。
split: (可选) 字符串字段。将为该字段中的每个值生成单独的时间线。
limit: (可选) 每个时间存储桶中分割字段中值的数量限制。分割值按第一个度量标准降序排列。
start: (必需) 以 Solr 日期或日期数学语法表示的时间序列的开始时间。
end: (必需) 以 Solr 日期或日期数学语法表示的时间序列的结束时间。
gap: (必需) 以 Solr 日期数学语法表示的时间序列聚合点之间的时间间隔。
format: (可选) 用于在输出元组中格式化日期字段的日期模板。格式化由 Java 的 SimpleDateFormat 类执行。
metrics: (必需) 要包含在结果元组中的度量标准。当前支持的度量标准为 sum(col)、avg(col)、min(col)、max(col)、count(*)、countDist(col)、std(col)、per(col, 50)。per 度量标准计算数字列的百分位数，并且可以在同一 timeseries 函数中多次指定。

timeseries 语法

timeseries(collection1,
           q=*:*,
           field="rec_dt",
           split="customer_s",
           limit="5",
           start="NOW-30DAYS",
           end="NOW",
           gap="+1DAY",
           format="YYYY-MM-dd",
           sum(a_i),
           max(a_i),
           max(a_f),
           avg(a_i),
           avg(a_f),
           std(a_f),
           per(a_f, 50),
           per(a_f, 75),
           count(*))

train

train 函数在存储在 SolrCloud 集合中的训练集上训练 Logistic 回归文本分类器。它使用并行迭代的批量梯度下降方法来训练模型。训练算法嵌入在 Solr 中，因此每次迭代仅通过网络传输模型。

train 函数包装一个 features 函数，该函数提供用于训练模型的词和逆文档频率 (IDF)。train 函数对与 features 函数相同的训练集进行操作，其中包括该类的正负示例。

每次迭代时，train 函数都会发出带有模型的元组。该模型包含特征词、权重和模型的混淆矩阵。然后，可以使用优化的模型根据文档的特征词对文档进行分类。

train 参数

collection: (必需) 包含训练集的集合
q: (必需) 定义训练集的查询。特征的 IDF 将在
name: (必需) 模型名称。如果模型存储在 SolrCloud 集合中，则可以使用此名称来检索模型。
field: （必需）从中提取特征的文本字段。
outcome: （必需）定义类别（正面或负面）的字段
maxIterations: (必需) 要执行的训练迭代次数。
positiveLabel: (默认为 1) 结果字段中定义正面结果的值。

train 语法

train(collection1,
      features(collection1, q="*:*", featureSet="first", field="body", outcome="out_i", numTerms=250),
      q="*:*",
      name="model1",
      field="body",
      outcome="out_i",
      maxIterations=100)

topic

topic 函数提供基于 SolrCloud 构建的发布/订阅消息传递功能。topic 函数允许用户订阅查询。然后，该函数提供与主题查询匹配的新文档或更新文档的一次性交付。对 topic 函数的初始调用会为特定主题 ID 建立检查点。对同一主题 ID 的后续调用将返回在初始检查点之后添加或更新的文档。每次运行主题查询都会更新主题 ID 的检查点。将 initialCheckpoint 参数设置为 0 将导致主题处理索引中与主题查询匹配的所有文档。

在 SOLR-8709 提交并发布之前，应将 topic 函数视为 beta 版。

topic 参数

checkpointCollection: (必需) 存储主题检查点的集合。
collection: (必需) 将在其上运行主题查询的集合。
id: (必需) 主题的唯一 ID。检查点将在此 ID 下保存。
q: (必需) 主题查询。
fl: (必需) topic 函数返回的字段列表。
initialCheckpoint: (可选) 设置从队列开始读取的初始 Solr _version_ 数字。如果未设置，则默认为索引中的最高版本。设置为 0 将处理索引中与查询匹配的所有记录。
zkHost: (可选) 仅当要搜索的集合与本地流处理程序位于不同的 zkHost 中时才需要定义。仅当使用的 ZkHost 与您连接的 Solr 实例相同时（chroot 可以不同），才会包含 Zookeeper 凭据和 ACL。

topic 语法

topic(checkpointCollection,
      collection,
      id="uniqueId",
      q="topic query",
      fl="id, name, country")

tuple

tuple 函数发出一个包含名称/值对的单个元组。这些值可以设置为 let 表达式中分配的变量、字面量、流求值器或流表达式。在流求值器的情况下，元组将输出求值器的返回值。这可以是数值、列表或映射。如果将值设置为流表达式，则 tuple 函数会将来自流表达式的元组流展平为元组列表。

tuple 参数

名称=值对

tuple 语法

tuple(a=add(1,1),
      b=search(collection1, q="cat:a", fl="a, b, c", sort="a desc"))