sphinxql

sphinxql

SPHINXQL Query Builder pour Node.js a écrit dans TypeScript. Faites des requêtes faciles en évitant d'écrire toujours des chaînes de sphinxql brutes que vous pouvez. Par défaut, il utilise les paramètres de requête échappés, en pensant toujours dans la sécurité.

Il est fortement inspiré dans le BUILDER PHP SPHINXQL-QUERY ainsi que le constructeur de requête éloquent (Laravel Framework ORM)

Le client utilisé pour Create Connection est MySQL2 qui est axé sur les performances.

exigences

Vous devez utiliser Node.js> = 6.x

installer

Exécutez simplement la commande npm:

npm install --save sphinxql

usage

Pour créer une connexion simple (pas la plus recommandée, utilisez une connexion au pool) et écrivez votre première requête, faites-le simplement:

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

Établir une connexion

Il existe deux façons possibles de créer une connexion entre votre application et le serveur Manticore / Sphinx. Tout d'abord et le plus simple utilise la méthode createConnection .

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

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

La deuxième option consiste à utiliser la méthode createPoolConnection . Cette méthodologie vous permet d'avoir plusieurs connexions ouvertes avec les connexions précédentes de Manticore / Sphinx. Pour en savoir plus sur les pools de connexion MySQL2 (paramètres autorisés pour la création et la configuration du pool), lisez la documentation MySQL2 sur l'utilisation des pools de connexion. Cette technique utilise plus de mémoire, alors soyez conscient.

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

SÉLECTIONNER

Cette section est séparée dans de nombreuses parties, mais si vous avez utilisé SphinXQL avant ou SQL, vous pouvez voir cette section également très basique pour vous. Quoi qu'il en soit, je recommande fortement de lire la recherche Manticore ou la documentation Sphinx pour faire une bonne idée de la façon d'utiliser cette API.

Où et correspond aux méthodes

• Où (ColumnExpr: String, Operator: String, Value ?: Any)
• où (colonne: chaîne, valeurs: tout [])
• wherenotin (colonne: chaîne, valeurs: tout [])
• Entre (colonne: chaîne, valeur1: any, valeur2: any)
• Match (champs: String [] | String, Valeur: String, EscapeValue: boolean = true)
• Ormatch (champs: chaîne [] | chaîne, valeur: chaîne, EscapeValue: boolean = true)

Exemple ici:

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

OPTION

Vous pouvez enchaîner plusieurs options à l'aide de la méthode "Option". La tête de méthode est:

• Option (Option: String, Value: Any) où l'argument de valeur peut être une instance de:
• Instance d'expression pour les paramètres non testés
• Objet de valeur clé (exemple ci-dessous)
• chaîne pour la valeur d'option simple et échappée.

Exemple avec l'option:

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

Recherche à facettes

// FAIRE

INSÉRER

Une instruction INSERT est créée comme ceci:

 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 en utilisant un tableau de paires de valeurs clés pour insérer plusieurs valeurs dans la même requête

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

REMPLACER

Remplace un document à l'aide de l'ID ou de l'insertion DOC. Similaire à l'insertion de l'instruction Changer uniquement l'insert pour remplacer.

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

MISE À JOUR

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

Transactions

Ce package est également livré avec la prise en charge des transactions. N'oubliez pas que les transactions ne sont disponibles que pour les index RT. Pour plus d'informations, visitez la documentation des transactions pour la recherche Manticore.

L'API Transactions est simple et la liste des méthodes est ci-dessous ici:

• connection.getQueryBuilder (). Transaction.Begin ()
• connection.getQueryBuilder (). transaction.start () // même qui commence ()
• connection.getQueryBuilder (). Transaction.Commit ()
• connection.getQueryBuilder (). Transaction.Rollback ()

Toutes ces méthodes renvoient un objet de promesse.

Un exemple simple fonctionnant avec les transactions:

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

Requêtes par lots (multi-requêtes)

Tout d'abord, vous avez besoin de connaître les limites des multiples requêtes dans Manticore / Sphinx. Comme l'a dit la recherche sur la recherche et le sphinx de Manticore, il n'y a que la prise en charge des déclarations suivantes utilisées dans un lot:

• SÉLECTIONNER
• Montrer les avertissements
• Afficher le statut
• Montrer la méta

Dit ceci, c'est maintenant le moment d'écrire du code. Il y a une classe, la file d'attente , qui implémente uniquement les méthodes nécessaires, il est utile d'exécuter des requêtes multiples. Pour activer les instructions multiples, vous devez spécifier dans votre objet de configuration pour la création de connexion Le multiplesatements: true comme suivant:

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

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

Créons maintenant une file d'attente et traitons-le:

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

Plus de méthodes de sphinxql

• OptimizeIndex (index: string): promesse
• attachIndex (diskindex: string): jointIndexstatement
• truncate (rTindex: String): truncatestatement
• reloadIndex (index: string): reloadIndexstatement

Fixer l'index (attachIndexstatement)

Lire sur l'indice de joints dans le documentation de Manticore pour utiliser cette déclaration Voir l'exemple ci-dessous:

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

Rinter rTindex (FlushrTindexstatement)

Lire sur Flush rTindex pour utiliser cette déclaration Voir l'exemple ci-dessous):

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

Truncicate rTindex (truncatestatement)

Lire sur truncate rTindex dans le documentation de Manticore pour utiliser cette déclaration Voir l'exemple ci-dessous:

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

Index de rechargement

Lire sur l'indice de rechargement dans la documentation de Manticore pour utiliser cette déclaration Voir l'exemple ci-dessous:

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

Exécuter des requêtes brutes

Exécutez les requêtes brutes à l'aide de la méthode de requête disponible après l'appel GetQueryBuilder. Cette méthode permet une instruction préparée à l'aide d'un? (point d'interrogation) où vous souhaitez échapper à la valeur.

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

Requêtes de débogage

Toutes les instructions ont une méthode finale utilisée en interne pour exécuter des requêtes. Cette méthode est disponible à l'extérieur en utilisant generate () et renvoie une chaîne avec la requête finale.

 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