← Back to branch summary

~ubuntu-branches/ubuntu/precise/postgresql-9.1/precise-security

« back to all changes in this revision

Viewing changes to doc/src/sgml/html/intarray.html

  • Committer: Bazaar Package Importer
  • Author(s): Martin Pitt
  • Date: 2011-05-11 10:41:53 UTC
  • Revision ID: james.westby@ubuntu.com-20110511104153-psbh2o58553fv1m0
Tags: upstream-9.1~beta1
Import upstream version 9.1~beta1

Show diffs side-by-side

added added

removed removed

Lines of Context:
doc/src/sgml/html/intarray.html
 
1
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
 
2
<HTML
 
3
><HEAD
 
4
><TITLE
 
5
>intarray</TITLE
 
6
><META
 
7
NAME="GENERATOR"
 
8
CONTENT="Modular DocBook HTML Stylesheet Version 1.79"><LINK
 
9
REV="MADE"
 
10
HREF="mailto:pgsql-docs@postgresql.org"><LINK
 
11
REL="HOME"
 
12
TITLE="PostgreSQL 9.1beta1 Documentation"
 
13
HREF="index.html"><LINK
 
14
REL="UP"
 
15
TITLE="Additional Supplied Modules"
 
16
HREF="contrib.html"><LINK
 
17
REL="PREVIOUS"
 
18
TITLE="intagg"
 
19
HREF="intagg.html"><LINK
 
20
REL="NEXT"
 
21
TITLE="isn"
 
22
HREF="isn.html"><LINK
 
23
REL="STYLESHEET"
 
24
TYPE="text/css"
 
25
HREF="stylesheet.css"><META
 
26
HTTP-EQUIV="Content-Type"
 
27
CONTENT="text/html; charset=ISO-8859-1"><META
 
28
NAME="creation"
 
29
CONTENT="2011-04-27T21:20:33"></HEAD
 
30
><BODY
 
31
CLASS="SECT1"
 
32
><DIV
 
33
CLASS="NAVHEADER"
 
34
><TABLE
 
35
SUMMARY="Header navigation table"
 
36
WIDTH="100%"
 
37
BORDER="0"
 
38
CELLPADDING="0"
 
39
CELLSPACING="0"
 
40
><TR
 
41
><TH
 
42
COLSPAN="5"
 
43
ALIGN="center"
 
44
VALIGN="bottom"
 
45
><A
 
46
HREF="index.html"
 
47
>PostgreSQL 9.1beta1 Documentation</A
 
48
></TH
 
49
></TR
 
50
><TR
 
51
><TD
 
52
WIDTH="10%"
 
53
ALIGN="left"
 
54
VALIGN="top"
 
55
><A
 
56
TITLE="intagg"
 
57
HREF="intagg.html"
 
58
ACCESSKEY="P"
 
59
>Prev</A
 
60
></TD
 
61
><TD
 
62
WIDTH="10%"
 
63
ALIGN="left"
 
64
VALIGN="top"
 
65
><A
 
66
TITLE="Additional Supplied Modules"
 
67
HREF="contrib.html"
 
68
>Fast Backward</A
 
69
></TD
 
70
><TD
 
71
WIDTH="60%"
 
72
ALIGN="center"
 
73
VALIGN="bottom"
 
74
>Appendix F. Additional Supplied Modules</TD
 
75
><TD
 
76
WIDTH="10%"
 
77
ALIGN="right"
 
78
VALIGN="top"
 
79
><A
 
80
TITLE="Additional Supplied Modules"
 
81
HREF="contrib.html"
 
82
>Fast Forward</A
 
83
></TD
 
84
><TD
 
85
WIDTH="10%"
 
86
ALIGN="right"
 
87
VALIGN="top"
 
88
><A
 
89
TITLE="isn"
 
90
HREF="isn.html"
 
91
ACCESSKEY="N"
 
92
>Next</A
 
93
></TD
 
94
></TR
 
95
></TABLE
 
96
><HR
 
97
ALIGN="LEFT"
 
98
WIDTH="100%"></DIV
 
99
><DIV
 
100
CLASS="SECT1"
 
101
><H1
 
102
CLASS="SECT1"
 
103
><A
 
104
NAME="INTARRAY"
 
105
>F.18. intarray</A
 
106
></H1
 
107
><P
 
108
>  The <TT
 
109
CLASS="FILENAME"
 
