wildcard

項目一覧

定義

構文
オプション
動作
例

定義

wildcard

wildcard 演算子を使用すると、検索文字列に任意の文字と一致する特殊文字を使用するクエリが可能になります。

文字	説明
`?`	任意の 1 文字と一致します。
`*`	0 文字以上の文字と一致します。
`\`	エスケープ文字。

wildcard はタームレベルの演算子であり、 query フィールドは分析されないことを意味します。query フィールドは特殊文字を含む 1 つのタームとして扱われるため、タームレベルの演算子はキーワードアナライザと連携します。分析された query フィールドと分析されていない query フィールドに対するクエリの例については、「分析されたフィールドの例」を参照してください。

構文

wildcard の構文は次のとおりです。

{
  $search: {
    "index": <index name>, // optional, defaults to "default"
    "wildcard": {
      "query": "<search-string>",
      "path": "<field-to-search>",
      "allowAnalyzedField": <boolean>,
      "score": <options>
    }
  }
}

オプション

wildcard では、次の用語を使用してクエリを作成します。

フィールド	タイプ	説明	必要性	default
`query`	文字列または複数の文字列の配列	検索する文字列または複数の文字列。	はい
`path`	文字列または複数の文字列の配列	インデックス付きフィールドまたは検索するフィールド。ワイルドカードパスを指定して検索することもできます。詳しくは、「パスの構築」を参照してください。	はい
`allowAnalyzedField`	ブール値	分析対象フィールドに対してクエリを実行する場合は、 `true` に設定する必要があります。	no	`false`
`score`	オブジェクト	一致する検索用語の結果に割り当てられたスコアを変更します。次の選択肢があります。 `boost`: 結果のスコアに指定された数値を掛けます。 `constant`: 結果のスコアを指定された数値に置き換えます。 `function`: 指定された式を使用して結果スコアを置き換えます。クエリで `score` を使用する方法については、「結果内のドキュメントのスコアリング」を参照してください。	no

動作

wildcard はタームレベルの演算子であり、 query フィールドは分析されないことを意味します。allowAnalyzedField オプションを true に設定することで、wildcard 演算子を使用してインデックス作成中に分析されたフィールドで検索を実行することは可能ですが、結果にはクエリテキストが分析されていないことが反映されます。

例

フィールド foo bar baz は標準アナライザでインデックス付けされてます。Atlas Search はフィールドを分析し、foo、 bar、 bazとしてインデックスを作成します。このフィールドで foo bar* を検索しても何も見つかりません。これは、ワイルドカード演算子が foo bar* を末尾にワイルドカードが付いた単一の検索用語として扱うためです。つまり、Atlas Search はフィールド内で foo bar で始まる用語を検索しますが、用語が存在しないため何も見つかりません。

例

keyword アナライザでインデックス付けされたフィールドで *Star Trek* を検索すると、任意のコンテキストでフィールドに文字列Star Trek が含まれるすべてのドキュメントが見つかります。標準アナライザでフィールドにインデックス付けされた *Star Trek* を検索しても何も見つかりません。これは、 Star とTrek の間にスペースがあり、インデックスにスペースが含まれていないためです。

エスケープ文字の動作

mongoshまたはドライバーとともにエスケープ文字を使用する場合は、エスケープ文字の前にdoubleバックスラッシュを使用する必要があります。

例

リテラルアスタリスクを含む任意の文字列を検索するワイルドカード式を作成するには、次の式を使用します。

"*\\**"

最初と最後のアスタリスクは任意の文字に一致するワイルドカードとして機能し、\\* はリテラルのアスタリスクに一致します。

注意

次の式を使用して、リテラルのバックスラッシュをエスケープします。

"*\\\*"

➤ [言語の選択] ドロップダウンメニューを使用して、このページの例の言語を設定します。

例

次の例では、キーワードアナライザを使用するカスタムインデックス定義を持つ sample_mflix データベースの movies コレクションを使用します。クラスターにサンプルデータセットがある場合は、movies コレクションに Atlas Search インデックスを作成し、クラスターでサンプルクエリを実行できます。

Tip

サンプルデータセットをすでに読み込んでいる場合は、「Atlas Search スタートガイド」チュートリアルに従って、インデックスの定義を作成し、Atlas Search クエリを実行します。

Search Testerのクエリ構文を表示および編集するには、以下の手順を行ってください。

AtlasGoClustersAtlas で、プロジェクトのページにGoします。

まだ表示されていない場合は、希望するプロジェクトを含む組織を選択しますナビゲーションバーのOrganizationsメニュー
まだ表示されていない場合は、ナビゲーションバーのProjectsメニューから目的のプロジェクトを選択します。
まだ表示されていない場合は、サイドバーの Clusters をクリックしてください。
[ Clusters （クラスター） ] ページが表示されます。

GoAtlas Searchクラスターのページにします。

GoAtlas Searchページには、サイドバー、Data Explorer 、またはクラスターの詳細ページからできます。

サイドバーで、 Services見出しの下のAtlas Searchをクリックします。
[ Select data sourceドロップダウンからクラスターを選択し、[ Go to Atlas Search ] をクリックします。
Atlas Searchページが表示されます。

クラスターの [Browse Collections] ボタンをクリックします。
データベースを展開し、コレクションを選択します。
コレクションのSearch Indexesタブをクリックします。
Atlas Searchページが表示されます。

クラスタの名前をクリックします。
[Atlas Search] タブをクリックします。
Atlas Searchページが表示されます。

クエリ構文を表示および編集します。

クエリするインデックスの右側にある [ Query ] ボタンをクリックします。
Edit Queryをクリックすると、 JSON形式のデフォルトのクエリ構文サンプルが表示されます。

sample_mflix データベースを使用するには、mongosh プロンプトで次のコマンドを実行します。

use sample_mflix

インデックスの定義

次のインデックス定義は、キーワードアナライザを使用して、movies コレクションの title フィールドにインデックスを作成します。

1 {
2   "mappings": {
3     "fields": {
4       "title": {
5         "analyzer": "lucene.keyword",
6         "type": "string"
7       }
8     }
9   }
10 }

次の例では、Green D で始まり、その後に任意の数の他の文字が続く映画のタイトルをすべての title フィールドで検索します。

次のクエリをコピーして、 Query Editorに貼り付け、 Query EditorのSearchボタンをクリックします。

[
  {
    $search: {
      "wildcard": {
        "path": "title",
        "query": "Green D*"
      }
    }
  }
]

db.movies.aggregate([
  {
    "$search": {
      "wildcard": {
        "path": "title",
        "query": "Green D*"
      }
    }
  },
  {
    "$project": {
      "_id": 0,
      "title": 1
    }
  }
])

moviesコレクションのAggregationsタブで、ドロップダウンからステージを選択し、そのステージのクエリを追加して、次の各パイプラインステージを構成します。ステージを追加するには、 Add Stageをクリックします。

パイプラインステージ

クエリ

$search

{
  "wildcard": {
    "query": "Green D*",
    "path": "title"
  }
}

$project

{
  "_id": 0,
  "title": 1,
}

using MongoDB.Bson;
using MongoDB.Bson.Serialization.Attributes;
using MongoDB.Bson.Serialization.Conventions;
using MongoDB.Driver;
using MongoDB.Driver.Search;
public class WildcardSingleCharacter
{
    private const string MongoConnectionString = "<connection-string>";
    public static void Main(string[] args)
    {
        // allow automapping of the camelCase database fields to our MovieDocument
        var camelCaseConvention = new ConventionPack { new CamelCaseElementNameConvention() };
        ConventionRegistry.Register("CamelCase", camelCaseConvention, type => true);
        // connect to your Atlas cluster
        var mongoClient = new MongoClient(MongoConnectionString);
        var mflixDatabase = mongoClient.GetDatabase("sample_mflix");
        var moviesCollection = mflixDatabase.GetCollection<MovieDocument>("movies");
        // define and run pipeline
        var results = moviesCollection.Aggregate()
            .Search(Builders<MovieDocument>.Search.Wildcard(movie => movie.Title, "Green D*"))
            .Project<MovieDocument>(Builders<MovieDocument>.Projection
                .Include(movie => movie.Title)
                .Exclude(movie => movie.Id))
            .ToList();
        // print results
        foreach (var movie in results)
        {
            Console.WriteLine(movie.ToJson());
        }
    }
}
[BsonIgnoreExtraElements]
public class MovieDocument
{
    [BsonIgnoreIfDefault]
    public ObjectId Id { get; set; }
    public string Title { get; set; }
}

package main
import (
	"context"
	"fmt"
	"go.mongodb.org/mongo-driver/bson"
	"go.mongodb.org/mongo-driver/mongo"
	"go.mongodb.org/mongo-driver/mongo/options"
)
func main() {
	// connect to your Atlas cluster
	client, err := mongo.Connect(context.TODO(), options.Client().ApplyURI("<connection-string>"))
	if err != nil {
		panic(err)
	}
	defer client.Disconnect(context.TODO())
	// set namespace
	collection := client.Database("sample_mflix").Collection("movies")
	// define pipeline stages
	searchStage := bson.D{{"$search", bson.D{{"wildcard", bson.D{{"path", "title"}, {"query", "Green D*"}}}}}}
	projectStage := bson.D{{"$project", bson.D{{"title", 1}, {"_id", 0}}}}
	// run pipeline
	cursor, err := collection.Aggregate(context.TODO(), mongo.Pipeline{searchStage, projectStage})
	if err != nil {
		panic(err)
	}
	// print results
	var results []bson.D
	if err = cursor.All(context.TODO(), &results); err != nil {
		panic(err)
	}
	for _, result := range results {
		fmt.Println(result)
	}
}

import static com.mongodb.client.model.Filters.eq;
import static com.mongodb.client.model.Aggregates.project;
import static com.mongodb.client.model.Projections.excludeId;
import static com.mongodb.client.model.Projections.fields;
import static com.mongodb.client.model.Projections.include;
import com.mongodb.client.MongoClient;
import com.mongodb.client.MongoClients;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoDatabase;
import org.bson.Document;
import java.util.Arrays;
public class WildcardSingleCharacter {
    public static void main(String[] args) {
        // connect to your Atlas cluster
        String uri = "<connection-string>";
        try (MongoClient mongoClient = MongoClients.create(uri)) {
            // set namespace
            MongoDatabase database = mongoClient.getDatabase("sample_mflix");
            MongoCollection<Document> collection = database.getCollection("movies");
            
            // define pipeline
            Document agg = new Document("query", "Green D*").append("path", "title");
            // run pipeline and print results
            collection.aggregate(Arrays.asList(
                eq("$search", eq("wildcard", agg)),
                project(fields(excludeId(), include("title"))))).forEach(doc -> System.out.println(doc.toJson()));
        }
    }
}

import com.mongodb.client.model.Aggregates.project
import com.mongodb.client.model.Filters.eq
import com.mongodb.client.model.Projections.*
import com.mongodb.kotlin.client.coroutine.MongoClient
import kotlinx.coroutines.runBlocking
import org.bson.Document
fun main() {
    val uri = "<connection-string>"
    val mongoClient = MongoClient.create(uri)
    val database = mongoClient.getDatabase("sample_mflix")
    val collection = database.getCollection<Document>("movies")
    runBlocking {
        val agg = Document("query", "Green D*").append("path", "title")
        val resultsFlow = collection.aggregate<Document>(
            listOf(
                eq("\$search", eq("wildcard", agg)),
                project(fields(
                    excludeId(),
                    include("title")
                ))
            )
        )
        resultsFlow.collect { println(it) }
    }
    mongoClient.close()
}

const { MongoClient } = require("mongodb");
// connect to your Atlas cluster
const uri =
    "<connection-string>";
const client = new MongoClient(uri);
async function run() {
    try {
        await client.connect();
        // set namespace
        const database = client.db("sample_mflix");
        const coll = database.collection("movies");
        // define pipeline
        const agg = [
            {$search: {wildcard: {query: "Green D*", path: "title"}}},
            {$project: {_id: 0, title: 1}},
        ];
        // run pipeline
        const result = await coll.aggregate(agg);
        // print results
        await result.forEach((doc) => console.log(doc));
    } finally {
        await client.close();
    }
}
run().catch(console.dir);

import pymongo
# connect to your Atlas cluster
client = pymongo.MongoClient('<connection-string>')
# define pipeline
pipeline = [
    {"$search": {"wildcard": {"query": "Green D*", "path": "title"}}},
    {"$project": {"_id": 0, "title": 1}},
]
# run pipeline
result = client["sample_mflix"]["movies"].aggregate(pipeline)
# print results
for i in result:
    print(i)

上記のクエリは、次の結果を返します。

SCORE: 1  _id:  "573a1393f29313caabcddaf5"
  plot: "Sophie loved Edmund, but he left town when her parents forced her to m…"
  genres: Array
  runtime: 141
SCORE: 1  _id:  "573a13a2f29313caabd0a4e4"
  plot: "The story of some Vietnamese refugees as they first arrive at Camp Pen…"
  genres: Array
  runtime: 115

Search Testerでは、返されるドキュメント内のすべてのフィールドが表示されない場合があります。クエリパスで指定したフィールドを含むすべてのフィールドを表示するには、結果内のドキュメントを展開します。

{ "title" : "Green Dolphin Street" }
{ "title" : "Green Dragon" }

{ "title" : "Green Dolphin Street" }
{ "title" : "Green Dragon" }

{ "title" : "Green Dolphin Street" }
{ "title" : "Green Dragon" }

[{title Green Dolphin Street}]
[{title Green Dragon}]

{"title": "Green Dolphin Street"}
{"title": "Green Dragon"}

Document{{title=Green Dolphin Street}}
Document{{title=Green Dragon}}

{ title: 'Green Dolphin Street' }
{ title: 'Green Dragon' }

{'title': 'Green Dolphin Street'}
{'title': 'Green Dragon'}

次の例では、文字列 Wom?n （? は任意の 1 文字）で始まり、その後にスペースが続き、任意の数の追加文字が続く映画のタイトルを、すべての title フィールドで検索します。

次のクエリをコピーして、 Query Editorに貼り付け、 Query EditorのSearchボタンをクリックします。

[
  {
    $search: {
      "wildcard": {
        "path": "title",
        "query": "Wom?n *"
      }
    }
  }
]

$limit ステージでは、結果を 5 つのドキュメントに制限し、$project ステージでは、結果を title フィールドのみに制限します。

db.movies.aggregate([
  {
    "$search": {
      "wildcard": {
        "path": "title",
        "query": "Wom?n *"
      }
    }
  },
  {
    "$limit": 5
  },
  {
    "$project": {
      "_id": 0,
      "title": 1
    }
  }
])

$limit ステージでは、結果を 5 つのドキュメントに制限し、$project ステージでは、結果を title フィールドのみに制限します。

パイプラインステージ

クエリ

$search

{
  "wildcard": {
    "query": "Wom?n *",
    "path": "title"
  }
}

$limit

$project

{
  "_id": 0,
  "title": 1,
}

$limit ステージでは、結果を 5 つのドキュメントに制限し、$project ステージでは、結果を title フィールドのみに制限します。

using MongoDB.Bson;
using MongoDB.Bson.Serialization.Attributes;
using MongoDB.Bson.Serialization.Conventions;
using MongoDB.Driver;
using MongoDB.Driver.Search;
public class WildcardMultipleCharacter
{
    private const string MongoConnectionString = "<connection-string>";
    public static void Main(string[] args)
    {
        // allow automapping of the camelCase database fields to our MovieDocument
        var camelCaseConvention = new ConventionPack { new CamelCaseElementNameConvention() };
        ConventionRegistry.Register("CamelCase", camelCaseConvention, type => true);
        // connect to your Atlas cluster
        var mongoClient = new MongoClient(MongoConnectionString);
        var mflixDatabase = mongoClient.GetDatabase("sample_mflix");
        var moviesCollection = mflixDatabase.GetCollection<MovieDocument>("movies");
        // define and run pipeline
        var results = moviesCollection.Aggregate()
            .Search(Builders<MovieDocument>.Search.Wildcard(movie => movie.Title, "Wom?n *"))
            .Project<MovieDocument>(Builders<MovieDocument>.Projection
                .Include(movie => movie.Title)
                .Exclude(movie => movie.Id))
            .Limit(5)
            .ToList();
        // print results
        foreach (var movie in results)
        {
            Console.WriteLine(movie.ToJson());
        }
    }
}
[BsonIgnoreExtraElements]
public class MovieDocument
{
    [BsonIgnoreIfDefault]
    public ObjectId Id { get; set; }
    public string Title { get; set; }
}

$limit ステージでは、結果を 5 つのドキュメントに制限し、$project ステージでは、結果を title フィールドのみに制限します。

package main
import (
	"context"
	"fmt"
	"go.mongodb.org/mongo-driver/bson"
	"go.mongodb.org/mongo-driver/mongo"
	"go.mongodb.org/mongo-driver/mongo/options"
)
func main() {
	// connect to your Atlas cluster
	client, err := mongo.Connect(context.TODO(), options.Client().ApplyURI("<connection-string>"))
	if err != nil {
		panic(err)
	}
	defer client.Disconnect(context.TODO())
	// set namespace
	collection := client.Database("sample_mflix").Collection("movies")
	// define pipeline stages
	searchStage := bson.D{{"$search", bson.D{{"wildcard", bson.D{{"path", "title"}, {"query", "Wom?n *"}}}}}}
	limitStage := bson.D{{"$limit", 5}}
	projectStage := bson.D{{"$project", bson.D{{"title", 1}, {"_id", 0}}}}
	// run pipeline
	cursor, err := collection.Aggregate(context.TODO(), mongo.Pipeline{searchStage, limitStage, projectStage})
	if err != nil {
		panic(err)
	}
	// print results
	var results []bson.D
	if err = cursor.All(context.TODO(), &results); err != nil {
		panic(err)
	}
	for _, result := range results {
		fmt.Println(result)
	}
}

$limit ステージでは、結果を 5 つのドキュメントに制限し、$project ステージでは、結果を title フィールドのみに制限します。

import static com.mongodb.client.model.Filters.eq;
import static com.mongodb.client.model.Aggregates.limit;
import static com.mongodb.client.model.Aggregates.project;
import static com.mongodb.client.model.Projections.excludeId;
import static com.mongodb.client.model.Projections.fields;
import static com.mongodb.client.model.Projections.include;
import com.mongodb.client.MongoClient;
import com.mongodb.client.MongoClients;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoDatabase;
import org.bson.Document;
import java.util.Arrays;
public class WildcardMultiCharacter {
    public static void main(String[] args) {
        // connect to your Atlas cluster
        String uri = "<connection-string>";
        try (MongoClient mongoClient = MongoClients.create(uri)) {
            // set namespsace
            MongoDatabase database = mongoClient.getDatabase("sample_mflix");
            MongoCollection<Document> collection = database.getCollection("movies");
            // define pipeline
            Document agg = new Document("query", "Wom?n *").append("path", "title");
            // run pipeline and print results
            collection.aggregate(Arrays.asList(
                eq("$search", eq("wildcard", agg)),
                limit(5),
                project(fields(excludeId(), include("title"))))).forEach(doc -> System.out.println(doc.toJson()));
        }
    }
}

$limit ステージでは、結果を 5 つのドキュメントに制限し、$project ステージでは、結果を title フィールドのみに制限します。

import com.mongodb.client.model.Aggregates.limit
import com.mongodb.client.model.Aggregates.project
import com.mongodb.client.model.Filters.eq
import com.mongodb.client.model.Projections.*
import com.mongodb.kotlin.client.coroutine.MongoClient
import kotlinx.coroutines.runBlocking
import org.bson.Document
fun main() {
    val uri = "<connection-string>"
    val mongoClient = MongoClient.create(uri)
    val database = mongoClient.getDatabase("sample_mflix")
    val collection = database.getCollection<Document>("movies")
    runBlocking {
        val agg = Document("query", "Wom?n *").append("path", "title")
        val resultsFlow = collection.aggregate<Document>(
            listOf(
                eq("\$search", eq("wildcard", agg)),
                limit(5),
                project(fields(
                    excludeId(),
                    include("title")
                ))
            )
        )
        resultsFlow.collect { println(it) }
    }
    mongoClient.close()
}

$limit ステージでは、結果を 5 つのドキュメントに制限し、$project ステージでは、結果を title フィールドのみに制限します。

const { MongoClient } = require("mongodb");
// connect to your Atlas cluster
const uri =
    "<connection-string>";
const client = new MongoClient(uri);
async function run() {
    try {
        await client.connect();
        // set namespace
        const database = client.db("sample_mflix");
        const coll = database.collection("movies");
        // define pipeline
        const agg = [
            {$search: {wildcard: {query: "Wom?n *", path: "title"}}},
            {$limit: 5},
            {$project: {_id: 0,title: 1}}
        ];
        // run pipeline
        const result = await coll.aggregate(agg);
        // print results
        await result.forEach((doc) => console.log(doc));
    } finally {
        await client.close();
    }
}
run().catch(console.dir);

$limit ステージでは、結果を 5 つのドキュメントに制限し、$project ステージでは、結果を title フィールドのみに制限します。

import pymongo
# connect to your Atlas cluster
client = pymongo.MongoClient('<connection-string>')
# define pipeline
pipeline = [
    {"$search": {"wildcard": {"query": "Wom?n *", "path": "title"}}},
    {"$limit": 5},
    {"$project": {"_id": 0, "title": 1}},
]
# run pipeline
result = client["sample_mflix"]["movies"].aggregate(pipeline)
# print results
for i in result:
    print(i)

上記のクエリは、次の結果を返します。

SCORE: 1  _id:  "573a1393f29313caabcdcbdd"
  plot: "Rival reporters Sam and Tess fall in love and get married, only to fin…"
  genres: Array
  runtime: 114
SCORE: 1  _id:  "573a1394f29313caabce08c6"
  plot: "A married, middle-aged woman is shocked to discover that her husband, …"
  genres: Array
  runtime: 93
SCORE: 1  _id:  "573a1395f29313caabce254c"
  plot: "An entomologist searching for insects by the seaside is trapped by loc…"
  genres: Array
  runtime: 123
SCORE: 1  _id:  "573a1396f29313caabce42e5"
  plot: "The battle of the sexes and relationships among the elite of Britian's…"
  genres: Array
  runtime: 131
SCORE: 1  _id:  "573a1398f29313caabceb06d"
  fullplot: "A woman's lover leaves her, and she tries to contact him to find out w…"
  imdb: Object
  year: 1988
SCORE: 1  _id:  "573a139df29313caabcf9c83"
  plot: "A new woman comes between a widower and his adult son."
  genres: Array
  runtime: 110
SCORE: 1  _id:  "573a13a0f29313caabd050bf"
  fullplot: "Isabella is a great cook, making her husband's restaurant in Bahia, Br…"
  imdb: Object
  year: 2000
SCORE: 1  _id:  "573a13aaf29313caabd22c05"
  countries: Array
  genres: Array
  runtime: 115
SCORE: 1  _id:  "573a13aef29313caabd2d899"
  countries: Array
  genres: Array
  runtime: 72
SCORE: 1  _id:  "573a13aff29313caabd32566"
  fullplot: "An adaptation of Bishop T.D. Jakes' self-help novel, chronciling a wom…"
  imdb: Object
  year: 2004

{ "title" : "Woman of the Year" }
{ "title" : "Woman in a Dressing Gown" }
{ "title" : "Woman in the Dunes" }
{ "title" : "Women in Love" }
{ "title" : "Women on the Verge of a Nervous Breakdown" }

{ "title" : "Woman of the Year" }
{ "title" : "Woman in a Dressing Gown" }
{ "title" : "Woman in the Dunes" }
{ "title" : "Women in Love" }
{ "title" : "Women on the Verge of a Nervous Breakdown" }

{ "title" : "Woman of the Year" }
{ "title" : "Woman in a Dressing Gown" }
{ "title" : "Woman in the Dunes" }
{ "title" : "Women in Love" }
{ "title" : "Women on the Verge of a Nervous Breakdown" }

[{title Woman of the Year}]
[{title Woman in a Dressing Gown}]
[{title Woman in the Dunes}]
[{title Women in Love}]
[{title Women on the Verge of a Nervous Breakdown}]

{"title": "Woman of the Year"}
{"title": "Woman in a Dressing Gown"}
{"title": "Woman in the Dunes"}
{"title": "Women in Love"}
{"title": "Women on the Verge of a Nervous Breakdown"}

Document{{title=Woman in the Meadow}}
Document{{title=Woman on the Beach}}
Document{{title=Woman in Love}}
Document{{title=Woman of the Year}}
Document{{title=Woman in a Dressing Gown}}

{ title: 'Woman of the Year' }
{ title: 'Woman in a Dressing Gown' }
{ title: 'Woman in the Dunes' }
{ title: 'Women in Love' }
{ title: 'Women on the Verge of a Nervous Breakdown' }

{'title': 'Woman of the Year'}
{'title': 'Woman in a Dressing Gown'}
{'title': 'Woman in the Dunes'}
{'title': 'Women in Love'}
{'title': 'Women on the Verge of a Nervous Breakdown'}

エスケープ文字の例

次の例では、 titleフィールドが疑問符で終わるドキュメントを検索します。

注意

次の例は mongosh で実行することを目的としています。ドライバーでエスケープ文字を使用する方法について詳しくは、「エスケープ文字の動作」を参照してください。

query フィールドの * 文字は任意の文字に一致し、\\? 文字列はリテラルの疑問符に一致します。

次のクエリをコピーして、 Query Editorに貼り付け、 Query EditorのSearchボタンをクリックします。

[
  {
    $search: {
      "wildcard": {
        "path": "title",
        "query": "*\\?"
      }
    }
  }
]

$limit ステージでは、結果を 5 つのドキュメントに制限し、$project ステージでは、結果を title フィールドのみに制限します。

db.movies.aggregate([
  {
    "$search": {
      "wildcard": {
        "path": "title",
        "query": "*\\?"
      }
    }
  },
  {
    "$limit": 5
  },
  {
    "$project": {
      "_id": 0,
      "title": 1
    }
  }
])

$limit ステージでは、結果を 5 つのドキュメントに制限し、$project ステージでは、結果を title フィールドのみに制限します。

パイプラインステージ

クエリ

$search

{
  "wildcard": {
    "query": "*\\?",
    "path": "title"
  }
}

$limit

$project

{
  "_id": 0,
  "title": 1,
}

$limit ステージでは、結果を 5 つのドキュメントに制限し、$project ステージでは、結果を title フィールドのみに制限します。

using MongoDB.Bson;
using MongoDB.Bson.Serialization.Attributes;
using MongoDB.Bson.Serialization.Conventions;
using MongoDB.Driver;
using MongoDB.Driver.Search;
public class WildcardEscapeCharacter
{
    private const string MongoConnectionString = "<connection-string>";
    public static void Main(string[] args)
    {
        // allow automapping of the camelCase database fields to our MovieDocument
        var camelCaseConvention = new ConventionPack { new CamelCaseElementNameConvention() };
        ConventionRegistry.Register("CamelCase", camelCaseConvention, type => true);
        // connect to your Atlas cluster
        var mongoClient = new MongoClient(MongoConnectionString);
        var mflixDatabase = mongoClient.GetDatabase("sample_mflix");
        var moviesCollection = mflixDatabase.GetCollection<MovieDocument>("movies");
        // define and run pipeline
        var results = moviesCollection.Aggregate()
            .Search(Builders<MovieDocument>.Search.Wildcard(movie => movie.Title, "*\\?"))
            .Project<MovieDocument>(Builders<MovieDocument>.Projection
                .Include(movie => movie.Title)
                .Exclude(movie => movie.Id))
            .Limit(5)
            .ToList();
        // print results
        foreach (var movie in results)
        {
            Console.WriteLine(movie.ToJson());
        }
    }
}
[BsonIgnoreExtraElements]
public class MovieDocument
{
    [BsonIgnoreIfDefault]
    public ObjectId Id { get; set; }
    public string Title { get; set; }
}

$limit ステージでは、結果を 5 つのドキュメントに制限し、$project ステージでは、結果を title フィールドのみに制限します。

package main
import (
	"context"
	"fmt"
	"go.mongodb.org/mongo-driver/bson"
	"go.mongodb.org/mongo-driver/mongo"
	"go.mongodb.org/mongo-driver/mongo/options"
)
func main() {
	// connect to your Atlas cluster
	client, err := mongo.Connect(context.TODO(), options.Client().ApplyURI("<connection-string>"))
	if err != nil {
		panic(err)
	}
	defer client.Disconnect(context.TODO())
	// set namespace
	collection := client.Database("sample_mflix").Collection("movies")
	// define pipeline stages
	searchStage := bson.D{{"$search", bson.D{{"wildcard", bson.D{{"path", "title"}, {"query", "*\\?"}}}}}}
	limitStage := bson.D{{"$limit", 5}}
	projectStage := bson.D{{"$project", bson.D{{"title", 1}, {"_id", 0}}}}
	// run pipeline
	cursor, err := collection.Aggregate(context.TODO(), mongo.Pipeline{searchStage, limitStage, projectStage})
	if err != nil {
		panic(err)
	}
	// print results
	var results []bson.D
	if err = cursor.All(context.TODO(), &results); err != nil {
		panic(err)
	}
	for _, result := range results {
		fmt.Println(result)
	}
}

$limit ステージでは、結果を 5 つのドキュメントに制限し、$project ステージでは、結果を title フィールドのみに制限します。

import static com.mongodb.client.model.Filters.eq;
import static com.mongodb.client.model.Aggregates.limit;
import static com.mongodb.client.model.Aggregates.project;
import static com.mongodb.client.model.Projections.excludeId;
import static com.mongodb.client.model.Projections.fields;
import static com.mongodb.client.model.Projections.include;
import com.mongodb.client.MongoClient;
import com.mongodb.client.MongoClients;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoDatabase;
import org.bson.Document;
import java.util.Arrays;
public class WildcardEscapeCharacter {
    public static void main(String[] args) {
        // connect to your Atlas cluster
        String uri = "<connection-string>";
        try (MongoClient mongoClient = MongoClients.create(uri)) {
            // set namespace
            MongoDatabase database = mongoClient.getDatabase("sample_mflix");
            MongoCollection<Document> collection = database.getCollection("movies");
            
            // define pipeline
            Document agg = new Document("query", "*\\?").append("path", "title");
            // run pipeline and print results
            collection.aggregate(Arrays.asList(
                eq("$search", eq("wildcard", agg)),
                limit(5),
                project(fields(excludeId(), include("title"))))).forEach(doc -> System.out.println(doc.toJson()));
        }
    }
}

$limit ステージでは、結果を 5 つのドキュメントに制限し、$project ステージでは、結果を title フィールドのみに制限します。

import com.mongodb.client.model.Aggregates.limit
import com.mongodb.client.model.Aggregates.project
import com.mongodb.client.model.Filters.eq
import com.mongodb.client.model.Projections.*
import com.mongodb.kotlin.client.coroutine.MongoClient
import kotlinx.coroutines.runBlocking
import org.bson.Document
fun main() {
    val uri = "<connection-string>"
    val mongoClient = MongoClient.create(uri)
    val database = mongoClient.getDatabase("sample_mflix")
    val collection = database.getCollection<Document>("movies")
    runBlocking {
        val agg = Document("query", "*\\?").append("path", "title")
        val resultsFlow = collection.aggregate<Document>(
            listOf(
                eq("\$search", eq("wildcard", agg)),
                limit(5),
                project(fields(
                    excludeId(),
                    include("title")
                ))
            )
        )
        resultsFlow.collect { println(it) }
    }
    mongoClient.close()
}

$limit ステージでは、結果を 5 つのドキュメントに制限し、$project ステージでは、結果を title フィールドのみに制限します。

const { MongoClient } = require("mongodb");
// connect to your Atlas cluster
const uri =
    "<connection-string>";
const client = new MongoClient(uri);
async function run() {
    try {
        await client.connect();
        // set namespace
        const database = client.db("sample_mflix");
        const coll = database.collection("movies");
        // define pipeline
        const agg = [
            {$search: {wildcard: {query: "*\\?", path: "title"}}},
            {$limit: 5},
            {$project: {_id: 0,title: 1}}
        ];
        // run pipeline
        const result = await coll.aggregate(agg);
        // print results
        await result.forEach((doc) => console.log(doc));
    } finally {
        await client.close();
    }
}
run().catch(console.dir);

$limit ステージでは、結果を 5 つのドキュメントに制限し、$project ステージでは、結果を title フィールドのみに制限します。

import pymongo
# connect to your Atlas cluster
client = pymongo.MongoClient('<connection-string>')
# define pipeline
pipeline = [
    {"$search": {"wildcard": {"query": "*\\?", "path": "title"}}},
    {"$limit": 5},
    {"$project": {"_id": 0, "title": 1}},
]
# run pipeline
result = client["sample_mflix"]["movies"].aggregate(pipeline)
# print results
for i in result:
    print(i)

上記のクエリは、次の結果を返します。

SCORE: 1  _id:  "573a1390f29313caabcd5ea4"
  plot: "A District Attorney's outspoken stand on abortion gets him in trouble …"
  genres: Array
  runtime: 62
SCORE: 1  _id:  "573a1392f29313caabcdab4a"
  plot: "Robin is crooning to a Mae West-like Jenny Wren when he is shot with a…"
  genres: Array
  runtime: 8
SCORE: 1  _id:  "573a1394f29313caabce08ab"
  plot: "Elmer Fudd is again hunting rabbits - only this time it's an opera. Wa…"
  genres: Array
  runtime: 7
SCORE: 1  _id:  "573a1394f29313caabce08c8"
  plot: "To save his career, an ad man wants a sex symbol to endorse a lipstick…"
  genres: Array
  runtime: 93
SCORE: 1  _id:  "573a1395f29313caabce1555"
  plot: "In order to get back into the good graces with his wife with whom he h…"
  genres: Array
  runtime: 115
SCORE: 1  _id:  "573a1395f29313caabce1dce"
  plot: "A former child star torments her crippled sister in a decaying Hollywo…"
  genres: Array
  runtime: 134
SCORE: 1  _id:  "573a1395f29313caabce2422"
  plot: "Roger Willoughby is considered to be a leading expert on sports fishin…"
  genres: Array
  runtime: 120
SCORE: 1  _id:  "573a1395f29313caabce2d63"
  plot: "The true story of the departure of the German occupiers from Paris in …"
  genres: Array
  runtime: 173
SCORE: 1  _id:   "573a1395f29313caabce2db5"
  plot: "In this excoriating satire of the fashion industry, Polly Maggoo is a …"
  genres: Array
  runtime: 101
SCORE: 1  _id:   "573a1395f29313caabce2ecc"
  plot: "A bitter aging couple with the help of alcohol, use a young couple to …"
  genres: Array
  runtime: 131

{ "title" : "Where Are My Children?" }
{ "title" : "Who Killed Cock Robin?" }
{ "title" : "What's Opera, Doc?" }
{ "title" : "Will Success Spoil Rock Hunter?" }
{ "title" : "Who Was That Lady?" }

{ "title" : "Where Are My Children?" }
{ "title" : "Who Killed Cock Robin?" }
{ "title" : "What's Opera, Doc?" }
{ "title" : "Will Success Spoil Rock Hunter?" }
{ "title" : "Who Was That Lady?" }

{ "title" : "Where Are My Children?" }
{ "title" : "Who Killed Cock Robin?" }
{ "title" : "What's Opera, Doc?" }
{ "title" : "Will Success Spoil Rock Hunter?" }
{ "title" : "Who Was That Lady?" }

[{title Where Are My Children?}]
[{title Who Killed Cock Robin?}]
[{title What's Opera, Doc?}]
[{title Will Success Spoil Rock Hunter?}]
[{title Who Was That Lady?}]

{"title": "Where Are My Children?"}
{"title": "Who Killed Cock Robin?"}
{"title": "What's Opera, Doc?"}
{"title": "Will Success Spoil Rock Hunter?"}
{"title": "Who Was That Lady?"}

Document{{title=Who Are You, Polly Magoo?}}
Document{{title=Where Were You When the Lights Went Out?}}
Document{{title=Why Does Herr R. Run Amok?}}
Document{{title=What's Up, Doc?}}
Document{{title=Who Is Killing the Great Chefs of Europe?}}

{ title: 'Where Are My Children?' }
{ title: 'Who Killed Cock Robin?' }
{ title: "What's Opera, Doc?" }
{ title: 'Will Success Spoil Rock Hunter?' }
{ title: 'Who Was That Lady?' }

{'title': 'Where Are My Children?'}
{'title': 'Who Killed Cock Robin?'}
{'title': "What's Opera, Doc?"}
{'title': 'Will Success Spoil Rock Hunter?'}
{'title': 'Who Was That Lady?'}

戻る

text

3.クエリパスの構築

1	{
2	"mappings": {
3	"fields": {
4	"title": {
5	"analyzer": "lucene.keyword",
6	"type": "string"
7	}
8	}
9	}
10	}

定義

構文

オプション

動作

例

例

エスケープ文字の動作

例

注意

例

Tip

AtlasGoClustersAtlas で、プロジェクトの ページにGoします。

GoAtlas Searchクラスターの ページに します。

クエリ構文を表示および編集します。

インデックスの定義

エスケープ文字の例

注意

AtlasGoClustersAtlas で、プロジェクトのページにGoします。

GoAtlas Searchクラスターのページにします。