← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to docs/functions/logical.rst

  • Committer: Lee Bieber
  • Date: 2011-02-23 00:54:51 UTC
  • mfrom: (1994.4.96 drizzle)
  • mto: This revision was merged to the branch mainline in revision 2194.
  • Revision ID: kalebral@gmail.com-20110223005451-yqqywil9o7yzt4te
Merge Marisa - documentation updates

Show diffs side-by-side

added added

removed removed

Lines of Context:
docs/functions/logical.rst
1
1
Logical and Comparison Operators
2
2
================================
3
3
 
4
 
=========     ==========================
5
 
Operators     Description
6
 
=========     ==========================
7
 
AND (&&)       Logical AND
8
 
OR (||)        Logical OR
9
 
NOT (!)        Logical NOT
10
 
<              less than
11
 
>              greater than
12
 
<=             less than or equal to
13
 
>=             greater than or equal to
14
 
=              equal
15
 
<> or !=       not equal
16
 
=========     ==========================
 
4
==============================     ================================
 
5
Operators                           Description
 
6
==============================     ================================
 
7
:ref:`and` &&                       Logical AND
 
8
:ref:`or` (||)                      Logical OR
 
9
:ref:`xor`                          Logical XOR
 
10
:ref:`not` (!)                      Logical NOT
 
11
:ref:`less_than` <                  less than
 
12
:ref:`greater_than` >               greater than
 
13
:ref:`less_or_equal` <=             less than or equal to
 
14
:ref:`greater_or_equal` >=          greater than or equal to
 
15
:ref:`equal` =                      equal
 
16
:ref:`not_equal` <> or !=           not equal
 
17
==============================     ================================
 
18
 
 
19
 
 
20
.. _and:
 
21
 
 
22
AND
 
23
---
 
24
 
 
25
This logical operator AND:
 
26
 
 
27
* evaluates to 1 if all operands are nonzero and not NULL
 
28
* evaluates to 0 if one or more operands are 0 
 
29
* otherwise returns NULL 
 
30
 
 
31
::
 
32
 
 
33
        SELECT 1 && 1;
 
34
                -> 1
 
35
        SELECT 1 && 0;
 
36
                -> 0
 
37
        SELECT 1 && NULL;
 
38
                -> NULL
 
39
        SELECT 0 && NULL;
 
40
                -> 0
 
41
        SELECT NULL && 0;
 
42
                -> 0
 
43
 
 
44
AND can be used to select rows that satisfy all the conditions given in a statement. For Example, to find the names of the students between the age 20 to 25 years, the query would be like: ::
 
45
 
 
46
        SELECT first_name, last_name, age
 
47
        FROM user_details
 
48
        WHERE age >= 20 AND age <= 25;
 
49
 
 
50
The output would be:
 
51
 
 
52
+---------------+------------------+-------+
 
53
|first_name     |last_name         |age    |
 
54
+===============+==================+=======+
 
55
|Mary           |Bean              |20     |
 
56
+---------------+------------------+-------+
 
57
|Henry          |Catson            |22     |
 
58
+---------------+------------------+-------+
 
59
|Sheila         |Donaldson         |25     |
 
60
+---------------+------------------+-------+  
 
61
 
 
62
The logical "AND" operator selects rows only if the data in all relevant columns is satisfied. In this case, 'first_name' and 'last_name' simply need to have non-NULL values, and 'age' needs to be a value between 20 and 25.
 
63
 
 
64
.. _or:
 
65
 
 
66
OR
 
67
--
 
68
 
 
69
This logical operator OR:
 
70
 
 
71
* returns 1 if any operand is nonzero and both operands are non-NULL, and returns 0 otherwise
 
72
* returns 1 with a NULL operand if the other operand is nonzero, and retunes NULL otherwise
 
73
* returns NULL if both operands are NULL
 
74
 
 
75
::
 
76
 
 
77
        SELECT 1 || 1;
 
78
                -> 1
 
79
        SELECT 1 || 0;
 
80
                -> 1
 
81
        SELECT 0 || 0;
 
82
                -> 0
 
83
        SELECT 1 || NULL;
 
84
                -> 1
 
85
        SELECT 0 || NULL;
 
86
                -> NULL
 
87
 
 
88
In other words, OR is used to select rows that satisfy at least one of the given conditions.
 
89
 
 
90
For example, the following query could be used to find the user_id for people that live in either California or Texas: ::
 
91
 
 
92
        SELECT user_id, state
 
93
        FROM user_location
 
94
        WHERE state = 'California' OR state = 'Texas';
 
95
 
 
96
The result set could be something like:
 
97
 
 
98
+---------------+------------------+-----------+
 
99
|user_id        |city              |state      |
 
100
+===============+==================+===========+
 