110
>intarray</TT
 
111
> module provides a number of useful functions
 
112
  and operators for manipulating null-free arrays of integers.
 
113
  There is also support for indexed searches using some of the operators.
 
114
 </P
 
115
><P
 
116
>  All of these operations will throw an error if a supplied array contains any
 
117
  NULL elements.
 
118
 </P
 
119
><P
 
120
>  Many of these operations are only sensible for one-dimensional arrays.
 
121
  Although they will accept input arrays of more dimensions, the data is
 
122
  treated as though it were a linear array in storage order.
 
123
 </P
 
124
><DIV
 
125
CLASS="SECT2"
 
126
><H2
 
127
CLASS="SECT2"
 
128
><A
 
129
NAME="AEN130678"
 
130
>F.18.1. <TT
 
131
CLASS="FILENAME"
 
132
>intarray</TT
 
133
> Functions and Operators</A
 
134
></H2
 
135
><DIV
 
136
CLASS="TABLE"
 
137
><A
 
138
NAME="INTARRAY-FUNC-TABLE"
 
139
></A
 
140
><P
 
141
><B
 
142
>Table F-8. <TT
 
143
CLASS="FILENAME"
 
144
>intarray</TT
 
145
> Functions</B
 
146
></P
 
147
><TABLE
 
148
BORDER="1"
 
149
CLASS="CALSTABLE"
 
150
><COL><COL><COL><COL><COL><THEAD
 
151
><TR
 
152
><TH
 
153
>Function</TH
 
154
><TH
 
155
>Return Type</TH
 
156
><TH
 
157
>Description</TH
 
158
><TH
 
159
>Example</TH
 
160
><TH
 
161
>Result</TH
 
162
></TR
 
163
></THEAD
 
164
><TBODY
 
165
><TR
 
166
><TD
 
167
><CODE
 
168
CLASS="FUNCTION"
 
169
>icount(int[])</CODE
 
170
></TD
 
171
><TD
 
172
><TT
 
173
CLASS="TYPE"
 
174
>int</TT
 
175
></TD
 
176
><TD
 
177
>number of elements in array</TD
 
178
><TD
 
179
><TT
 
180
CLASS="LITERAL"
 
181
>icount('{1,2,3}'::int[])</TT
 
182
></TD
 
183
><TD
 
184
><TT
 
185
CLASS="LITERAL"
 
186
>3</TT
 
187
></TD
 
188
></TR
 
189
><TR
 
190
><TD
 
191
><CODE
 
192
CLASS="FUNCTION"
 
193
>sort(int[], text dir)</CODE
 
194
></TD
 
195
><TD
 
196
><TT
 
197
CLASS="TYPE"
 
198
>int[]</TT
 
199
></TD
 
200
><TD
 
201
>sort array &mdash; <TT
 
202
CLASS="PARAMETER"
 
203
>dir</TT
 
204
> must be <TT
 
205
CLASS="LITERAL"
 
206
>asc</TT
 
207
> or <TT
 
208
CLASS="LITERAL"
 
209
>desc</TT
 
210
></TD
 
211
><TD
 
212
><TT
 
213
CLASS="LITERAL"
 
214
>sort('{1,2,3}'::int[], 'desc')</TT
 
215
></TD
 
216
><TD
 
217
><TT
 
218
CLASS="LITERAL"
 
219
>{3,2,1}</TT
 
220
></TD
 
221
></TR
 
222
><TR
 
223
><TD
 
224
><CODE
 
225
CLASS="FUNCTION"
 
226
>sort(int[])</CODE
 
227
></TD
 
228
><TD
 
229
><TT
 
230
CLASS="TYPE"
 
231
>int[]</TT
 
232
></TD
 
233
><TD
 
234
>sort in ascending order</TD
 
235
><TD
 
236
><TT
 
237
CLASS="LITERAL"
 
238
>sort(array[11,77,44])</TT
 
239
></TD
 
240
><TD
 
241
><TT
 
242
CLASS="LITERAL"
 
243
>{11,44,77}</TT
 
244
></TD
 
245
></TR
 
246
><TR
 
247
><TD
 
248
><CODE
 
249
CLASS="FUNCTION"
 
250
>sort_asc(int[])</CODE
 
251
></TD
 
252
><TD
 
253
><TT
 
254
CLASS="TYPE"
 
255
>int[]</TT
 
256
></TD
 
257
><TD
 
