Nano Hash - криптовалюты, майнинг, программирование

Как создать лямбда-выражение Fluent DSL для ниже json

У меня есть json, где у меня есть несколько моделей и вариантов для автомобиля, и теперь нам нужно динамически создать запрос в соответствии с запросом на модель автомобиля с соответствующим вариантом. У меня есть json ниже.

Я попытался создать запрос, но не знаю, как я буду обрабатывать динамически множественный запрос модели и варианта.

var response = _esclient.EsClient().Search<ClassName>(a => a
                                .Index("Test")
                                .Type("Testa")
                                .Query(q => q.Bool(b => 
                                                   b.Must(m => m.Bool(p =>                                                                    p.Should(should => 
        should.Bool(sb => sb.Must(m3 => m3.Term(t => t.Field(classname => classname.model).Value(modelname))                                                                                    m3 => m3.Term(t => t.Field(classname => classname.model).Value(varientName)))))),                                                should => should.Bool(sb => sb.Must(m1 => m1.Term(c => c.Field(classname => classname.variant).Value(varientname)),                                                                                     m1 => m1.Term(c => c.Field(classname => classname.model).Value(modelname))))
                                                               )))))

Я создал выражение статически для двух моделей с соответствующим вариантом. но я хочу, чтобы это было динамически для любого количества моделей и связанных с ними моделей, потому что я понятия не имею, какая модель и связанный запрос варианта будут получены. Ожидаемый Json для модели 4 и соответствующий запрос варианта. Он может быть увеличен или уменьшен по запросу.

{  
  "query": {
    "bool": {
      "must": [
        {
          "bool": {
            "should": [
             {
                "bool": {
                  "must": [
                    {
                      "term": {
                        "variant": "lxi"
                      }
                    },
                    {
                      "term": {
                        "model": "ritz"
                      }
                    }
                  ]
                }
              },              
             {
                "bool": {
                  "must": [
                    {
                      "term": {
                        "variant": "lxi"
                      }
                    },
                    {
                      "term": {
                        "model": "alto"
                      }
                    }
                  ]
                }
              },
             {
                "bool": {
                  "must": [
                    {
                      "term": {
                        "variant": "lxi"
                      }
                    },
                    {
                      "term": {
                        "model": "omni"
                      }
                    }
                  ]
                }
              },
              {
                "bool": {
                  "must": [
                    {
                      "term": {
                        "variant": "vxi"
                      }
                    },
                    {
                      "term": {
                        "model": "alto 800"
                      }
                    }
                  ]
                }
              }
            ]
          }
        }       
      ]
    }
  }
}
nest elasticsearch
27.07.2019

  • Какую версию Nest вы используете? 27.07.2019
  • Использование версии Elastic search Nest 6.0. 27.07.2019

Ответы:


1

На самом деле это не вопрос Nest. Речь идет об использовании лямбда-выражений C#, которые, честно говоря, иногда могут сбивать с толку. Ниже я покажу код, который будет работать для любого количества автомобилей. Но вы должны приложить усилия, чтобы понять лямбда-выражения самостоятельно :)

internal class Program
{
    private class Car
    {
        public string Model { get; set; }
        public string Variant { get; set; }
    }

    private static void Main(string[] args)
    {
        ElasticClient esClient = new ElasticClient(new Uri("http://localhost:9200"));

        List<Car> cars = new List<Car>
        {
            new Car
            {
                Model = "ritz",
                Variant = "lxi"
            },
            new Car
            {
                Model = "alto",
                Variant = "lxi"
            },
            new Car
            {
                Model = "omni",
                Variant = "lxi"
            },
            new Car
            {
                Model = "alto 800",
                Variant = "vxi"
            }
        };

        ISearchResponse<object> response = esClient.Search<object>(a => new SearchDescriptor<object>()
            .Index("index")
            .Type("type")
            .Query(q => q
                .Bool(b => b
                    .Should(cars.Select<Car, Func<QueryContainerDescriptor<object>, QueryContainer>>(car =>
                        d => new TermQuery { Field = "variant", Value = car.Variant }
                          && new TermQuery { Field = "model", Value = car.Model })))));

    }
}

Это создаст тело поискового запроса Elasticsearch, как и то, что вы хотите.

{
    "query": {
        "bool": {
            "should": [
                {
                    "bool": {
                        "must": [
                            {
                                "term": {
                                    "variant": {
                                        "value": "lxi"
                                    }
                                }
                            },
                            {
                                "term": {
                                    "model": {
                                        "value": "ritz"
                                    }
                                }
                            }
                        ]
                    }
                },
                {
                    "bool": {
                        "must": [
                            {
                                "term": {
                                    "variant": {
                                        "value": "lxi"
                                    }
                                }
                            },
                            {
                                "term": {
                                    "model": {
                                        "value": "alto"
                                    }
                                }
                            }
                        ]
                    }
                },
                {
                    "bool": {
                        "must": [
                            {
                                "term": {
                                    "variant": {
                                        "value": "lxi"
                                    }
                                }
                            },
                            {
                                "term": {
                                    "model": {
                                        "value": "omni"
                                    }
                                }
                            }
                        ]
                    }
                },
                {
                    "bool": {
                        "must": [
                            {
                                "term": {
                                    "variant": {
                                        "value": "vxi"
                                    }
                                }
                            },
                            {
                                "term": {
                                    "model": {
                                        "value": "alto 800"
                                    }
                                }
                            }
                        ]
                    }
                }
            ]
        }
    }
}
27.07.2019
Новые материалы
Кластеризация: более глубокий взгляд
Кластеризация — это метод обучения без учителя, в котором мы пытаемся найти группы в наборе данных на основе некоторых известных или неизвестных свойств, которые могут существовать. Независимо от..
Как написать эффективное резюме
Предложения по дизайну и макету, чтобы представить себя профессионально Вам не позвонили на собеседование после того, как вы несколько раз подали заявку на работу своей мечты? У вас может..
Частный метод Python: улучшение инкапсуляции и безопасности
Введение Python — универсальный и мощный язык программирования, известный своей простотой и удобством использования. Одной из ключевых особенностей, отличающих Python от других языков, является..
Как я автоматизирую тестирование с помощью Jest
Шутка для победы, когда дело касается автоматизации тестирования Одной очень важной частью разработки программного обеспечения является автоматизация тестирования, поскольку она создает..
Работа с векторными символическими архитектурами, часть 4 (искусственный интеллект)
Hyperseed: неконтролируемое обучение с векторными символическими архитектурами (arXiv) Автор: Евгений Осипов , Сачин Кахавала , Диланта Хапутантри , Тимал Кемпития , Дасвин Де Сильва ,..
Понимание расстояния Вассерштейна: мощная метрика в машинном обучении
В обширной области машинного обучения часто возникает необходимость сравнивать и измерять различия между распределениями вероятностей. Традиционные метрики расстояния, такие как евклидово..
Обеспечение масштабируемости LLM: облачный анализ с помощью AWS Fargate и Copilot
В динамичной области искусственного интеллекта все большее распространение получают модели больших языков (LLM). Они жизненно важны для различных приложений, таких как интеллектуальные..