sphinxql

SPHINXQL

SPHINXQL Consulta Builder para Node.js escreveu no TypeScript. Torne as perguntas fáceis, evitando escrever strings brutas para SPHINXQL sempre que você pode. Por padrão, ele usa parâmetros de consulta escape, sempre pensando em segurança.

É fortemente inspirado no PHP SPHINXQL-QUERY-Builder e também no eloqüente Construtor Builder (Laravel Framework ORM)

O cliente usado para criar conexão é o MySQL2 focado no desempenho.

requisitos

Você deve usar node.js> = 6.x

instalar

Basta executar o comando npm:

npm install --save sphinxql

uso

Para criar uma conexão simples (não a mais recomendada, use uma conexão de pool) e escreva sua primeira consulta, basta fazer isso:

 const { Sphinxql , Expression } = require ( 'sphinxql' ) ;

const sphql = Sphinxql . createConnection ( {
  host : 'localhost' ,
  port : 9306
} ) ;

sphql . getQueryBuilder ( )
  . select ( '*' )
  . from ( 'books' )
  . match ( 'title' , 'harry potter' )
  . where ( 'created_at' , '<' ,  Expression . raw ( 'YEAR()' ) )
  . between ( Expression . raw ( `YEAR(created_at)` ) , 2014 , 2019 )
  . orderBy ( { 'date_published' : 'ASC' , 'price' : 'DESC' } )
  . limit ( 10 )
  . execute ( )
  . then ( ( result , fields ) => {
    console . log ( result ) ;
  } )
  . catch ( err => {
    console . log ( err ) ;
  } ) ;

Estabelecer conexão

Existem duas maneiras possíveis de criar uma conexão entre o seu aplicativo e o servidor Manticore/Sphinx. Primeiro e mais simples é usar o método createConnection .

 const { Sphinxql } = require ( 'sphinxql' ) ;

const sphql = Sphinxql . createConnection ( {
  host : 'localhost' ,
  port : 9306
} ) ;

A segunda opção é usar o método createPoolConnection . Essa metodologia permite que você tenha várias conexões abertas com Manticore/Sphinx reutilizando conexões anteriores. Para saber mais sobre os pools de conexão MySQL2 (parâmetros permitidos para a criação e configuração do pool), leia a documentação do MySQL2 sobre o uso de pools de conexão. Esta técnica usa mais memória, então esteja ciente.

 const { Sphinxql } = require ( 'sphinxql' ) ;
// Create the connection pool. The pool-specific settings are the defaults
const sphql = Sphinxql . createPoolConnection ( {
  host : 'localhost' ,
  port : 9306 ,
  waitForConnections : true ,
  connectionLimit : 10 ,
  queueLimit : 0
} ) ;

Selecione

Esta seção é separada em muitas partes, mas se você já usou SPHINXQL antes ou SQL, poderá ver esta seção também muito básica para você. De qualquer forma, eu recomendo fortemente ler a Manticore Search ou Sphinx Documentation para fazer uma boa idéia de como usar essa API.

Onde e métodos de correspondência

• Onde (ColumnExpr: String, Operador: String, Value?: Algum)
• em que (coluna: string, valores: qualquer [])
• Whrerenotin (coluna: string, valores: qualquer [])
• entre (coluna: string, value1: qualquer, valor2: qualquer)
• Match (Campos: String [] | String, Valor: String, EscapeValue: Boolean = true)
• ormatch (campos: string [] | string, valor: string, escapeValue: boolean = true)

Exemplo aqui:

 sphql . getQueryBuilder ( )
  . select ( 'id' , 'author_id' , 'publication_date' )
  . from ( 'books' )
  . match ( '*' , '"harry potter"' , false )
  . whereIn ( 'lang' , [ 'en' , 'sp' , 'fr' ] )
  . between ( Expression . raw ( `YEAR(publication_date)` ) , 2008 , 2015 )
  . execute ( )
  . then ( ( result , fields ) => {
    console . log ( result ) ;
  } )
  . catch ( err => {
    console . log ( err ) ;
  } ) ; 

OPÇÃO

Você pode encadear várias opções usando o método "Opção". O chefe do método é:

• opção (opção: string, valor: qualquer) onde o argumento do valor pode ser uma instância de:
• Instância de expressão para parâmetros unespados
• Objeto de valor-chave (exemplo abaixo)
• String para valor de opção simples e escapado.