258
>sort in ascending order</TD
 
259
><TD
 
260
><TT
 
261
CLASS="LITERAL"
 
262
></TT
 
263
></TD
 
264
><TD
 
265
><TT
 
266
CLASS="LITERAL"
 
267
></TT
 
268
></TD
 
269
></TR
 
270
><TR
 
271
><TD
 
272
><CODE
 
273
CLASS="FUNCTION"
 
274
>sort_desc(int[])</CODE
 
275
></TD
 
276
><TD
 
277
><TT
 
278
CLASS="TYPE"
 
279
>int[]</TT
 
280
></TD
 
281
><TD
 
282
>sort in descending order</TD
 
283
><TD
 
284
><TT
 
285
CLASS="LITERAL"
 
286
></TT
 
287
></TD
 
288
><TD
 
289
><TT
 
290
CLASS="LITERAL"
 
291
></TT
 
292
></TD
 
293
></TR
 
294
><TR
 
295
><TD
 
296
><CODE
 
297
CLASS="FUNCTION"
 
298
>uniq(int[])</CODE
 
299
></TD
 
300
><TD
 
301
><TT
 
302
CLASS="TYPE"
 
303
>int[]</TT
 
304
></TD
 
305
><TD
 
306
>remove adjacent duplicates</TD
 
307
><TD
 
308
><TT
 
309
CLASS="LITERAL"
 
310
>uniq(sort('{1,2,3,2,1}'::int[]))</TT
 
311
></TD
 
312
><TD
 
313
><TT
 
314
CLASS="LITERAL"
 
315
>{1,2,3}</TT
 
316
></TD
 
317
></TR
 
318
><TR
 
319
><TD
 
320
><CODE
 
321
CLASS="FUNCTION"
 
322
>idx(int[], int item)</CODE
 
323
></TD
 
324
><TD
 
325
><TT
 
326
CLASS="TYPE"
 
327
>int</TT
 
328
></TD
 
329
><TD
 
330
>index of first element matching <TT
 
331
CLASS="PARAMETER"
 
332
>item</TT
 
333
> (0 if none)</TD
 
334
><TD
 
335
><TT
 
336
CLASS="LITERAL"
 
337
>idx(array[11,22,33,22,11], 22)</TT
 
338
></TD
 
339
><TD
 
340
><TT
 
341
CLASS="LITERAL"
 
342
>2</TT
 
343
></TD
 
344
></TR
 
345
><TR
 
346
><TD
 
347
><CODE
 
348
CLASS="FUNCTION"
 
349
>subarray(int[], int start, int len)</CODE
 
350
></TD
 
351
><TD
 
352
><TT
 
353
CLASS="TYPE"
 
354
>int[]</TT
 
355
></TD
 
356
><TD
 
357
>portion of array starting at position <TT
 
358
CLASS="PARAMETER"
 
359
>start</TT
 
360
>, <TT
 
361
CLASS="PARAMETER"
 
362
>len</TT
 
363
> elements</TD
 
364
><TD
 
365
><TT
 
366
CLASS="LITERAL"
 
367
>subarray('{1,2,3,2,1}'::int[], 2, 3)</TT
 
368
></TD
 
369
><TD
 
370
><TT
 
371
CLASS="LITERAL"
 
372
>{2,3,2}</TT
 
373
></TD
 
374
></TR
 
375
><TR
 
376
><TD
 
377
><CODE
 
378
CLASS="FUNCTION"
 
379
>subarray(int[], int start)</CODE
 
380
></TD
 
381
><TD
 
382
><TT
 
383
CLASS="TYPE"
 
384
>int[]</TT
 
385
></TD
 
386
><TD
 
387
>portion of array starting at position <TT
 
388
CLASS="PARAMETER"
 
389
>start</TT
 
390
></TD
 
391
><TD
 
392
><TT
 
393
CLASS="LITERAL"
 
394
>subarray('{1,2,3,2,1}'::int[], 2)</TT
 
395
></TD
 
396
><TD
 
397
><TT
 
398
CLASS="LITERAL"
 
399
>{2,3,2,1}</TT
 
400
></TD
 
401
></TR
 
402
><TR
 
403
><TD
 
404
><CODE
 
405
CLASS="FUNCTION"
 
406
>intset(int)</CODE
 
407
></TD
 
408
><TD
 
409
><TT
 
410
CLASS="TYPE"
 
411
>int[]</TT
 