101
|608            |Sacremento        |California |
 
102
+---------------+------------------+-----------+
 
103
|844            |Austin            |Texas      |
 
104
+---------------+------------------+-----------+
 
105
|917            |Oakland           |California |
 
106
+---------------+------------------+-----------+  
 
107
 
 
108
 
 
109
.. _xor:
 
110
 
 
111
XOR
 
112
---
 
113
 
 
114
* returns NULL if either operand is NULL
 
115
* evaluates to 1 for non-NULL operands (if an odd number of operands is nonzero)
 
116
* otherwise 0 is returned
 
117
 
 
118
::
 
119
 
 
120
        SELECT 1 XOR NULL;
 
121
                -> NULL
 
122
        SELECT 1 XOR 0;
 
123
                -> 1
 
124
        SELECT 1 XOR 1 XOR 1;
 
125
                -> 1
 
126
        SELECT 1 XOR 1;
 
127
                -> 0
 
128
 
 
129
Note that "a XOR b" is the mathematical equivalent of (a AND (NOT b)) OR ((NOT a) and b). 
 
130
 
 
131
 
 
132
.. _not:
 
133
 
 
134
NOT
 
135
---
 
136
 
 
137
This logical operator NOT:
 
138
 
 
139
* evaluates to 1 if the operand is 0
 
140
* evaluates to 0 if the operand is nonzero
 
141
* NOT NULL returns NULL
 
142
 
 
143
::
 
144
 
 
145
        SELECT NOT 10;
 
146
                -> 0
 
147
        SELECT NOT 0;
 
148
                -> 1
 
149
        SELECT NOT NULL;
 
150
                -> NULL
 
151
        SELECT ! (1+1);
 
152
                -> 0
 
153
        SELECT ! 1+1;
 
154
                -> 1
 
155
 
 
156
If you want to find rows that do not satisfy a condition, you can use the logical operator, NOT. NOT results in the reverse of a condition. That is, if a condition is satisfied, then the row is not returned.
 
157
 
 
158
For example: If you want to find out the user_id for people who do not practice medicine as their profession, the query would be like: ::
 
159
 
 
160
        SELECT user_id, title, occupation
 
161
        FROM user_occupations
 
162
        WHERE NOT occupation = 'Doctor';
 
163
 
 
164
The result set would be something like:
 
165
 
 
166
+---------------+------------------+--------------+
 
167
|user_id        |degree            |occupation    |
 
168
+===============+==================+==============+
 
169
|322            |PhD               |Professor     |
 
170
+---------------+------------------+--------------+
 
171
|579            |PhD               |Writer        |
 
172
+---------------+------------------+--------------+
 
173
|681            |MD                |Consultant    |
 
174
+---------------+------------------+--------------+  
 
175
 
 
176
 
 
177
.. _less_than:
 
178
 
 
179
LESS THAN
 
180
----------
 
181
 
 
182
Less than: ::
 
183
 
 
184
        SELECT 2 < 2;
 
185
                -> 0
 
186
 
 
187
 
 
188
.. _greater_than:
 
189
 
 
190
GREATER THAN
 
191
-------------
 
192
 
 
193
Greater than: ::
 
194
 
 
195
        SELECT 2 > 2;
 
196
                -> 0
 
197
 
 
198
.. _less_or_equal:
 
199
 
 
200
LESS THAN OR EQUAL
 
201
-------------------
 
202
 
 
203
Less than or equal: ::
 
204
 
 
205
        SELECT 0.1 <= 2;
 
206
                -> 1
 
207
 
 
208
 
 
209
.. _greater_or_equal:
 
210
 
 
211
GREATER THAN OR EQUAL
 
212
----------------------
 
213
 
 
214
Greater than or equal: ::
 
215
 
 
216
        SELECT 2 >= 2;
 
217
                -> 1
 
218
 
 
219
.. _equal:
 
220
 
 
221
EQUAL
 
222
-----
 
223
 
 
224
Equal: ::
 
225
 
 
226
        SELECT 1 = 0;
 
227
                -> 0
 
228
        SELECT '0' = 0;
 
229
                -> 1
 
230
        SELECT '0.0' = 0;
 
231
                -> 1
 
232
        SELECT '0.01' = 0;
 
233
                -> 0
 
234
        SELECT '.01' = 0.01;
 
235
                -> 1
 
236
 
 
237
 
 
238
.. _not_equal:
 
239
 
 
240
NOT EQUAL
 
241
----------
 
242
 
 
243
Not equal: ::
 
244
 
 
245
        SELECT '.01' <> '0.01';
 
246
                -> 1
 
247
        SELECT .01 <> '0.01';
 
248
                -> 0
 
249
        SELECT 'zing' <> 'zingg';
 
250
                -> 1
 
251