Comment sélectionner une ligne postgreSQL contenant un mot spécifique

Cette expression:

WHERE column ~* '[jep]'

Correspond uniquement aux lignes dont la valeur est lower (column) = 'jeep' , comme:

• JEEP
• jeep
• JeeP

Il ne correspond à aucune autre expression.

Si vous utilisez des caractères génériques:

 WHERE column ilike '%jeep%'

alors il recherche ' jeep ' n'importe où dans inférieur (colonne) . Il ne s'agit pas de rechercher caractère par caractère. Pour cela, vous utiliseriez des expressions régulières et des classes de caractères:

 WHERE column ilike 'jeep'

Si vous voulez trouver un mot dans le champ, vous utiliseriez normalement expressions, pas comme/ilike.

L'utilisation de .union fonctionne et renvoie les valeurs correctes, mais en utilisant la balise clé de la première table de la requête. J'ai fini par faire quatre requêtes distinctes à la fin, mais j'espère que cela peut aider d'autres!

searchAllBoardPosts(db, term) {
        return db
            .union([db
                    .select('id', 'market_place_cat')
                    .from('market_place')
                    .where('title', 'ilike', `%${term}%`)
            ])
            .union([db
                    .select('id', 'board_id')
                    .from('messageboard_posts')
                    .where('title', 'ilike', `%${term}%`)
            ])
            .union([db
                    .select('id', 'rental_cat')
                    .from('rentals')
                    .where('title', 'ilike', `%${term}%`)
            ])
            .union([db
                    .select('id', 'job_cat')
                    .from('jobs')
                    .where('title', 'ilike', `%${term}%`)
            ]);
    },

Cette requête est une jointure croisée

(mais la syntaxe de Knex masque cela, un peu).

Ceci renvoie n'importe quelle ligne qui a j, e ou p dans la colonne (et la même ligne plusieurs fois pour une raison quelconque).

Il ne renvoie pas la même ligne plusieurs fois. Il renvoie tout de chaque table nommée dans un CROSS JOIN . C'est le comportement de Postgres lorsque plusieurs tables sont nommées dans la clause FROM (voir: docs ). Ceci:

[
  { id: 1, title: 'WILLMATCHwombatblahblahblah', type: 'table_one' },
  { id: 2, title: 'WILLMATCHWOMBAT', type: 'table_one' },
  { id: 2, title: 'wombatWILLMATCH', type: 'table_two' }
]

renverra la ligne entière de chacune des tables nommées chaque fois que vous obtenez un Correspondance ILIKE . Ainsi, au minimum, vous obtiendrez toujours un objet composé de deux lignes jointes (ou quel que soit le nombre que vous nommez dans la clause FROM ).

La partie délicate est que les noms de colonnes Knex ont pour mapper sur des objets JavaScript. Cela signifie que s'il y a deux résultats de colonne nommés, par exemple, id ou title , le dernier écrasera le premier dans l'objet résultant.

Illustrons (avec des wombats)

Voici une migration et une graine, juste pour clarifier les choses:

table_one

  return db
    .unionAll([
      db("market_place")
        .select(db.raw("*, 'marketplace' as type"))
        .where("title", "ilike", `%${term}%`),
      db("messageboard_posts")
        .select(db.raw("*, 'post' as type"))
        .where("title", "ilike", `%${term}%`),
      db("rentals")
        .select(db.raw("*, 'rental' as type"))
        .where("title", "ilike", `%${term}%`),
      db("jobs")
        .select(db.raw("*, 'job' as type"))
        .where("title", "ilike", `%${term}%`)
    ]);

table_two

[
  {
    'a.id': 1,
    'a.title': 'WILLMATCHwombatblahblahblah',
    'b.id': 1,
    'b.title': 'NEVERMATCHwwwwwww'
  },
  {
    'a.id': 1,
    'a.title': 'WILLMATCHwombatblahblahblah',
    'b.id': 2,
    'b.title': 'wombatWILLMATCH'
  },
  {
    'a.id': 2,
    'a.title': 'WILLMATCHWOMBAT',
    'b.id': 1,
    'b.title': 'NEVERMATCHwwwwwww'
  },
  {
    'a.id': 2,
    'a.title': 'WILLMATCHWOMBAT',
    'b.id': 2,
    'b.title': 'wombatWILLMATCH'
  }
]

Seed

  return db
    .select([
      "a.id as a.id",
      "a.title as a.title",
      "b.id as b.id",
      "b.title as b.title"
    ])
    .from({
      a: "table_one",
      b: "table_two"
    })
    .where("a.title", "ilike", `%${term}%`)
    .orWhere("b.title", "ilike", `%${term}%`);

Query

Cela nous permet de jouer un peu avec Correspondance ILIKE . Nous devons maintenant rendre les noms de colonnes vraiment explicites:

exports.seed = knex =>
    knex("table_one")
      .del()
      .then(() => knex("table_two").del())
      .then(() =>
        knex("table_one").insert([
          { title: "WILLMATCHwombatblahblahblah" },
          { title: "WILLMATCHWOMBAT" }
        ])
      )
      .then(() =>
        knex("table_two").insert([
          { title: "NEVERMATCHwwwwwww" },
          { title: "wombatWILLMATCH" }
        ])
      )
  );

Cela produit:

exports.up = knex =>
  knex.schema.createTable("table_two", t => {
    t.increments("id");
    t.string("title");
  });

exports.down = knex => knex.schema.dropTable("table_two");

Comme vous pouvez le voir, c'est joignant les deux tables, mais je suppose que vous ne voyiez que des résultats qui semblaient ne pas correspondre (car la correspondance était dans l'autre table et le nom de la colonne title était un dupliquer).

Alors, quelle devrait être la requête?

Je pense que votre projet (ou celui de Ry) d'utiliser UNION était correct, mais cela en vaut probablement la peine en utilisant UNION ALL pour éviter la suppression inutile des doublons. Quelque chose comme ceci:

exports.up = knex =>
  knex.schema.createTable("table_one", t => {
    t.increments("id");
    t.string("title");
  });

exports.down = knex => knex.schema.dropTable("table_one");

Une requête similaire sur nos données de test produit l'ensemble de résultats:

db
  .select('*')
  .from({
    a: 'table_one',
    b: 'table_two'
  })