As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Usar a pesquisa de texto completo do Neptune em consultas do Gremlin
O `NeptuneSearchStep` permite consultas de pesquisa de texto completo para a parte de uma travessia do Gremlin que não é convertida em etapas do Neptune. Por exemplo, considere uma consulta como a seguinte.
```
g.withSideEffect("Neptune#fts.endpoint", "your-es-endpoint-URL")
.V()
.tail(100)
.has("name", "Neptune#fts mark*") <== # Limit the search on name
```
Esta consulta é convertida no percurso a seguir no Neptune.
```
Neptune steps:
[
NeptuneGraphQueryStep(Vertex) {
JoinGroupNode {
PatternNode[(?1, <~label>, ?2, <~>) . project distinct ?1 .], {estimatedCardinality=INFINITY}
}, annotations={path=[Vertex(?1):GraphStep], maxVarId=4}
},
NeptuneTraverserConverterStep
]
+ not converted into Neptune steps: [NeptuneTailGlobalStep(100), NeptuneTinkerpopTraverserConverterStep, NeptuneSearchStep {
JoinGroupNode {
SearchNode[(idVar=?3, query=mark*, field=name) . project ask .], {endpoint=your-OpenSearch-endpoint-URL}
}
JoinGroupNode {
SearchNode[(idVar=?3, query=mark*, field=name) . project ask .], {endpoint=your-OpenSearch-endpoint-URL}
}
}]
```
Os exemplos a seguir são das consultas do Gremlin em relação a dados de rotas aéreas:
## Consulta `match` sem distinção de maiúsculas ou minúsculas do Gremlin
```
g.withSideEffect("Neptune#fts.endpoint",
"your-OpenSearch-endpoint-URL")
.withSideEffect('Neptune#fts.queryType', 'match')
.V().has("city","Neptune#fts dallas")
==>v[186]
==>v[8]
```
## Consulta `match` do Gremlin
```
g.withSideEffect("Neptune#fts.endpoint",
"your-OpenSearch-endpoint-URL")
.withSideEffect('Neptune#fts.queryType', 'match')
.V().has("city","Neptune#fts southampton")
.local(values('code','city').fold())
.limit(5)
==>[SOU, Southampton]
```
## Consulta `fuzzy` do Gremlin
```
g.withSideEffect("Neptune#fts.endpoint",
"your-OpenSearch-endpoint-URL")
.V().has("city","Neptune#fts allas~").values('city').limit(5)
==>Dallas
==>Dallas
==>Walla Walla
==>Velas
==>Altai
```
## Consulta difusa `query_string` do Gremlin
```
g.withSideEffect("Neptune#fts.endpoint",
"your-OpenSearch-endpoint-URL")
.withSideEffect('Neptune#fts.queryType', 'query_string')
.V().has("city","Neptune#fts allas~").values('city').limit(5)
==>Dallas
==>Dallas
```
## Consulta de expressão regular `query_string` do Gremlin
```
g.withSideEffect("Neptune#fts.endpoint",
"your-OpenSearch-endpoint-URL")
.withSideEffect('Neptune#fts.queryType', 'query_string')
.V().has("city","Neptune#fts /[dp]allas/").values('city').limit(5)
==>Dallas
==>Dallas
```
## Consulta híbrida do Gremlin
Essa consulta usa um índice interno do Neptune e OpenSearch o índice na mesma consulta.
```
g.withSideEffect("Neptune#fts.endpoint",
"your-OpenSearch-endpoint-URL")
.V().has("region","GB-ENG")
.has('city','Neptune#fts L*')
.values('city')
.dedup()
.limit(10)
==>London
==>Leeds
==>Liverpool
==>Land's End
```
## Exemplo de pesquisa de texto completo simples do Gremlin
```
g.withSideEffect("Neptune#fts.endpoint",
"your-OpenSearch-endpoint-URL")
.V().has('desc','Neptune#fts regional municipal')
.local(values('code','desc').fold())
.limit(100)
==>[HYA, Barnstable Municipal Boardman Polando Field]
==>[SPS, Sheppard Air Force Base-Wichita Falls Municipal Airport]
==>[ABR, Aberdeen Regional Airport]
==>[SLK, Adirondack Regional Airport]
==>[BFD, Bradford Regional Airport]
==>[EAR, Kearney Regional Airport]
==>[ROT, Rotorua Regional Airport]
==>[YHD, Dryden Regional Airport]
==>[TEX, Telluride Regional Airport]
==>[WOL, Illawarra Regional Airport]
==>[TUP, Tupelo Regional Airport]
==>[COU, Columbia Regional Airport]
==>[MHK, Manhattan Regional Airport]
==>[BJI, Bemidji Regional Airport]
==>[HAS, Hail Regional Airport]
==>[ALO, Waterloo Regional Airport]
==>[SHV, Shreveport Regional Airport]
==>[ABI, Abilene Regional Airport]
==>[GIZ, Jizan Regional Airport]
==>[USA, Concord Regional Airport]
==>[JMS, Jamestown Regional Airport]
==>[COS, City of Colorado Springs Municipal Airport]
==>[PKB, Mid Ohio Valley Regional Airport]
```
## Consulta do Gremlin usando `query_string` com operadores “\$1” e “-”
Embora o tipo de consulta `query_string` seja muito menos tolerante que o tipo `simple_query_string` padrão, ele não permite consultas mais precisas. A primeira consulta abaixo usa `query_string`, enquanto a segunda usa o padrão `simple_query_string`:
```
g.withSideEffect("Neptune#fts.endpoint",
"your-OpenSearch-endpoint-URL")
.withSideEffect('Neptune#fts.queryType', 'query_string')
. V().has('desc','Neptune#fts +London -(Stansted|Gatwick)')
.local(values('code','desc').fold())
.limit(10)
==>[LHR, London Heathrow]
==>[YXU, London Airport]
==>[LTN, London Luton Airport]
==>[SEN, London Southend Airport]
==>[LCY, London City Airport]
```
Observe como `simple_query_string` nos exemplos abaixo ignora silenciosamente os operadores “\$1” e “-”:
```
g.withSideEffect("Neptune#fts.endpoint",
"your-OpenSearch-endpoint-URL")
.V().has('desc','Neptune#fts +London -(Stansted|Gatwick)')
.local(values('code','desc').fold())
.limit(10)
==>[LHR, London Heathrow]
==>[YXU, London Airport]
==>[LGW, London Gatwick]
==>[STN, London Stansted Airport]
==>[LTN, London Luton Airport]
==>[SEN, London Southend Airport]
==>[LCY, London City Airport]
==>[SKG, Thessaloniki Macedonia International Airport]
==>[ADB, Adnan Menderes International Airport]
==>[BTV, Burlington International Airport]
```
```
g.withSideEffect("Neptune#fts.endpoint",
"your-OpenSearch-endpoint-URL")
.withSideEffect('Neptune#fts.queryType', 'query_string')
.V().has('desc','Neptune#fts +(regional|municipal) -(international|bradford)')
.local(values('code','desc').fold())
.limit(10)
==>[CZH, Corozal Municipal Airport]
==>[MMU, Morristown Municipal Airport]
==>[YBR, Brandon Municipal Airport]
==>[RDD, Redding Municipal Airport]
==>[VIS, Visalia Municipal Airport]
==>[AIA, Alliance Municipal Airport]
==>[CDR, Chadron Municipal Airport]
==>[CVN, Clovis Municipal Airport]
==>[SDY, Sidney Richland Municipal Airport]
==>[SGU, St George Municipal Airport]
```
## Consulte `query_string` do Gremlin com operadores `AND` e `OR`
```
g.withSideEffect("Neptune#fts.endpoint",
"your-OpenSearch-endpoint-URL")
.withSideEffect('Neptune#fts.queryType', 'query_string')
.V().has('desc','Neptune#fts (St AND George) OR (St AND Augustin)')
.local(values('code','desc').fold())
.limit(10)
==>[YIF, St Augustin Airport]
==>[STG, St George Airport]
==>[SGO, St George Airport]
==>[SGU, St George Municipal Airport]
```
## Consulta `term` do Gremlin
```
g.withSideEffect("Neptune#fts.endpoint",
"your-OpenSearch-endpoint-URL")
.withSideEffect('Neptune#fts.queryType', 'term')
.V().has("SKU","Neptune#fts ABC123DEF9")
.local(values('code','city').fold())
.limit(5)
==>[AUS, Austin]
```
## Consulta `prefix` do Gremlin
```
g.withSideEffect("Neptune#fts.endpoint",
"your-OpenSearch-endpoint-URL")
.withSideEffect('Neptune#fts.queryType', 'prefix')
.V().has("icao","Neptune#fts ka")
.local(values('code','icao','city').fold())
.limit(5)
==>[AZO, KAZO, Kalamazoo]
==>[APN, KAPN, Alpena]
==>[ACK, KACK, Nantucket]
==>[ALO, KALO, Waterloo]
==>[ABI, KABI, Abilene]
```
## Usar a sintaxe Lucene em Gremlin no Neptune
No Gremlin no Neptune, também é possível gravar consultas muito avançadas usando a sintaxe de consulta Lucene. Observe que a sintaxe do Lucene só é suportada para `query_string` consultas em. OpenSearch
Suponha os seguintes dados:
```
g.addV("person")
.property(T.id, "p1")
.property("name", "simone")
.property("surname", "rondelli")
g.addV("person")
.property(T.id, "p2")
.property("name", "simone")
.property("surname", "sengupta")
g.addV("developer")
.property(T.id, "p3")
.property("name", "simone")
.property("surname", "rondelli")
```
Usando a sintaxe Lucene, que é invocada quando `queryType` for `query_string`, é possível pesquisar esses dados por nome e sobrenome da seguinte forma:
```
g.withSideEffect("Neptune#fts.endpoint", "es_endpoint")
.withSideEffect("Neptune#fts.queryType", "query_string")
.V()
.has("*", "Neptune#fts predicates.name.value:simone AND predicates.surname.value:rondelli")
==> v[p1], v[p3]
```
Observe que na etapa `has()` acima, o campo é substituído por `"*"`). Na verdade, qualquer valor inserido aqui será substituído pelos campos que você acessar na consulta. Acesse o campo do nome usando `predicates.name.value,` porque é como o modelo de dados é estruturado.
É possível pesquisar por nome, sobrenome e rótulo da seguinte forma:
```
g.withSideEffect("Neptune#fts.endpoint", getEsEndpoint())
.withSideEffect("Neptune#fts.queryType", "query_string")
.V()
.has("*", "Neptune#fts predicates.name.value:simone AND predicates.surname.value:rondelli AND entity_type:person")
==> v[p1]
```
O rótulo é acessado usando `entity_type`, novamente porque é como o modelo de dados é estruturado.
Também é possível incluir condições de aninhamento:
```
g.withSideEffect("Neptune#fts.endpoint", getEsEndpoint())
.withSideEffect("Neptune#fts.queryType", "query_string")
.V()
.has("*", "Neptune#fts (predicates.name.value:simone AND predicates.surname.value:rondelli AND entity_type:person) OR predicates.surname.value:sengupta")
==> v[p1], v[p2]
```
## Inserindo um gráfico moderno TinkerPop
```
g.addV('person').property(T.id, '1').property('name', 'marko').property('age', 29)
.addV('personr').property(T.id, '2').property('name', 'vadas').property('age', 27)
.addV('software').property(T.id, '3').property('name', 'lop').property('lang', 'java')
.addV('person').property(T.id, '4').property('name', 'josh').property('age', 32)
.addV('software').property(T.id, '5').property('name', 'ripple').property('lang', 'java')
.addV('person').property(T.id, '6').property('name', 'peter').property('age', 35)
g.V('1').as('a').V('2').as('b').addE('knows').from('a').to('b').property('weight', 0.5f).property(T.id, '7')
.V('1').as('a').V('3').as('b').addE('created').from('a').to('b').property('weight', 0.4f).property(T.id, '9')
.V('4').as('a').V('3').as('b').addE('created').from('a').to('b').property('weight', 0.4f).property(T.id, '11')
.V('4').as('a').V('5').as('b').addE('created').from('a').to('b').property('weight', 1.0f).property(T.id, '10')
.V('6').as('a').V('3').as('b').addE('created').from('a').to('b').property('weight', 0.2f).property(T.id, '12')
.V('1').as('a').V('4').as('b').addE('knows').from('a').to('b').property('weight', 1.0f).property(T.id, '8')
```
## Exemplo de valor do campo de classificação por string
```
g.withSideEffect("Neptune#fts.endpoint", "your-OpenSearch-endpoint-URL")
.withSideEffect('Neptune#fts.queryType', 'query_string')
.withSideEffect('Neptune#fts.sortOrder', 'asc')
.withSideEffect('Neptune#fts.sortBy', 'name')
.V().has('name', 'Neptune#fts marko OR vadas OR ripple')
```
## Exemplo de valor do campo de classificação sem string
```
g.withSideEffect("Neptune#fts.endpoint", "your-OpenSearch-endpoint-URL")
.withSideEffect('Neptune#fts.queryType', 'query_string')
.withSideEffect('Neptune#fts.sortOrder', 'asc')
.withSideEffect('Neptune#fts.sortBy', 'age.value')
.V().has('name', 'Neptune#fts marko OR vadas OR ripple')
```
## Exemplo de valor do campo de classificação por ID
```
g.withSideEffect("Neptune#fts.endpoint", "your-OpenSearch-endpoint-URL")
.withSideEffect('Neptune#fts.queryType', 'query_string')
.withSideEffect('Neptune#fts.sortOrder', 'asc')
.withSideEffect('Neptune#fts.sortBy', 'Neptune#fts.entity_id')
.V().has('name', 'Neptune#fts marko OR vadas OR ripple')
```
## Exemplo de valor do campo de classificação por rótulo
```
g.withSideEffect("Neptune#fts.endpoint", "your-OpenSearch-endpoint-URL")
.withSideEffect('Neptune#fts.queryType', 'query_string')
.withSideEffect('Neptune#fts.sortOrder', 'asc')
.withSideEffect('Neptune#fts.sortBy', 'Neptune#fts.entity_type')
.V().has('name', 'Neptune#fts marko OR vadas OR ripple')
```
## Exemplo de valor do campo de classificação por `document_type`
```
g.withSideEffect("Neptune#fts.endpoint", "your-OpenSearch-endpoint-URL")
.withSideEffect('Neptune#fts.queryType', 'query_string')
.withSideEffect('Neptune#fts.sortOrder', 'asc')
.withSideEffect('Neptune#fts.sortBy', 'Neptune#fts.document_type')
.V().has('name', 'Neptune#fts marko OR vadas OR ripple')
```