Exemplo com a opção:

 sphql . getQueryBuilder ( )
  . select ( 'id' , 'author_id' , 'publication_date' )
  . from ( 'books' )
  . match ( '*' , '"harry potter"' , false )
  . between ( Expression . raw ( `YEAR(publication_date)` ) , 2008 , 2015 )
  . orderBy ( { 'publication_date' : 'ASC' , 'price' : 'DESC' } )
  . limit ( 10 )
  . option ( 'rank_fields' , 'title content' )
  . option ( 'field_weights' , { title : 100 , content : 1 } )
  . execute ( )
  . then ( ( result , fields ) => {
    console . log ( result ) ;
  } )
  . catch ( err => {
    console . log ( err ) ;
  } ) ; 

Pesquisa facetada

// PENDÊNCIA

INSERIR

Uma declaração de inserção é criada assim:

 const document = {
  id : 1 ,
  content : 'this is the first post for the blog...' ,
  title : 'First post'
} ;

connection . getQueryBuilder ( )
  . insert ( 'my_rtindex' , document )
  . execute ( )
  . then ( ( result , fields ) => {
    console . log ( result ) ;
  } )
  . catch ( err => {
    console . log ( err ) ;
  } ) ;

Ou usando uma matriz de pares de valor-chave para inserir vários valores na mesma consulta

 const document = [ {
  id : 1 ,
  content : 'this is the first post for the blog...' ,
  title : 'First post'
} , {
  id : 2 ,
    content : 'this is the second post for the blog...' ,
    title : 'Second post'
} ] ;

connection . getQueryBuilder ( )
  . insert ( 'my_rtindex' , document )
  . execute ( )
  . then ( ( result ) => {
    console . log ( result ) ;
  } )
  . catch ( err => {
    console . log ( err ) ;
  } ) ;

SUBSTITUIR

Substitui um documento usando o Doc ID ou Insert. Semelhante à inserção de instrução Somente alterando a inserção para substituir.

 const document = {
  id : 1 ,
  content : 'this is the first post for the blog...' ,
  title : 'UPDATE! First post'
} ;

connection . getQueryBuilder ( )
  . replace ( 'my_rtindex' , document )
  . execute ( )
  . then ( ( result ) => {
    console . log ( result ) ;
  } )
  . catch ( err => {
    console . log ( err ) ;
  } ) ;

ATUALIZAR

 const document = {
  content : 'UPDATE! it's an old post. this is the first post for the blog...' ,
  title : 'First post (edit)'
} ;

connection . getQueryBuilder ( )
  . update ( 'my_rtindex' )
  . set ( document )
  . match ( 'fullname' , 'John' )
  . where ( 'salary' , '<' , 3000 )
  . execute ( )
  . then ( ( result , fields ) => {
    console . log ( result ) ;
  } )
  . catch ( err => {
    console . log ( err ) ;
  } ) ;

Transações

Este pacote também vem com suporte para transações. Lembre -se de que as transações estão disponíveis apenas para índices de RT. Para obter mais informações, visite a documentação de transações para a Manticore Search.

A API de transações é simples e a lista de métodos está abaixo:

• Connection.getQueryBuilder (). Transaction.Begin ()
• Connection.getQueryBuilder (). transaction.start () // mesmo que comece ()
• Connection.getQueryBuilder (). Transaction.Commit ()
• Connection.getQueryBuilder (). transaction.rollback ()

Todos esses métodos retornam um objeto de promessa.

Um exemplo simples trabalhando com transações:

 const document = {
  id : 1 ,
  content : 'this is the first post for the blog...' ,
  title : 'First post'
} ;

const insertDocumentAndCommit = async ( doc ) => {
  await connection . getQueryBuilder ( ) . transaction . begin ( ) ;
  
  connection . getQueryBuilder ( )
    . insert ( 'my_rtindex' , doc )
    . execute ( )
    . then ( ( result , fields ) => {
      console . log ( result ) ;
    } )
    . catch ( err => {
      console . log ( err ) ;
    } ) ;

    await connection . getQueryBuilder ( ) . transaction . commit ( ) ;

    return true ;
}

insertDocumentAndCommit ( document ) ;

Consultas em lote (múltiplas perguntas)

Antes de tudo, você precisa conhecer as limitações de múltiplas consultas em Manticore/Sphinx. Como a Manticore Search e a documentação da Sphinx disseram que há apenas suporte para as seguintes declarações usadas em um lote:

• Selecione
• Mostrar avisos
• Mostrar status
• Mostrar meta

Disse isso, agora é o momento de escrever código. Há uma classe, fila , que implementa apenas os métodos necessários, é útil executar consultas múltiplas. Para ativar as declarações multi que você deve especificar em seu objeto de configuração para a criação de conexão os multiplestamentos: true como seguinte:

 const { Sphinxql } = require ( 'sphinxql' ) ;

