Skip to main content

drizzle_core/builder/
states.rs

1//! Shared typestate markers for dialect query builders.
2
3use super::{ClauseAllowed, ExecutableState, clause};
4
5//------------------------------------------------------------------------------
6// SELECT states
7//------------------------------------------------------------------------------
8
9/// Marker for the initial state of `SelectBuilder`.
10#[derive(Debug, Clone, Copy, Default)]
11pub struct SelectInitial;
12
13/// Marker for the state after FROM clause.
14#[derive(Debug, Clone, Copy, Default)]
15pub struct SelectFromSet;
16
17/// Marker for the state after JOIN clause.
18#[derive(Debug, Clone, Copy, Default)]
19pub struct SelectJoinSet;
20
21/// Marker for the state after WHERE clause.
22#[derive(Debug, Clone, Copy, Default)]
23pub struct SelectWhereSet;
24
25/// Marker for the state after GROUP BY clause.
26#[derive(Debug, Clone, Copy, Default)]
27pub struct SelectGroupSet;
28
29/// Marker for the state after ORDER BY clause.
30#[derive(Debug, Clone, Copy, Default)]
31pub struct SelectOrderSet;
32
33/// Marker for the state after LIMIT clause.
34#[derive(Debug, Clone, Copy, Default)]
35pub struct SelectLimitSet;
36
37/// Marker for the state after OFFSET clause.
38#[derive(Debug, Clone, Copy, Default)]
39pub struct SelectOffsetSet;
40
41/// Marker for the state after set operations (UNION/INTERSECT/EXCEPT).
42#[derive(Debug, Clone, Copy, Default)]
43pub struct SelectSetOpSet;
44
45impl ExecutableState for SelectFromSet {}
46impl ExecutableState for SelectWhereSet {}
47impl ExecutableState for SelectLimitSet {}
48impl ExecutableState for SelectOffsetSet {}
49impl ExecutableState for SelectOrderSet {}
50impl ExecutableState for SelectGroupSet {}
51impl ExecutableState for SelectJoinSet {}
52impl ExecutableState for SelectSetOpSet {}
53
54impl ClauseAllowed<clause::Where> for SelectFromSet {}
55impl ClauseAllowed<clause::Where> for SelectJoinSet {}
56
57impl ClauseAllowed<clause::GroupBy> for SelectFromSet {}
58impl ClauseAllowed<clause::GroupBy> for SelectJoinSet {}
59impl ClauseAllowed<clause::GroupBy> for SelectWhereSet {}
60
61impl ClauseAllowed<clause::OrderBy> for SelectFromSet {}
62impl ClauseAllowed<clause::OrderBy> for SelectJoinSet {}
63impl ClauseAllowed<clause::OrderBy> for SelectWhereSet {}
64impl ClauseAllowed<clause::OrderBy> for SelectGroupSet {}
65// `SelectSetOpSet` is deliberately absent: a compound query orders by output
66// column names, so each dialect builder provides its own `order_by` there.
67
68impl ClauseAllowed<clause::Limit> for SelectFromSet {}
69impl ClauseAllowed<clause::Limit> for SelectJoinSet {}
70impl ClauseAllowed<clause::Limit> for SelectWhereSet {}
71impl ClauseAllowed<clause::Limit> for SelectGroupSet {}
72impl ClauseAllowed<clause::Limit> for SelectOrderSet {}
73impl ClauseAllowed<clause::Limit> for SelectSetOpSet {}
74
75impl ClauseAllowed<clause::Offset> for SelectFromSet {}
76impl ClauseAllowed<clause::Offset> for SelectLimitSet {}
77impl ClauseAllowed<clause::Offset> for SelectSetOpSet {}
78
79impl ClauseAllowed<clause::Join> for SelectFromSet {}
80impl ClauseAllowed<clause::Join> for SelectJoinSet {}
81
82impl ClauseAllowed<clause::Having> for SelectGroupSet {}
83
84impl ClauseAllowed<clause::Simple> for SelectFromSet {}
85impl ClauseAllowed<clause::Simple> for SelectJoinSet {}
86impl ClauseAllowed<clause::Simple> for SelectWhereSet {}
87impl ClauseAllowed<clause::Simple> for SelectGroupSet {}
88impl ClauseAllowed<clause::Simple> for SelectOrderSet {}
89impl ClauseAllowed<clause::Simple> for SelectLimitSet {}
90impl ClauseAllowed<clause::Simple> for SelectOffsetSet {}
91
92impl ClauseAllowed<clause::Compound> for SelectFromSet {}
93impl ClauseAllowed<clause::Compound> for SelectJoinSet {}
94impl ClauseAllowed<clause::Compound> for SelectWhereSet {}
95impl ClauseAllowed<clause::Compound> for SelectGroupSet {}
96impl ClauseAllowed<clause::Compound> for SelectOrderSet {}
97impl ClauseAllowed<clause::Compound> for SelectLimitSet {}
98impl ClauseAllowed<clause::Compound> for SelectOffsetSet {}
99impl ClauseAllowed<clause::Compound> for SelectSetOpSet {}
100
101impl ClauseAllowed<clause::Source> for SelectFromSet {}
102impl ClauseAllowed<clause::Source> for SelectJoinSet {}
103impl ClauseAllowed<clause::Source> for SelectWhereSet {}
104impl ClauseAllowed<clause::Source> for SelectGroupSet {}
105impl ClauseAllowed<clause::Source> for SelectOrderSet {}
106impl ClauseAllowed<clause::Source> for SelectLimitSet {}
107impl ClauseAllowed<clause::Source> for SelectOffsetSet {}
108impl ClauseAllowed<clause::Source> for SelectSetOpSet {}
109
110//------------------------------------------------------------------------------
111// INSERT states
112//------------------------------------------------------------------------------
113
114/// Marker for the initial state of `InsertBuilder`.
115#[derive(Debug, Clone, Copy, Default)]
116pub struct InsertInitial;
117
118/// Marker for the state after VALUES are set.
119#[derive(Debug, Clone, Copy, Default)]
120pub struct InsertValuesSet;
121
122/// Marker for the state after RETURNING clause is added.
123#[derive(Debug, Clone, Copy, Default)]
124pub struct InsertReturningSet;
125
126/// Marker for the state after ON CONFLICT is set.
127#[derive(Debug, Clone, Copy, Default)]
128pub struct InsertOnConflictSet;
129
130/// Marker for the state after DO UPDATE SET (before optional WHERE).
131#[derive(Debug, Clone, Copy, Default)]
132pub struct InsertDoUpdateSet;
133
134impl ExecutableState for InsertValuesSet {}
135impl ExecutableState for InsertReturningSet {}
136impl ExecutableState for InsertOnConflictSet {}
137impl ExecutableState for InsertDoUpdateSet {}
138
139//------------------------------------------------------------------------------
140// DELETE states
141//------------------------------------------------------------------------------
142
143/// Marker for the initial state of `DeleteBuilder`.
144#[derive(Debug, Clone, Copy, Default)]
145pub struct DeleteInitial;
146
147/// Marker for the state after WHERE clause.
148#[derive(Debug, Clone, Copy, Default)]
149pub struct DeleteWhereSet;
150
151/// Marker for the state after RETURNING clause.
152#[derive(Debug, Clone, Copy, Default)]
153pub struct DeleteReturningSet;
154
155impl ExecutableState for DeleteInitial {}
156impl ExecutableState for DeleteWhereSet {}
157impl ExecutableState for DeleteReturningSet {}
158
159//------------------------------------------------------------------------------
160// UPDATE states
161//------------------------------------------------------------------------------
162
163/// Marker for the initial state of `UpdateBuilder`.
164#[derive(Debug, Clone, Copy, Default)]
165pub struct UpdateInitial;
166
167/// Marker for the state after SET clause.
168#[derive(Debug, Clone, Copy, Default)]
169pub struct UpdateSetClauseSet;
170
171/// Marker for the state after WHERE clause.
172#[derive(Debug, Clone, Copy, Default)]
173pub struct UpdateWhereSet;
174
175/// Marker for the state after RETURNING clause.
176#[derive(Debug, Clone, Copy, Default)]
177pub struct UpdateReturningSet;
178
179impl ExecutableState for UpdateSetClauseSet {}
180impl ExecutableState for UpdateWhereSet {}
181impl ExecutableState for UpdateReturningSet {}