liqe
v3.8.0
Analisador, serializador e mecanismo de pesquisa leve e de alto desempenho semelhante ao Lucene.
Liqe originalmente construído para permitir a filtragem de log Roarr via cli. Desde então, venho aprimorando este projeto como um hobby/exercício intelectual. Já vi isso sendo adotado por vários aplicativos CLI e web que exigem pesquisa avançada. Até onde sei, é atualmente o analisador de sintaxe e serializador semelhante ao Lucene mais completo em JavaScript, bem como um mecanismo de pesquisa na memória compatível.
Os casos de uso do Liqe incluem:
Observe que o Liqe AST é tratado como uma API pública, ou seja, pode-se implementar seu próprio mecanismo de busca que utiliza a linguagem de consulta Liqe (LQL).
import {
filter ,
highlight ,
parse ,
test ,
} from 'liqe' ;
const persons = [
{
height : 180 ,
name : 'John Morton' ,
} ,
{
height : 175 ,
name : 'David Barker' ,
} ,
{
height : 170 ,
name : 'Thomas Castro' ,
} ,
] ;Filtrar uma coleção:
filter ( parse ( 'height:>170' ) , persons ) ;
// [
// {
// height: 180,
// name: 'John Morton',
// },
// {
// height: 175,
// name: 'David Barker',
// },
// ]Teste um único objeto:
test ( parse ( 'name:John' ) , persons [ 0 ] ) ;
// true
test ( parse ( 'name:David' ) , persons [ 0 ] ) ;
// falseDestaque campos e substrings correspondentes:
highlight ( parse ( 'name:john' ) , persons [ 0 ] ) ;
// [
// {
// path: 'name',
// query: /(John)/,
// }
// ]
highlight ( parse ( 'height:180' ) , persons [ 0 ] ) ;
// [
// {
// path: 'height',
// }
// ] Liqe usa Liqe Query Language (LQL), que é fortemente inspirado em Lucene, mas o estende de várias maneiras que permitem uma experiência de pesquisa mais poderosa.
# search for "foo" term anywhere in the document (case insensitive)
foo
# search for "foo" term anywhere in the document (case sensitive)
'foo'
"foo"
# search for "foo" term in `name` field
name :foo
# search for "foo" term in `full name` field
'full name' : foo
"full name" : foo
# search for "foo" term in `first` field, member of `name`, i.e.
# matches {name: {first: 'foo'}}
name . first :foo
# search using regex
name :/foo /
name :/ foo / o
# search using wildcard
name :foo * bar
name :foo? bar
# boolean search
member :true
member :false
# null search
member :null
# search for age =, >, >=, <, <=
height : = 100
height :>100
height :>=100
height :<100
height :<=100
# search for height in range (inclusive, exclusive)
height : [ 100 TO 200 ]
height : { 100 TO 200 }
# boolean operators
name :foo AND height : = 100
name :foo OR name : bar
# unary operators
NOT foo
- foo
NOT foo : bar
- foo :bar
name :foo AND NOT ( bio :bar OR bio : baz )
# implicit AND boolean operator
name :foo height : = 100
# grouping
name :foo AND ( bio :bar OR bio : baz )Pesquise a palavra "foo" em qualquer campo (sem distinção entre maiúsculas e minúsculas).
foo Pesquise a palavra "foo" no campo name .
name :foo Pesquise valores de campo name correspondentes /foo/i regex.
name :/foo / i Pesquise valores de campo name que correspondam ao padrão curinga f*o .
name :f * o Pesquise valores de campo name que correspondam f?o padrão curinga.
name :f? o Pesquise a frase "foo bar" no campo name (diferencia maiúsculas de minúsculas).
name :"foo bar" Procure o valor igual a 100 no campo height .
height : = 100 Procure valor maior que 100 no campo height .
height :>100 Procure valor maior ou igual a 100 no campo height .
height :>=100 Procure valor maior ou igual a 100 e menor ou igual a 200 no campo height .
height : [ 100 TO 200 ] Procure valor maior que 100 e menor que 200 no campo height .
height : { 100 TO 200 } Pesquise qualquer palavra que comece com “foo” no campo name .
name :foo * Pesquise qualquer palavra que comece com “foo” e termine com “bar” no campo name .
name :foo * bar Pesquise qualquer palavra que comece com “foo” no campo name , seguida por um único caractere arbitrário.
name :foo? Pesquise qualquer palavra que comece com “foo”, seguida por um único caractere arbitrário e termine imediatamente com “bar” no campo name .
name :foo? bar Pesquise a frase “foo bar” no campo name E a frase “quick fox” no campo bio .
name :"foo bar" AND bio : "quick fox" Pesquise a frase “foo bar” no campo name E a frase “quick fox” no campo bio , ou a palavra “fox” no campo name .
( name :"foo bar" AND bio : "quick fox" ) OR name : fox O serializador permite converter tokens Liqe de volta à consulta de pesquisa original.
import {
parse ,
serialize ,
} from 'liqe' ;
const tokens = parse ( 'foo:bar' ) ;
// {
// expression: {
// location: {
// start: 4,
// },
// quoted: false,
// type: 'LiteralExpression',
// value: 'bar',
// },
// field: {
// location: {
// start: 0,
// },
// name: 'foo',
// path: ['foo'],
// quoted: false,
// type: 'Field',
// },
// location: {
// start: 0,
// },
// operator: {
// location: {
// start: 3,
// },
// operator: ':',
// type: 'ComparisonOperator',
// },
// type: 'Tag',
// }
serialize ( tokens ) ;
// 'foo:bar' import {
type BooleanOperatorToken ,
type ComparisonOperatorToken ,
type EmptyExpression ,
type FieldToken ,
type ImplicitBooleanOperatorToken ,
type ImplicitFieldToken ,
type LiteralExpressionToken ,
type LogicalExpressionToken ,
type RangeExpressionToken ,
type RegexExpressionToken ,
type TagToken ,
type UnaryOperatorToken ,
} from 'liqe' ;Existem 11 tokens AST que descrevem uma consulta Liqe analisada.
Se você estiver construindo um serializador, deverá implementar todos eles para cobrir completamente todas as entradas de consulta possíveis. Consulte o serializador integrado para obter um exemplo.
import {
isSafeUnquotedExpression ,
} from 'liqe' ;
/**
* Determines if an expression requires quotes.
* Use this if you need to programmatically manipulate the AST
* before using a serializer to convert the query back to text.
*/
isSafeUnquotedExpression ( expression : string ) : boolean ; As seguintes habilidades Lucene não são suportadas:
No caso de um erro de sintaxe, Liqe lança SyntaxError .
import {
parse ,
SyntaxError ,
} from 'liqe' ;
try {
parse ( 'foo bar' ) ;
} catch ( error ) {
if ( error instanceof SyntaxError ) {
console . error ( {
// Syntax error at line 1 column 5
message : error . message ,
// 4
offset : error . offset ,
// 1
offset : error . line ,
// 5
offset : error . column ,
} ) ;
} else {
throw error ;
}
} Considere usar o pacote highlight-words para destacar correspondências do Liqe.
Se você for modificar o analisador, use npm run watch para executar o compilador no modo watch.
Antes de fazer qualquer alteração, capture o benchmark atual em sua máquina usando npm run benchmark . Execute o benchmark novamente após fazer qualquer alteração. Antes de confirmar as alterações, certifique-se de que o desempenho não seja afetado negativamente.