const sphql = Sphinxql . createConnection ( {
  host : 'localhost' ,
  port : 9306 ,
  multipleStatements : true
} ) ;

Agora vamos criar uma fila e processá -la:

 const { Queue , Sphinxql } = require ( 'sphinxql' ) ;

const sphql = Sphinxql . createConnection ( {
  host : 'localhost' ,
  port : 9306 ,
  multipleStatements : true
} ) ;

const queue = new Queue ( sphql . getConnection ( ) ) ;
queue
  . push ( sphql . getQueryBuilder ( ) . select ( '*' ) . from ( 'rt' ) . where ( 'id' , '=' , 1 ) )
  . push (
    sphql . getQueryBuilder ( )
      . select ( 'id' , 'author_id' , 'publication_date' )
      . from ( 'books' )
      . match ( '*' , '"harry potter"' , false )
  ) ;

queue . process ( )
  . then ( results => {
    console . log ( results . results . length ) // 2
  } )
  . catch ( err => console . log ( err ) ) ;

Mais métodos SPHINXQL

• OptimizeIndex (índice: string): Promise
• AnexeNIndex (DiskIndex: String): AnexeNIndExStatement
• truncado (rtindex: string): truncatestatement
• ReloadIndex (Índice: String): ReloadIndexstatement

Anexe o índice (AnexIndindexstatement)

Leia sobre o índice de anexo no documentação de Manticore para usar esta declaração, veja o exemplo abaixo:

 connection . getQueryBuilder ( )
  . attachIndex ( 'my_disk_index' )
  . to ( 'my_rt_index' )
  . withTruncate ( ) // this method is optional
  . execute ( )
  . then ( ( result , fields ) => {
    console . log ( result ) ;
  } )
  . catch ( err => {
    console . log ( err ) ;
  } ) ; 

Flush RTIndex (FlushrTindexstatement)

Leia sobre o Flush RTIndex para usar esta declaração, veja o exemplo abaixo):

 connection . getQueryBuilder ( )
  . flushRTIndex ( 'my_rt_index' )
  . execute ( )
  . then ( ( result , fields ) => {
    console . log ( result ) ;
  } )
  . catch ( err => {
    console . log ( err ) ;
  } ) ; 

Truncado rtindex (truncatestatement)

Leia sobre o truncado rtindex no documentação de Manticore para usar esta declaração, veja o exemplo abaixo:

 connection . getQueryBuilder ( )
  . truncate ( 'my_rt_index' )
  . withReconfigure ( )  // this method is optional
  . execute ( )
  . then ( ( result , fields ) => {
    console . log ( result ) ;
  } )
  . catch ( err => {
    console . log ( err ) ;
  } ) ; 

Recarregar o índice

Leia sobre o índice de recarga no documentação de Manticore para usar esta declaração, veja o exemplo abaixo:

 connection . getQueryBuilder ( )
  . reloadIndex ( 'my_index' )
  . from ( '/home/mighty/new_index_files' ) // this method is optional
  . then ( ( result , fields ) => {
    console . log ( result ) ;
  } )
  . catch ( err => {
    console . log ( err ) ;
  } ) ;

Execute consultas brutas

Execute consultas brutas usando o método de consulta que está disponível após o método GetQueryBuilder. Este método permite a instrução preparada usando um? (ponto de interrogação) onde você deseja escapar do valor.

 connection . getQueryBuilder ( )
  . query ( `SELECT * FROM sales WHERE MATCH(@title "italian lamp") AND tags IN (?, ?)` , [ 'home' , 'italian style' ] )
  . then ( ( result , fields ) => {
    console . log ( result ) ;
  } )
  . catch ( err => {
    console . log ( err ) ;
  } ) ; 

Consultas de depuração

Todas as declarações possuem um método final usado internamente para executar consultas. Este método está disponível fora usando o generate () e retorna uma string com a consulta final.

 const sphinxqlQuery = connection . getQueryBuilder ( )
  . select ( 'user_id' , 'product_id' , Expression . raw ( 'SUM(product_price) as total' ) . getExpression ( ) )
  . from ( 'rt_sales' )
  . facet ( ( f ) => {
    return f
      . fields ( [ 'category_id' ] )
      . by ( [ 'category_id' ] )
  } )
  . facet ( ( f ) => {
    return f
      . field ( 'brand_id' )
      . orderBy ( Expression . raw ( 'facet()' ) )
      . limit ( 5 )
  } )
  . generate ( ) ;

console . log ( sphinxqlQuery ) ; // SELECT user_id, product_id, SUM(product_price) as total FROM rt_sales FACET category_id BY category_id FACET brand_id ORDER BY facet() DESC LIMIT 5