sift-query-core 0.1.0

Backend-independent query model and strict parameter parser for SiftQuery
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155

use super::shared::*;

// ---------------------------------------------------------------------------
// Entities used for configuration-error paths.
// ---------------------------------------------------------------------------

/// Entity whose `stable_order` is empty, which must reject pagination.
pub(super) static UNSTABLE_FIELDS: &[FieldMeta] = &[FieldMeta {
    id: FieldId(0),
    public_name: "id",
    column: "u.id",
    result_alias: Some("id"),
    value_type: ValueType::I64,
    kind: FieldKind::Scalar,
    filterable: true,
    selectable: true,
    sortable: true,
    operators: OperatorSet(OPS_I64),
}];

pub(super) static UNSTABLE_META: EntityMeta = EntityMeta {
    entity_name: "UnstableEntity",
    from: "app_user u",
    base_where: None,
    fixed_having: None,
    distinct: false,
    fields: UNSTABLE_FIELDS,
    default_order: &[],
    stable_order: &[],
    limits: LIMITS,
    schema_fingerprint: 21,
};

#[derive(Debug)]
pub struct UnstableEntity;

impl SearchEntity for UnstableEntity {
    const META: &'static EntityMeta = &UNSTABLE_META;
}

/// Entity with a `distinct` base relation and a non-projected default order.
pub(super) static DISTINCT_FIELDS: &[FieldMeta] = &[
    FieldMeta {
        id: FieldId(0),
        public_name: "id",
        column: "u.id",
        result_alias: Some("id"),
        value_type: ValueType::I64,
        kind: FieldKind::Scalar,
        filterable: true,
        selectable: true,
        sortable: true,
        operators: OperatorSet(OPS_I64),
    },
    FieldMeta {
        id: FieldId(1),
        public_name: "name",
        column: "u.name",
        result_alias: Some("name"),
        value_type: ValueType::Text,
        kind: FieldKind::Scalar,
        filterable: true,
        selectable: true,
        sortable: true,
        operators: OperatorSet(OPS_TEXT),
    },
];

pub(super) static DISTINCT_META: EntityMeta = EntityMeta {
    entity_name: "DistinctEntity",
    from: "app_user u",
    base_where: None,
    fixed_having: None,
    distinct: true,
    fields: DISTINCT_FIELDS,
    default_order: DEFAULT_ORDER,
    stable_order: DEFAULT_ORDER,
    limits: LIMITS,
    schema_fingerprint: 22,
};

#[derive(Debug)]
pub struct DistinctEntity;

impl SearchEntity for DistinctEntity {
    const META: &'static EntityMeta = &DISTINCT_META;
}

/// Entity whose schema is incompatible with `TestEntity`, for mismatch checks.
pub(super) static OTHER_FIELDS: &[FieldMeta] = &[FieldMeta {
    id: FieldId(0),
    public_name: "id",
    column: "o.id",
    result_alias: Some("id"),
    value_type: ValueType::I64,
    kind: FieldKind::Scalar,
    filterable: true,
    selectable: true,
    sortable: true,
    operators: OperatorSet(OPS_I64),
}];

pub(super) static OTHER_META: EntityMeta = EntityMeta {
    entity_name: "OtherEntity",
    from: "other o",
    base_where: None,
    fixed_having: None,
    distinct: false,
    fields: OTHER_FIELDS,
    default_order: DEFAULT_ORDER,
    stable_order: DEFAULT_ORDER,
    limits: LIMITS,
    schema_fingerprint: 23,
};

#[derive(Debug)]
pub struct OtherEntity;

impl SearchEntity for OtherEntity {
    const META: &'static EntityMeta = &OTHER_META;
}

/// Entity whose public field name is not a valid parameter name.
pub(super) static INVALID_NAME_FIELDS: &[FieldMeta] = &[FieldMeta {
    id: FieldId(0),
    public_name: "1bad",
    column: "u.id",
    result_alias: Some("id"),
    value_type: ValueType::I64,
    kind: FieldKind::Scalar,
    filterable: true,
    selectable: true,
    sortable: true,
    operators: OperatorSet(OPS_I64),
}];

pub(super) static INVALID_NAME_META: EntityMeta = EntityMeta {
    entity_name: "InvalidNameEntity",
    from: "app_user u",
    base_where: None,
    fixed_having: None,
    distinct: false,
    fields: INVALID_NAME_FIELDS,
    default_order: DEFAULT_ORDER,
    stable_order: DEFAULT_ORDER,
    limits: LIMITS,
    schema_fingerprint: 24,
};

#[derive(Debug)]
pub struct InvalidNameEntity;

impl SearchEntity for InvalidNameEntity {
    const META: &'static EntityMeta = &INVALID_NAME_META;
}