412
></TD
 
413
><TD
 
414
>make single-element array</TD
 
415
><TD
 
416
><TT
 
417
CLASS="LITERAL"
 
418
>intset(42)</TT
 
419
></TD
 
420
><TD
 
421
><TT
 
422
CLASS="LITERAL"
 
423
>{42}</TT
 
424
></TD
 
425
></TR
 
426
></TBODY
 
427
></TABLE
 
428
></DIV
 
429
><DIV
 
430
CLASS="TABLE"
 
431
><A
 
432
NAME="INTARRAY-OP-TABLE"
 
433
></A
 
434
><P
 
435
><B
 
436
>Table F-9. <TT
 
437
CLASS="FILENAME"
 
438
>intarray</TT
 
439
> Operators</B
 
440
></P
 
441
><TABLE
 
442
BORDER="1"
 
443
CLASS="CALSTABLE"
 
444
><COL><COL><COL><THEAD
 
445
><TR
 
446
><TH
 
447
>Operator</TH
 
448
><TH
 
449
>Returns</TH
 
450
><TH
 
451
>Description</TH
 
452
></TR
 
453
></THEAD
 
454
><TBODY
 
455
><TR
 
456
><TD
 
457
><TT
 
458
CLASS="LITERAL"
 
459
>int[] &amp;&amp; int[]</TT
 
460
></TD
 
461
><TD
 
462
><TT
 
463
CLASS="TYPE"
 
464
>boolean</TT
 
465
></TD
 
466
><TD
 
467
>overlap &mdash; <TT
 
468
CLASS="LITERAL"
 
469
>true</TT
 
470
> if arrays have at least one common element</TD
 
471
></TR
 
472
><TR
 
473
><TD
 
474
><TT
 
475
CLASS="LITERAL"
 
476
>int[] @&gt; int[]</TT
 
477
></TD
 
478
><TD
 
479
><TT
 
480
CLASS="TYPE"
 
481
>boolean</TT
 
482
></TD
 
483
><TD
 
484
>contains &mdash; <TT
 
485
CLASS="LITERAL"
 
486
>true</TT
 
487
> if left array contains right array</TD
 
488
></TR
 
489
><TR
 
490
><TD
 
491
><TT
 
492
CLASS="LITERAL"
 
493
>int[] &lt;@ int[]</TT
 
494
></TD
 
495
><TD
 
496
><TT
 
497
CLASS="TYPE"
 
498
>boolean</TT
 
499
></TD
 
500
><TD
 
501
>contained &mdash; <TT
 
502
CLASS="LITERAL"
 
503
>true</TT
 
504
> if left array is contained in right array</TD
 
505
></TR
 
506
><TR
 
507
><TD
 
508
><TT
 
509
CLASS="LITERAL"
 
510
># int[]</TT
 
511
></TD
 
512
><TD
 
513
><TT
 
514
CLASS="TYPE"
 
515
>int</TT
 
516
></TD
 
517
><TD
 
518
>number of elements in array</TD
 
519
></TR
 
520
><TR
 
521
><TD
 
522
><TT
 
523
CLASS="LITERAL"
 
524
>int[] # int</TT
 
525
></TD
 
526
><TD
 
527
><TT
 
528
CLASS="TYPE"
 
529
>int</TT
 
530
></TD
 
531
><TD
 
532
>index (same as <CODE
 
533
CLASS="FUNCTION"
 
534
>idx</CODE
 
535
> function)</TD
 
536
></TR
 
537
><TR
 
538
><TD
 
539
><TT
 
540
CLASS="LITERAL"
 
541
>int[] + int</TT
 
542
></TD
 
543
><TD
 
544
><TT
 
545
CLASS="TYPE"
 
546
>int[]</TT
 
547
></TD
 
548
><TD
 
549
>push element onto array (add it to end of array)</TD
 
550
></TR
 
551
><TR
 
552
><TD
 
553
><TT
 
554
CLASS="LITERAL"
 
555
>int[] + int[]  </TT
 
556
></TD
 
557
><TD
 
558
><TT
 
559
CLASS="TYPE"
 
560
>int[]</TT
 
561
></TD
 
562
><TD
 
563
>array concatenation (right array added to the end of left one)</TD
 
564
></TR
 
565
><TR
 
566
><TD
 
567
><TT
 
568
CLASS="LITERAL"
 
569
>int[] - int</TT
 
