18338781771
584 lines
16 KiB
PHP
584 lines
16 KiB
PHP
<?php
|
||
|
||
namespace app\mzl\common\utils;
|
||
|
||
use Illuminate\Database\Eloquent\Builder;
|
||
use Illuminate\Database\Eloquent\Model;
|
||
use Illuminate\Pagination\LengthAwarePaginator;
|
||
use Illuminate\Support\Collection;
|
||
|
||
/**
|
||
* 通用查询构建器 SimpleQueryBuilder
|
||
*/
|
||
class SimpleQueryBuilder
|
||
{
|
||
protected ?Model $model = null;
|
||
protected ?Builder $query = null;
|
||
|
||
protected array $filters = [];
|
||
protected array $sorts = [];
|
||
protected array $fields = [];
|
||
protected array $relations = [];
|
||
protected array $hasRelations = [];
|
||
protected array $pagination = [
|
||
'page' => 1,
|
||
'per_page' => 10,
|
||
];
|
||
|
||
/** @var string[] 要执行 withCount 的关联 */
|
||
protected array $counts = [];
|
||
|
||
public array $allowedFields = [];
|
||
|
||
protected ?\Closure $customQueryCallback = null;
|
||
|
||
public function __construct(?Model $model = null)
|
||
{
|
||
if ($model) {
|
||
$this->setModel($model);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 设置模型
|
||
*/
|
||
public function setModel(Model $model): self
|
||
{
|
||
$this->model = $model;
|
||
$this->query = $model->newQuery();
|
||
return $this;
|
||
}
|
||
|
||
/**
|
||
* 批量应用查询配置
|
||
*
|
||
* @param array $config
|
||
* @return $this
|
||
*/
|
||
public function applyQueryConfig(array $config): self
|
||
{
|
||
foreach ($config['filters'] ?? [] as $filter) {
|
||
$this->addFilter($filter['field'], $filter['operator'], $filter['value']);
|
||
}
|
||
|
||
foreach ($config['sorts'] ?? [] as $sort) {
|
||
$this->addSort($sort['field'], $sort['direction'] ?? 'asc');
|
||
}
|
||
|
||
if (!empty($config['fields'])) {
|
||
$this->selectFields($config['fields']);
|
||
}
|
||
|
||
foreach ($config['relations'] ?? [] as $relation => $fields) {
|
||
$this->withRelation($relation, $fields);
|
||
}
|
||
|
||
foreach ($config['hasRelations'] ?? [] as $relation => $callback) {
|
||
if ($callback instanceof \Closure) {
|
||
$this->addHasRelation($relation, $callback);
|
||
}
|
||
}
|
||
|
||
// 新增：处理 counts
|
||
foreach ($config['counts'] ?? [] as $relation) {
|
||
$this->addCount($relation);
|
||
}
|
||
|
||
if (!empty($config['pagination'])) {
|
||
$this->setPagination(
|
||
$config['pagination']['page'] ?? 1,
|
||
$config['pagination']['per_page'] ?? 15
|
||
);
|
||
}
|
||
|
||
if (!empty($config['custom']) && $config['custom'] instanceof \Closure) {
|
||
$this->withCustomQuery($config['custom']);
|
||
}
|
||
|
||
return $this;
|
||
}
|
||
|
||
/**
|
||
* 添加单个过滤条件
|
||
*/
|
||
public function addFilter(string $field, string $operator, mixed $value): self
|
||
{
|
||
$this->filters[] = compact('field', 'operator', 'value');
|
||
return $this;
|
||
}
|
||
|
||
/**
|
||
* 添加排序字段
|
||
*/
|
||
public function addSort(string $field, string $direction = 'asc'): self
|
||
{
|
||
$this->sorts[$field] = strtolower($direction) === 'desc' ? 'desc' : 'asc';
|
||
return $this;
|
||
}
|
||
|
||
/**
|
||
* 设置查询字段（select），可配合 allowedFields 校验
|
||
*/
|
||
public function selectFields(array $fields): self
|
||
{
|
||
$this->fields = array_unique($fields);
|
||
return $this;
|
||
}
|
||
|
||
/**
|
||
* 加载关联（支持指定字段）
|
||
*/
|
||
public function withRelation2(string $relation, array $fields = []): self
|
||
{
|
||
$this->relations[$relation] = !empty($fields) ? $fields : '*';
|
||
return $this;
|
||
}
|
||
/**
|
||
* 加载关联（支持指定字段 或 自定义闭包）
|
||
*
|
||
* @param string $relation 关联名，支持点式多级
|
||
* @param array|\Closure $fields 字段数组 或 查询闭包
|
||
*/
|
||
public function withRelation(string $relation, $fields = []): self
|
||
{
|
||
if ($fields instanceof \Closure) {
|
||
// 自定义关联查询闭包
|
||
$this->relations[$relation] = $fields;
|
||
} else {
|
||
// 字段选择，空数组表示全部
|
||
$this->relations[$relation] = !empty($fields) ? $fields : '*';
|
||
}
|
||
return $this;
|
||
}
|
||
|
||
|
||
/**
|
||
* 添加 whereHas 条件
|
||
*/
|
||
public function addHasRelation(string $relation, \Closure $callback): self
|
||
{
|
||
$this->hasRelations[] = compact('relation', 'callback');
|
||
return $this;
|
||
}
|
||
|
||
/**
|
||
* 设置分页
|
||
*/
|
||
public function setPagination(int $page, int $perPage): self
|
||
{
|
||
$this->pagination = [
|
||
'page' => max(1, $page),
|
||
'per_page' => min(max(1, $perPage), 100),
|
||
];
|
||
return $this;
|
||
}
|
||
|
||
/**
|
||
* 注入复杂查询闭包（适合业务层扩展）
|
||
*/
|
||
public function withCustomQuery(\Closure $callback): self
|
||
{
|
||
$this->customQueryCallback = $callback;
|
||
return $this;
|
||
}
|
||
|
||
/**
|
||
* 添加关联数量统计 (withCount)
|
||
*
|
||
* @param string $relation 关联名，支持点式多层，如 "orders.items"
|
||
* @return $this
|
||
*/
|
||
public function addCount(string $relation): self
|
||
{
|
||
$this->counts[] = $relation;
|
||
return $this;
|
||
}
|
||
|
||
/**
|
||
* 构建完整查询（不执行）
|
||
*/
|
||
public function build(): Builder
|
||
{
|
||
if (!$this->query && $this->model) {
|
||
$this->query = $this->model->newQuery();
|
||
}
|
||
|
||
$this->applyFilters()
|
||
->applySorts()
|
||
->applyFields()
|
||
->applyRelations()
|
||
->applyWhereHas();
|
||
|
||
// ========== 新增：关联计数 ==========
|
||
if (!empty($this->counts)) {
|
||
// Laravel 支持 withCount(['rel1','rel2'])
|
||
$this->query->withCount($this->counts);
|
||
}
|
||
|
||
if ($this->customQueryCallback) {
|
||
call_user_func($this->customQueryCallback, $this->query);
|
||
}
|
||
|
||
return $this->query;
|
||
}
|
||
|
||
/**
|
||
* 获取集合（不分页）
|
||
*/
|
||
public function get(): Collection
|
||
{
|
||
return $this->build()->get();
|
||
}
|
||
|
||
/**
|
||
* 获取分页结果
|
||
*/
|
||
public function paginate(): LengthAwarePaginator
|
||
{
|
||
return $this->build()->paginate(
|
||
$this->pagination['per_page'],
|
||
['*'],
|
||
'page',
|
||
$this->pagination['page']
|
||
);
|
||
}
|
||
|
||
/**
|
||
* 应用过滤
|
||
*/
|
||
protected function applyFilters(): self
|
||
{
|
||
foreach ($this->filters as $filter) {
|
||
$field = $filter['field'];
|
||
$operator = $filter['operator'];
|
||
$value = $filter['value'];
|
||
|
||
if (str_contains($field, '.')) {
|
||
$segments = explode('.', $field);
|
||
$relationPath = implode('.', array_slice($segments, 0, -1));
|
||
$lastField = end($segments);
|
||
|
||
$this->query->whereHas($relationPath, function (Builder $q) use ($lastField, $operator, $value) {
|
||
$this->applyCondition($q, $lastField, $operator, $value);
|
||
});
|
||
} else {
|
||
$this->applyCondition($this->query, $field, $operator, $value);
|
||
}
|
||
}
|
||
|
||
return $this;
|
||
}
|
||
|
||
/**
|
||
* 应用排序
|
||
*/
|
||
protected function applySorts(): self
|
||
{
|
||
foreach ($this->sorts as $field => $direction) {
|
||
$this->query->orderBy($field, $direction);
|
||
}
|
||
return $this;
|
||
}
|
||
|
||
/**
|
||
* 应用字段选择
|
||
*/
|
||
// protected function applyFields2(): self
|
||
// {
|
||
// if (!empty($this->fields)) {
|
||
// // 排除关联字段（如 class.teacher.realname）
|
||
// $fields = array_filter($this->fields, fn($field) => !str_contains($field, '.'));
|
||
|
||
// // 白名单过滤
|
||
// $fields = !empty($this->allowedFields)
|
||
// ? array_intersect($fields, $this->allowedFields)
|
||
// : $fields;
|
||
|
||
// if (empty($fields)) {
|
||
// throw new \InvalidArgumentException('字段选择无效');
|
||
// }
|
||
|
||
// $this->query->select(array_unique($fields));
|
||
// }
|
||
|
||
// return $this;
|
||
// }
|
||
|
||
/**
|
||
* 应用字段选择，支持普通列和带 alias 的 Raw 表达式
|
||
*/
|
||
protected function applyFields(): self
|
||
{
|
||
if (empty($this->fields)) {
|
||
return $this;
|
||
}
|
||
|
||
// 只保留主表字段（排除带点的关联字段）
|
||
$cols = array_filter($this->fields, fn($f) => ! str_contains($f, '.'));
|
||
|
||
// 如果设置了 allowedFields，做一次白名单交集
|
||
if (! empty($this->allowedFields)) {
|
||
$cols = array_intersect($cols, $this->allowedFields);
|
||
}
|
||
|
||
if (empty($cols)) {
|
||
throw new \InvalidArgumentException('字段选择无效');
|
||
}
|
||
|
||
$plain = [];
|
||
$raws = [];
|
||
|
||
foreach ($cols as $col) {
|
||
// 简单判断带 “ as ” 的就归到 Raw
|
||
if (preg_match('/\s+as\s+/i', $col)) {
|
||
$raws[] = $col;
|
||
} else {
|
||
$plain[] = $col;
|
||
}
|
||
}
|
||
|
||
// 先 select 普通列
|
||
if ($plain) {
|
||
$this->query->select($plain);
|
||
}
|
||
// 再 selectRaw alias
|
||
if ($raws) {
|
||
// 注意：selectRaw 接受一整个字符串
|
||
$this->query->selectRaw(implode(', ', $raws));
|
||
}
|
||
|
||
return $this;
|
||
}
|
||
|
||
/**
|
||
* 应用关联加载，支持 dot-notation 多级关联
|
||
*/
|
||
// protected function applyRelations2(): self
|
||
// {
|
||
// if (empty($this->relations)) {
|
||
// return $this;
|
||
// }
|
||
|
||
// $with = [];
|
||
// foreach ($this->relations as $path => $fields) {
|
||
// $with[$path] = function ($q) use ($fields) {
|
||
// if ($fields === '*' || empty($fields)) {
|
||
// return;
|
||
// }
|
||
// // 保证 id 在内
|
||
// $model = $q->getModel();
|
||
// $key = $model->getKeyName();
|
||
// $q->select(array_merge([$key], $fields));
|
||
// };
|
||
// }
|
||
|
||
// $this->query->with($with);
|
||
|
||
// return $this;
|
||
// }
|
||
|
||
/**
|
||
* 应用多级关联加载，支持给关联字段加 alias
|
||
*/
|
||
protected function applyRelations2(): self
|
||
{
|
||
if (empty($this->relations)) {
|
||
return $this;
|
||
}
|
||
|
||
$with = [];
|
||
foreach ($this->relations as $path => $fields) {
|
||
$with[$path] = function ($q) use ($fields) {
|
||
if ($fields === '*' || empty($fields)) {
|
||
return;
|
||
}
|
||
|
||
// 模型主键一定要带上
|
||
$model = $q->getModel();
|
||
$key = $model->getKeyName();
|
||
|
||
$plain = [];
|
||
$raws = [];
|
||
|
||
foreach ($fields as $col) {
|
||
if (preg_match('/\s+as\s+/i', $col)) {
|
||
$raws[] = $col;
|
||
} else {
|
||
$plain[] = $col;
|
||
}
|
||
}
|
||
|
||
// 确保主键至少出现一次
|
||
if (! in_array($key, $plain, true)) {
|
||
array_unshift($plain, $key);
|
||
}
|
||
|
||
// select 普通列
|
||
if ($plain) {
|
||
$q->select($plain);
|
||
}
|
||
// selectRaw 带 alias 的列
|
||
if ($raws) {
|
||
$q->selectRaw(implode(', ', $raws));
|
||
}
|
||
};
|
||
}
|
||
|
||
$this->query->with($with);
|
||
return $this;
|
||
}
|
||
/**
|
||
* 应用多级关联加载，支持字段数组或直接传入闭包
|
||
*/
|
||
protected function applyRelations(): self
|
||
{
|
||
if (empty($this->relations)) {
|
||
return $this;
|
||
}
|
||
|
||
$with = [];
|
||
foreach ($this->relations as $path => $handler) {
|
||
if ($handler instanceof \Closure) {
|
||
// 直接使用用户传入的闭包
|
||
$with[$path] = $handler;
|
||
} else {
|
||
// 按字段数组构造查询
|
||
$fields = $handler;
|
||
$with[$path] = function ($q) use ($fields) {
|
||
if ($fields === '*' || empty($fields)) {
|
||
return;
|
||
}
|
||
// 确保主键被选中
|
||
$model = $q->getModel();
|
||
$key = $model->getKeyName();
|
||
|
||
$plain = [];
|
||
$raws = [];
|
||
foreach ($fields as $col) {
|
||
if (preg_match('/\s+as\s+/i', $col)) {
|
||
$raws[] = $col;
|
||
} else {
|
||
$plain[] = $col;
|
||
}
|
||
}
|
||
if (! in_array($key, $plain, true)) {
|
||
array_unshift($plain, $key);
|
||
}
|
||
|
||
if ($plain) {
|
||
$q->select($plain);
|
||
}
|
||
if ($raws) {
|
||
$q->selectRaw(implode(', ', $raws));
|
||
}
|
||
};
|
||
}
|
||
}
|
||
|
||
$this->query->with($with);
|
||
return $this;
|
||
}
|
||
|
||
|
||
/**
|
||
* 应用 whereHas 关联过滤
|
||
*/
|
||
protected function applyWhereHas(): self
|
||
{
|
||
foreach ($this->hasRelations as $relationData) {
|
||
$this->query->whereHas($relationData['relation'], $relationData['callback']);
|
||
}
|
||
return $this;
|
||
}
|
||
|
||
/**
|
||
* 应用单个过滤条件
|
||
*/
|
||
protected function applyCondition(Builder $query, string $field, string $operator, mixed $value): void
|
||
{
|
||
switch (strtolower($operator)) {
|
||
case 'between':
|
||
$query->whereBetween($field, (array)$value);
|
||
break;
|
||
case 'like':
|
||
$query->where($field, 'LIKE', "%{$value}%");
|
||
break;
|
||
case 'in':
|
||
$query->whereIn($field, (array)$value);
|
||
break;
|
||
case 'not_in':
|
||
$query->whereNotIn($field, (array)$value);
|
||
break;
|
||
case 'null':
|
||
$query->whereNull($field);
|
||
break;
|
||
case 'not_null':
|
||
$query->whereNotNull($field);
|
||
break;
|
||
default:
|
||
$query->where($field, $operator, $value);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 根据 queryConfig 构造 fieldsMap
|
||
* - 兼容 "col as alias"
|
||
* - 自动把 counts 生成的 xxx_count 加入根字段
|
||
*
|
||
* @param array $config 完整的 applyQueryConfig 输入
|
||
* @return array [''=>[主表字段…], 'relation'=>[字段…], …]
|
||
*/
|
||
public static function buildFieldsMap(array $config): array
|
||
{
|
||
$relations = $config['relations'] ?? [];
|
||
$counts = $config['counts'] ?? [];
|
||
$rawFields = $config['fields'] ?? [];
|
||
|
||
// 1) 根层字段：拆 alias + 自动加 count + 加顶级关联名
|
||
$root = [];
|
||
foreach ($rawFields as $f) {
|
||
if (preg_match('/\s+as\s+/i', $f)) {
|
||
[, $alias] = preg_split('/\s+as\s+/i', $f);
|
||
$root[] = $alias;
|
||
} else {
|
||
$root[] = $f;
|
||
}
|
||
}
|
||
// 把 withCount 生成的字段也加进来
|
||
foreach ($counts as $rel) {
|
||
$root[] = "{$rel}_count";
|
||
}
|
||
// 顶级关联名
|
||
foreach (array_keys($relations) as $path) {
|
||
$root[] = explode('.', $path, 2)[0];
|
||
}
|
||
$fieldsMap = ['' => array_values(array_unique($root))];
|
||
|
||
// 2) 每个关联：拆 alias + 加直接子关联
|
||
foreach ($relations as $path => $rawCols) {
|
||
$arr = [];
|
||
$segments = explode('.', $path);
|
||
$depth = count($segments);
|
||
// 拆 alias
|
||
foreach ($rawCols as $col) {
|
||
if (preg_match('/\s+as\s+/i', $col)) {
|
||
[, $alias] = preg_split('/\s+as\s+/i', $col);
|
||
$arr[] = $alias;
|
||
} else {
|
||
$arr[] = $col;
|
||
}
|
||
}
|
||
// 子关联名
|
||
if ($depth > 1) {
|
||
for ($i = 1; $i < $depth; $i++) {
|
||
$parent = implode('.', array_slice($segments, 0, $i));
|
||
$child = $segments[$i];
|
||
$fieldsMap[$parent][] = $child;
|
||
}
|
||
}
|
||
$fieldsMap[$path] = array_values(array_unique($arr));
|
||
}
|
||
|
||
return $fieldsMap;
|
||
}
|
||
} |