sphinxql

sphinxql

Sphinxql Consultor Builder para Node.js escribió en TypeScript. Hacer consultas fáciles evitando escribir cadenas SphinXQL en bruto siempre que pueda. Por defecto, utiliza parámetros de consulta escapados, siempre pensando en seguridad.

Está fuertemente inspirado en el php sphinxql-query-builder y también en el creador de consultas elocuente (Laravel Framework Orm)

El cliente utilizado para Crear conexión es MySQL2 que se centra en el rendimiento.

requisitos

Debe usar node.js> = 6.x

instalar

Simplemente ejecute el comando npm:

npm install --save sphinxql

uso

Para crear una conexión simple (no la más recomendada, use una conexión de grupo) y escriba su primera consulta, solo haga esto:

 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 ) ;
  } ) ;

Establecer conexión

Hay dos posibles formas de crear una conexión entre su aplicación y el servidor Manticore/Sphinx. Primero y más simple es usar el método createConnection .

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

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

La segunda opción es usar el método createPoolConnection . Esta metodología le permite tener múltiples conexiones abiertas con Manticore/Sphinx reutilizando conexiones anteriores. Para obtener más información sobre los grupos de conexión MySQL2 (parámetros permitidos para la creación y configuración del grupo) lea la documentación de MySQL2 sobre el uso de grupos de conexión. Esta técnica usa más memoria, así que tenga en cuenta.

 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
} ) ;

SELECCIONAR

Esta sección está separada en muchas partes, pero si ha usado SphinXQL antes o SQL, puede ver esta sección también muy básica para usted. De todos modos, recomiendo fuertemente leer la búsqueda de Manticore o la documentación de Sphinx para hacer una buena idea de cómo usar esta API.

Donde y los métodos de coincidencia

• donde (columnExpr: string, operador: string, valor?: cualquiera)
• en dónde (columna: cadena, valores: cualquier [])
• whereNotin (columna: cadena, valores: any [])
• entre (columna: cadena, valor1: any, valor2: cualquiera)
• Match (Fields: String [] | String, Value: String, EscapeValue: Boolean = True)
• Ormatch (Fields: String [] | String, Value: String, EscapeValue: Boolean = True)

Ejemplo aquí:

 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 ) ;
  } ) ; 

OPCIÓN

Puede encadenar múltiples opciones utilizando el método "Opción". La cabeza del método es:

• opción (opción: cadena, valor: cualquiera) donde el argumento de valor puede ser una instancia de:
• Instancia de expresión para parámetros no recapitados
• Objeto de valor clave (ejemplo a continuación)
• Cadena para un valor de opción simple y escapado.

Ejemplo con la opción:

 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 ) ;
  } ) ; 

Búsqueda facial

// HACER

INSERTAR

Se crea una declaración de inserción como esta:

 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 ) ;
  } ) ;

O utilizando una matriz de pares de valor clave para insertar múltiples valores en la misma 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 ) ;
  } ) ;

REEMPLAZAR

Reemplaza un documento utilizando la ID de doc o insertar. Similar a la declaración de inserción solo cambia de inserción para reemplazar.

 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 ) ;
  } ) ;

ACTUALIZAR

 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 ) ;
  } ) ;

Actas

Este paquete también viene con soporte para transacciones. Recuerde que las transacciones solo están disponibles para índices RT. Para obtener más información, visite la documentación de transacciones para la búsqueda de Manticore.

La API de transacciones es simple y la lista de métodos está a continuación aquí:

• Connection.getQueryBuilder (). Transaction.Begin ()
• Connection.getQueryBuilder (). Transaction.Start () // mismo que comienza ()
• Connection.getQueryBuilder (). Transaction.commit ()
• Connection.getQueryBuilder (). Transaction.Rollback ()

Todos estos métodos devuelven un objeto prometedor.

Un ejemplo simple trabajando con transacciones:

 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 por lotes (consultas múltiples)

En primer lugar, necesita saber las limitaciones de las consultas múltiples en Manticore/Sphinx. Como Manticore Search and Sphinx Documation dijo que solo hay soporte para las siguientes afirmaciones utilizadas en un lote:

• SELECCIONAR
• Mostrar advertencias
• Mostrar estado
• Mostrar meta

Dijo esto, ahora es el momento para escribir código. Hay una clase, la cola , que implementa solo los métodos necesarios, es útil ejecutar consultas múltiples. Para habilitar múltiples declaraciones, debe especificar en su objeto de configuración para la creación de conexión, las multiplicaciones: Verdadero de la siguiente manera:

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

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

Ahora creemos una cola y procesemos:

 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 ) ) ;

Más métodos de SphinxQL

• OptimizeIndex (índice: cadena): promesa
• adjectindex (diskIndex: string): adjectindexStatement
• truncate (rtindex: string): truncatestatement
• reloadindex (índice: string): reloadindexstatement

Adjuntar índice (adjuntarindexstatement)

Lea sobre el índice adjunto en el documento de Manticore para usar esta declaración Consulte el ejemplo a continuación:

 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)

Lea sobre FLUSH RTIndex para usar esta declaración Consulte el ejemplo a continuación):

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

Truncate rtindex (truncatestatement)

Lea sobre Truncate RTindex en Documante de Manticore para usar esta declaración Vea el ejemplo a continuación:

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

Índice de recarga

Lea sobre el índice de recarga en el documento de Manticore para usar esta declaración Vea el ejemplo a continuación:

 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 ) ;
  } ) ;

Ejecutar consultas crudas

Ejecute consultas sin procesar utilizando el método de consulta que está disponible después del método de llamada getQueryBuilder. Este método permite la declaración preparada usando un? (signo de interrogación) Donde desea escapar del 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 depuración

Todas las declaraciones tienen un método final que se usa internamente para ejecutar consultas. Este método está disponible afuera usando Generate () y devuelve una cadena con la 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