Add via query

If you want to add a collection of models to the search index via the Eloquent query builder, you can also chain the searchable method on the Eloquent query builder. searchable will chunk the constructor's query results and add the records to your search index. Likewise, if you have configured Scout to use a queue, all data chunks will be added in the background by your queue worker process:

// 通过 Eloquent 查询构造器增加..
App\Order::where('price', '>', 100)->searchable();
// 你也可以通过模型关系增加记录...
$user->orders()->searchable();
// 你也可以通过集合增加记录...
$orders->searchable();

searchable method can be thought of as an "update" Insert" operation. In other words, if the model record is already in your index, it will be updated. If it does not exist in the search index, it is added to the index.

Update Record

To update a searchable model, simply update the properties of the model instance and add the modelsave to database. Scout will automatically sync updates to your search index:

$order = App\Order::find(1);
// 更新订单...
$order->save();

You can also use the searchable method on an Eloquent query to update a collection of models. If this model does not exist in the index you are searching for, it will be created:

// 通过 Eloquent 查询更新...
App\Order::where('price', '>', 100)->searchable();
// 你也可以通过数据间的关联进行更新...
$user->orders()->searchable();
// 你也可以通过数据集合进行更新...
$orders->searchable();

Delete record

Use delete Delete the model from the database to remove the records in the index. This form of deletion is even compatible with the soft-delete model:

$order = App\Order::find(1);
$order->delete();

If you do not want the record to be retrieved before deletion, you can use the unsearchable method on the Eloquent query instance or collection:

// 通过 Eloquent 查询删除...
App\Order::where('price', '>', 100)->unsearchable();
//  你可以通过数据间的关系进行删除...
$user->orders()->unsearchable();
// 你可以通过数据集合进行删除...
$orders->unsearchable();

withoutSyncingToSearch method to do this. This method accepts a callback that is executed immediately. All operations in this callback will not be synchronized to the model index:

App\Order::withoutSyncingToSearch(function () { 
   // 执行模型操作...
  });

Sometimes you may need a model to be searchable under certain conditions. For example, let's say you have an

model that can be in one of two states: "Draft" or "Published". You may only allow searches for "published" posts. To achieve this, you need to define a shouldBeSearchable method in your model:

public function shouldBeSearchable(){
    return $this->isPublished();
   }

method, query, or associated model shouldBeSearchable method. Using the searchable method directly will cause the model or collection's searchable results to override the results of the shouldBeSearchable method:

// 此处将遵循 "shouldBeSearchable" 结果...
App\Order::where('price', '>', 100)->searchable();
$user->orders()->searchable();$order->save();
// 此处将覆盖 "shouldBeSearchable" 结果...
$orders->searchable();
$order->searchable();

Search

You can use the search method to search for models. The search method accepts a string to search for the model. You also need to chain the get method on the search query to query for a matching Eloquent model with a given search statement:

$orders = App\Order::search('Star Trek')->get();

Scout search returns a collection of Eloquent models, so You can return results directly from a route or controller, and they will be automatically converted to JSON format:

use Illuminate\Http\Request;
Route::get('/search', function (Request $request) {
    return App\Order::search($request->search)->get();
   });

If you want to get the original results before they are returned to the Eloquent model, you should use raw Methods:

$orders = App\Order::search('Star Trek')->raw();

Search queries are typically executed on the index specified by the model's searchableAs method. Of course, you can also specify a custom index that should be searched using the within method:

$orders = App\Order::search('Star Trek') 
   ->within('tv_shows_popularity_desc')    
   ->get();

Where statement

Allows you to add simple "where" statements to search queries. Currently, these statements only support basic numerical equality checks and are primarily intended for range search queries based on tenant IDs. Since the search index is not a relational database, the more advanced "where" statements are not currently supported:

$orders = App\Order::search('Star Trek')->where('user_id', 1)->get();

paginate method to paginate search results. This method returns a Paginator instance just like traditional Eloquent query pagination:

$orders = App\Order::search('Star Trek')->paginate();

paginate method To specify how many models to retrieve for each page:

$orders = App\Order::search('Star Trek')->paginate(15);

<div class="container">
    @foreach ($orders as $order) 
           {{ $order->price }}
    @endforeach
    </div>
  {{ $orders->links() }}

config The value of the soft_delete option in /scout.php configuration file is true:

'soft_delete' => true,

true , Scout does not remove soft-deleted models from the search index. Instead, it sets a hidden __soft_deleted attribute in the index record. Then, when searching, you can use the withTrashed or onlyTrashed method to retrieve soft deleted records:

// 搜索结果包括已删除的记录...
$orders = App\Order::withTrashed()->search('Star Trek')->get();
// 搜索结果只含已删除的记录...
$orders = App\Order::onlyTrashed()->search('Star Trek')->get();

{Tip} To permanently delete the model, use

forceDelete to delete, Scout will automatically remove the model from the search index.

use Algolia\AlgoliaSearch\SearchIndex;
App\Order::search('Star Trek', function (SearchIndex $algolia, string $query, array $options) {
    $options['body']['query']['bool']['filter']['geo_distance'] = [
            'distance' => '1000km',        
            'location' => ['lat' => 36, 'lon' => 111],  
          ];    
     return $algolia->search($query, $options);
  })->get();

use Laravel\Scout\Builder;
abstract public function update($models);
abstract public function delete($models);
abstract public function search(Builder $builder);
abstract public function paginate(Builder $builder, $perPage, $page);
abstract public function mapIds($results);
abstract public function map($results, $model);
abstract public function getTotalCount($results);
abstract public function flush($model);

use Laravel\Scout\EngineManager;
/**
 * 启动任何的服务
 *
 * @return void
 */
 public function boot(){ 
    resolve(EngineManager::class)->extend('mysql', function () {
            return new MySqlSearchEngine;   
         });
      }

'driver' => 'mysql',

<?php
    namespace App\Providers;
    use Laravel\Scout\Builder;
    use Illuminate\Support\ServiceProvider;
    use Illuminate\Support\Facades\Response;
    class ScoutMacroServiceProvider extends ServiceProvider{  
      /**
     * 注册应用的Scout 宏命令.
     *
     * @return void
     */  
       public function boot()  
         {     
            Builder::macro('count', function () {
                 return $this->engine->getTotalCount(           
                      $this->engine()->search($this)    
                           );     
                     });   
           }
        }

App\Order::search('Star Trek')->count();