为了在graphql服务器中使用,我定义了一种结构化的输入类型,您可以在其中指定许多过滤条件,这些条件与棱镜的工作方式非常相似:
这允许我在查询中提交结构化过滤器,例如:
{
users(
where: {
OR: [{ email: { starts_with: "ja" } }, { email: { ends_with: ".com" } }],
AND: [{ email: { starts_with: "ja" } }, { email: { ends_with: ".com" } }],
email: {contains: "lowe"}
}
) {
id
email
}
}
在我的解析器内部,我通过函数解析结构并使用TypeOrm的查询生成器将args.where转换为适当的sql。该功能的全部是:
import { Brackets } from "typeorm";
export const filterQuery = (query: any, where: any) => {
if (!where) {
return query;
}
Object.keys(where).forEach(key => {
if (key === "OR") {
where[key].map((queryArray: any) => {
query.orWhere(new Brackets(qb => filterQuery(qb, queryArray)));
});
} else if (key === "AND") {
where[key].map((queryArray: any) => {
query.andWhere(new Brackets(qb => filterQuery(qb, queryArray)));
});
} else {
const whereArgs = Object.entries(where);
whereArgs.map(whereArg => {
const [fieldName, filters] = whereArg;
const ops = Object.entries(filters);
ops.map(parameters => {
const [operation, value] = parameters;
switch (operation) {
case "is": {
query.andWhere(`${fieldName} = :isvalue`, { isvalue: value });
break;
}
case "not": {
query.andWhere(`${fieldName} != :notvalue`, { notvalue: value });
break;
}
case "in": {
query.andWhere(`${fieldName} IN :invalue`, { invalue: value });
break;
}
case "not_in": {
query.andWhere(`${fieldName} NOT IN :notinvalue`, {
notinvalue: value
});
break;
}
case "lt": {
query.andWhere(`${fieldName} < :ltvalue`, { ltvalue: value });
break;
}
case "lte": {
query.andWhere(`${fieldName} <= :ltevalue`, { ltevalue: value });
break;
}
case "gt": {
query.andWhere(`${fieldName} > :gtvalue`, { gtvalue: value });
break;
}
case "gte": {
query.andWhere(`${fieldName} >= :gtevalue`, { gtevalue: value });
break;
}
case "contains": {
query.andWhere(`${fieldName} ILIKE :convalue`, {
convalue: `%${value}%`
});
break;
}
case "not_contains": {
query.andWhere(`${fieldName} NOT ILIKE :notconvalue`, {
notconvalue: `%${value}%`
});
break;
}
case "starts_with": {
query
.andWhere(`${fieldName} ILIKE :swvalue`)
.setParameter("swvalue", `${value}%`);
break;
}
case "not_starts_with": {
query
.andWhere(`${fieldName} NOT ILIKE :nswvalue`)
.setParameter("nswvalue", `${value}%`);
break;
}
case "ends_with": {
query.andWhere(`${fieldName} ILIKE :ewvalue`, {
ewvalue: `%${value}`
});
break;
}
case "not_ends_with": {
query.andWhere(`${fieldName} ILIKE :newvalue`, {
newvalue: `%${value}`
});
break;
}
default: {
break;
}
}
});
});
}
});
return query;
};
哪个可以工作(有点大),但是不会像我期望的那样嵌套AND / OR查询(并且以前在KNEX中工作)。上面的函数生成SQL:
SELECT "user"."id" AS "user_id", "user"."name" AS "user_name", "user"."email" AS "user_email", "user"."loginToken" AS "user_loginToken", "user"."loginTokenExpiry" AS "user_loginTokenExpiry", "user"."active" AS "user_active", "user"."visible" AS "user_visible", "user"."isStaff" AS "user_isStaff", "user"."isBilling" AS "user_isBilling", "user"."createdAt" AS "user_createdAt", "user"."updatedAt" AS "user_updatedAt", "user"."version" AS "user_version" FROM "user" "user" WHERE (email ILIKE $1) AND (email ILIKE $2) OR (email ILIKE $3) OR (email ILIKE $4) AND email ILIKE $5 -- PARAMETERS: ["ja%","%.com","ja%","%.com","%lowe%"]
但是我希望看到更多类似的东西:
.....
WHERE email ILIKE '%low%'
AND (
email ILIKE 'ja%' AND email ILIKE '%.com'
) AND (
email ILIKE 'ja%' OR email ILIKE '%.com'
)
原谅废话,重复的查询。我只是想说明预期的NESTED语句。
如何强制查询构建器函数的AND / OR分支正确嵌套,如预期的那样?
**如果有人可以帮助我在这里找出实际的打字稿打字,则可获得加分**
答案 0 :(得分:2)
import { Brackets, WhereExpression, SelectQueryBuilder } from "typeorm";
interface FieldOptions {
starts_with?: string;
ends_with?: string;
contains?: string;
}
interface Fields {
email?: FieldOptions;
}
interface Where extends Fields {
OR?: Fields[];
AND?: Fields[];
}
const handleArgs = (
query: WhereExpression,
where: Where,
andOr: "andWhere" | "orWhere"
) => {
const whereArgs = Object.entries(where);
whereArgs.map(whereArg => {
const [fieldName, filters] = whereArg;
const ops = Object.entries(filters);
ops.map(parameters => {
const [operation, value] = parameters;
switch (operation) {
case "is": {
query[andOr](`${fieldName} = :isvalue`, { isvalue: value });
break;
}
case "not": {
query[andOr](`${fieldName} != :notvalue`, { notvalue: value });
break;
}
case "in": {
query[andOr](`${fieldName} IN :invalue`, { invalue: value });
break;
}
case "not_in": {
query[andOr](`${fieldName} NOT IN :notinvalue`, {
notinvalue: value
});
break;
}
case "lt": {
query[andOr](`${fieldName} < :ltvalue`, { ltvalue: value });
break;
}
case "lte": {
query[andOr](`${fieldName} <= :ltevalue`, { ltevalue: value });
break;
}
case "gt": {
query[andOr](`${fieldName} > :gtvalue`, { gtvalue: value });
break;
}
case "gte": {
query[andOr](`${fieldName} >= :gtevalue`, { gtevalue: value });
break;
}
case "contains": {
query[andOr](`${fieldName} ILIKE :convalue`, {
convalue: `%${value}%`
});
break;
}
case "not_contains": {
query[andOr](`${fieldName} NOT ILIKE :notconvalue`, {
notconvalue: `%${value}%`
});
break;
}
case "starts_with": {
query[andOr](`${fieldName} ILIKE :swvalue`, {
swvalue: `${value}%`
});
break;
}
case "not_starts_with": {
query[andOr](`${fieldName} NOT ILIKE :nswvalue`, {
nswvalue: `${value}%`
});
break;
}
case "ends_with": {
query[andOr](`${fieldName} ILIKE :ewvalue`, {
ewvalue: `%${value}`
});
break;
}
case "not_ends_with": {
query[andOr](`${fieldName} ILIKE :newvalue`, {
newvalue: `%${value}`
});
break;
}
default: {
break;
}
}
});
});
return query;
};
export const filterQuery = <T>(query: SelectQueryBuilder<T>, where: Where) => {
if (!where) {
return query;
}
Object.keys(where).forEach(key => {
if (key === "OR") {
query.andWhere(
new Brackets(qb =>
where[key]!.map(queryArray => {
handleArgs(qb, queryArray, "orWhere");
})
)
);
} else if (key === "AND") {
query.andWhere(
new Brackets(qb =>
where[key]!.map(queryArray => {
handleArgs(qb, queryArray, "andWhere");
})
)
);
}
});
return query;
};
答案 1 :(得分:0)
我必须进行更复杂的搜索。这也涵盖了这个用例吗?
{
"AND":[
{"name":{"contains":"Peter"}},
{"OR": [
{"phone_001":{"contains":"123455621"}},
{"phone_002":{"contains":"123455621"}}
]}
]
}
答案 2 :(得分:0)
根据Ben的回答,我对功能进行了一些调整,以允许使用更多用途的“ 过滤器”对象:
// enum
export enum Operator {
AND = 'AND',
OR = 'OR',
}
// interfaces
interface FieldOptions {
is?: string;
not?: string;
in?: string;
not_in?: string;
lt?: string;
lte?: string;
gt?: string;
gte?: string;
contains?: string;
not_contains?: string;
starts_with?: string;
not_starts_with?: string;
ends_with?: string;
not_ends_with?: string;
}
export interface Field {
[key: string]: FieldOptions;
}
export type Where = {
[K in Operator]?: (Where | Field)[];
};
// functions
export const filterQuery = <T>(query: SelectQueryBuilder<T>, where: Where) => {
if (!where) {
return query;
} else {
return traverseTree(query, where) as SelectQueryBuilder<T>;
}
};
const traverseTree = (query: WhereExpression, where: Where, upperOperator = Operator.AND) => {
Object.keys(where).forEach((key) => {
if (key === Operator.OR) {
query = query.orWhere(buildNewBrackets(where, Operator.OR));
} else if (key === Operator.AND) {
query = query.andWhere(buildNewBrackets(where, Operator.AND));
} else {
// Field
query = handleArgs(query, where as Field, upperOperator === Operator.AND ? 'andWhere' : 'orWhere');
}
});
return query;
};
const buildNewBrackets = (where: Where, operator: Operator) => {
return new Brackets((qb) =>
where[operator].map((queryArray) => {
traverseTree(qb, queryArray, operator);
}),
);
};
const handleArgs = (query: WhereExpression, field: Field, andOr: 'andWhere' | 'orWhere') => {
...
};
这样,我们现在可以将这种对象作为查询参数:
{
AND: [
{
OR: [
{
name: {
is: 'John'
},
},
{
surname: {
is: 'Doe'
},
}
]
},
{
AND: [
{
age: {
gt: 30
},
},
{
type: {
not: 'Employee'
}
}
]
},
{
registered_date: {
gte: '2000-01-01'
}
}
]
}
结果查询为:
SELECT *
FROM users U
WHERE (U.name = 'John' OR U.surname = 'Doe') AND (U.age > 30 AND U.type != 'Employee') AND U.registered_date >= '2000-01-01';