570
></TD
 
571
><TD
 
572
><TT
 
573
CLASS="TYPE"
 
574
>int[]</TT
 
575
></TD
 
576
><TD
 
577
>remove entries matching right argument from array</TD
 
578
></TR
 
579
><TR
 
580
><TD
 
581
><TT
 
582
CLASS="LITERAL"
 
583
>int[] - int[]</TT
 
584
></TD
 
585
><TD
 
586
><TT
 
587
CLASS="TYPE"
 
588
>int[]</TT
 
589
></TD
 
590
><TD
 
591
>remove elements of right array from left</TD
 
592
></TR
 
593
><TR
 
594
><TD
 
595
><TT
 
596
CLASS="LITERAL"
 
597
>int[] | int</TT
 
598
></TD
 
599
><TD
 
600
><TT
 
601
CLASS="TYPE"
 
602
>int[]</TT
 
603
></TD
 
604
><TD
 
605
>union of arguments</TD
 
606
></TR
 
607
><TR
 
608
><TD
 
609
><TT
 
610
CLASS="LITERAL"
 
611
>int[] | int[]</TT
 
612
></TD
 
613
><TD
 
614
><TT
 
615
CLASS="TYPE"
 
616
>int[]</TT
 
617
></TD
 
618
><TD
 
619
>union of arrays</TD
 
620
></TR
 
621
><TR
 
622
><TD
 
623
><TT
 
624
CLASS="LITERAL"
 
625
>int[] &amp; int[]</TT
 
626
></TD
 
627
><TD
 
628
><TT
 
629
CLASS="TYPE"
 
630
>int[]</TT
 
631
></TD
 
632
><TD
 
633
>intersection of arrays</TD
 
634
></TR
 
635
><TR
 
636
><TD
 
637
><TT
 
638
CLASS="LITERAL"
 
639
>int[] @@ query_int</TT
 
640
></TD
 
641
><TD
 
642
><TT
 
643
CLASS="TYPE"
 
644
>boolean</TT
 
645
></TD
 
646
><TD
 
647
><TT
 
648
CLASS="LITERAL"
 
649
>true</TT
 
650
> if array satisfies query (see below)</TD
 
651
></TR
 
652
><TR
 
653
><TD
 
654
><TT
 
655
CLASS="LITERAL"
 
656
>query_int ~~ int[]</TT
 
657
></TD
 
658
><TD
 
659
><TT
 
660
CLASS="TYPE"
 
661
>boolean</TT
 
662
></TD
 
663
><TD
 
664
><TT
 
665
CLASS="LITERAL"
 
666
>true</TT
 
667
> if array satisfies query (commutator of <TT
 
668
CLASS="LITERAL"
 
669
>@@</TT
 
670
>)</TD
 
671
></TR
 
672
></TBODY
 
673
></TABLE
 
674
></DIV
 
675
><P
 
676
>   (Before PostgreSQL 8.2, the containment operators <TT
 
677
CLASS="LITERAL"
 
678
>@&gt;</TT
 
679
> and
 
680
   <TT
 
681
CLASS="LITERAL"
 
682
>&lt;@</TT
 
683
> were respectively called <TT
 
684
CLASS="LITERAL"
 
685
>@</TT
 
686
> and <TT
 
687
CLASS="LITERAL"
 
688
>~</TT
 
689
>.
 
690
   These names are still available, but are deprecated and will eventually be
 
691
   retired.  Notice that the old names are reversed from the convention
 
692
   formerly followed by the core geometric data types!)
 
693
  </P
 
694
><P
 
695
>   The operators <TT
 
696
CLASS="LITERAL"
 
697
>&amp;&amp;</TT
 
698
>, <TT
 
699
CLASS="LITERAL"
 
700
>@&gt;</TT
 
701
> and
 
702
   <TT
 
703
CLASS="LITERAL"
 
704
>&lt;@</TT
 
705
> are equivalent to <SPAN
 
706
CLASS="PRODUCTNAME"
 
707
>PostgreSQL</SPAN
 
708
>'s built-in
 
709
   operators of the same names, except that they work only on integer arrays
 
710
   that do not contain nulls, while the built-in operators work for any array
 
711
   type.  This restriction makes them faster than the built-in operators
 
712
   in many cases.
 
713
  </P
 
714
><P
 
715
>   The <TT
 
716
CLASS="LITERAL"
 
717
>@@</TT
 
718
> and <TT
 
719
CLASS="LITERAL"
 
720
>~~</TT
 
721
> operators test whether an array
 
722
   satisfies a <I
 
723
CLASS="FIRSTTERM"
 
724
>query</I
 
725
>, which is expressed as a value of a
 
726
   specialized data type <TT
 
727
CLASS="TYPE"
 
728
>query_int</TT
 
729
>.  A <I
 
730
CLASS="FIRSTTERM"
 
731
>query</I
 
732
>
 
733
   consists of integer values that are checked against the elements of
 
734
   the array, possibly combined using the operators <TT
 
735
CLASS="LITERAL"
 
736
>&amp;</TT
 
737
>
 
738
   (AND), <TT
 
739
CLASS="LITERAL"
 
740
>|</TT
 
741
> (OR), and <TT
 
742
CLASS="LITERAL"
 
743
>!</TT
 
744
> (NOT).  Parentheses
 
745
   can be used as needed.  For example,
 
746
   the query <TT
 
747
CLASS="LITERAL"
 
748
>1&amp;(2|3)</TT
 
749
> matches arrays that contain 1
 
750
   and also contain either 2 or 3.
 
751
  </P
 
752
></DIV
 
753
><DIV
 
754
CLASS="SECT2"
 
755
><H2
 
756
CLASS="SECT2"
 
757
><A
 
758
NAME="AEN130921"
 
759
>F.18.2. Index Support</A
 
760
></H2
 
761
><P
 
762
>   <TT
 
763
CLASS="FILENAME"
 
764
>intarray</TT
 
765
> provides index support for the
 
766
   <TT
 
767
CLASS="LITERAL"
 
768
>&amp;&amp;</TT
 
769
>, <TT
 
770
CLASS="LITERAL"
 
771
>@&gt;</TT
 
772
>, <TT
 
773
CLASS="LITERAL"
 
774
>&lt;@</TT
 
775
>,
 
776
   and <TT
 
777
CLASS="LITERAL"
 
778
>@@</TT
 
779
> operators, as well as regular array equality.
 
780
  </P
 
781
><P
 
782
>   Two GiST index operator classes are provided:
 
783
   <TT
 
784
CLASS="LITERAL"
 
785
>gist__int_ops</TT
 
786
> (used by default) is suitable for
 
787
   small- to medium-size data sets, while
 
788
   <TT
 
789
CLASS="LITERAL"
 
790
>gist__intbig_ops</TT
 
791
> uses a larger signature and is more
 
792
   suitable for indexing large data sets (i.e., columns containing
 
793
   a large number of distinct array values).
 
794
   The implementation uses an RD-tree data structure with
 
795
   built-in lossy compression.
 
796
  </P
 
797
><P
 
798
>   There is also a non-default GIN operator class
 
799
   <TT
 
800
CLASS="LITERAL"
 
801
>gin__int_ops</TT
 
802
> supporting the same operators.
 
803
  </P
 
804
><P
 
805
>   The choice between GiST and GIN indexing depends on the relative
 
806
   performance characteristics of GiST and GIN, which are discussed elsewhere.
 
807
   As a rule of thumb, a GIN index is faster to search than a GiST index, but
 
808
   slower to build or update; so GIN is better suited for static data and GiST
 
809
   for often-updated data.
 
810
  </P
 
811
></DIV
 
812
><DIV
 
813
CLASS="SECT2"
 
814
><H2
 
815
CLASS="SECT2"
 
816
><A
 
817
NAME="AEN130935"
 
818
>F.18.3. Example</A
 
819
></H2
 
820
><PRE
 
821
CLASS="PROGRAMLISTING"
 
822
>-- a message can be in one or more <SPAN
 
823
CLASS="QUOTE"
 
824
>"sections"</SPAN
 
825
>
 
826
CREATE TABLE message (mid INT PRIMARY KEY, sections INT[], ...);
 
827
 
 
828
-- create specialized index
 
829
CREATE INDEX message_rdtree_idx ON message USING GIST (sections gist__int_ops);
 
830
 
 
831
-- select messages in section 1 OR 2 - OVERLAP operator
 
832
SELECT message.mid FROM message WHERE message.sections &amp;&amp; '{1,2}';
 
833
 
 
834
-- select messages in sections 1 AND 2 - CONTAINS operator
 
835
SELECT message.mid FROM message WHERE message.sections @&gt; '{1,2}';
 
836
 
 
837
-- the same, using QUERY operator
 
838
SELECT message.mid FROM message WHERE message.sections @@ '1&amp;2'::query_int;</PRE
 
839
></DIV
 
840
><DIV
 
841
CLASS="SECT2"
 
842
><H2
 
843
CLASS="SECT2"
 
844
><A
 
845
NAME="AEN130939"
 
846
>F.18.4. Benchmark</A
 
847
></H2
 
848
><P
 
849
>   The source directory <TT
 
850
CLASS="FILENAME"
 
851
>contrib/intarray/bench</TT
 
852
> contains a
 
853
   benchmark test suite.  To run:
 
854
  </P
 
855
><PRE
 
856
CLASS="PROGRAMLISTING"
 
857
>cd .../bench
 
858
createdb TEST
 
859
psql TEST &lt; ../_int.sql
 
860
./create_test.pl | psql TEST
 
861
./bench.pl</PRE
 
862
><P
 
863
>   The <TT
 
864
CLASS="FILENAME"
 
865
>bench.pl</TT
 
866
> script has numerous options, which
 
867
   are displayed when it is run without any arguments.
 
868
  </P
 
869
></DIV
 
870
><DIV
 
871
CLASS="SECT2"
 
872
><H2
 
873
CLASS="SECT2"
 
874
><A
 
875
NAME="AEN130946"
 
876
>F.18.5. Authors</A
 
877
></H2
 
878
><P
 
879
>   All work was done by Teodor Sigaev (<CODE
 
880
CLASS="EMAIL"
 
881
>&#60;<A
 
882
HREF="mailto:teodor@sigaev.ru"
 
883
>teodor@sigaev.ru</A
 
884
>&#62;</CODE
 
885
>) and
 
886
   Oleg Bartunov (<CODE
 
887
CLASS="EMAIL"
 
888
>&#60;<A
 
889
HREF="mailto:oleg@sai.msu.su"
 
890
>oleg@sai.msu.su</A
 
891
>&#62;</CODE
 
892
>). See
 
893
   <A
 
894
HREF="http://www.sai.msu.su/~megera/postgres/gist/"
 
895
TARGET="_top"
 
896
>http://www.sai.msu.su/~megera/postgres/gist/</A
 
897
> for
 
898
   additional information. Andrey Oktyabrski did a great work on adding new
 
899
   functions and operations.
 
900
  </P
 
901
></DIV
 
902
></DIV
 
903
><DIV
 
904
CLASS="NAVFOOTER"
 
905
><HR
 
906
ALIGN="LEFT"
 
907
WIDTH="100%"><TABLE
 
908
SUMMARY="Footer navigation table"
 
909
WIDTH="100%"
 
910
BORDER="0"
 
911
CELLPADDING="0"
 
912
CELLSPACING="0"
 
913
><TR
 
914
><TD
 
915
WIDTH="33%"
 
916
ALIGN="left"
 
917
VALIGN="top"
 
918
><A
 
919
HREF="intagg.html"
 
920
ACCESSKEY="P"
 
921
>Prev</A
 
922
></TD
 
923
><TD
 
924
WIDTH="34%"
 
925
ALIGN="center"
 
926
VALIGN="top"
 
927
><A
 
928
HREF="index.html"
 
929
ACCESSKEY="H"
 
930
>Home</A
 
931
></TD
 
932
><TD
 
933
WIDTH="33%"
 
934
ALIGN="right"
 
935
VALIGN="top"
 
936
><A
 
937
HREF="isn.html"
 
938
ACCESSKEY="N"
 
939
>Next</A
 
940
></TD
 
941
></TR
 
942
><TR
 
943
><TD
 
944
WIDTH="33%"
 
945
ALIGN="left"
 
946
VALIGN="top"
 
947
>intagg</TD
 
948
><TD
 
949
WIDTH="34%"
 
950
ALIGN="center"
 
951
VALIGN="top"
 
952
><A
 
953
HREF="contrib.html"
 
954
ACCESSKEY="U"
 
955
>Up</A
 
956
></TD
 
957
><TD
 
958
WIDTH="33%"
 
959
ALIGN="right"
 
960
VALIGN="top"
 
961
>isn</TD
 
962
></TR
 
963
></TABLE
 
964
></DIV
 
965
></BODY
 
966
></HTML
 
967
>
 
 
b'\\ No newline at end of file'