trgm - Trigram matching for PostgreSQL

-------------------------------------- The pg_trgm contrib module provides functions and index classes for determining the similarity of text based on trigram matching.

trgm - Trigram matching for PostgreSQL
cbfa4092 · Teodor Sigaev · 553bc416 · cbfa4092 · cbfa4092 · cbfa4092
Commit cbfa4092 authored 21 years ago by Teodor Sigaev
--- a/contrib/pg_trgm/Makefile
+++ b/contrib/pg_trgm/Makefile
+subdir = contrib/pg_trgm
+top_builddir = ../..
+include $(top_builddir)/src/Makefile.global
+override CPPFLAGS := -I. $(CPPFLAGS)
+MODULE_big = pg_trgm
+OBJS = trgm_op.o trgm_gist.o 
+DATA_built = pg_trgm.sql
+DOCS = README.pg_trgm
+REGRESS = pg_trgm
+include $(top_srcdir)/contrib/contrib-global.mk
+# DO NOT DELETE
--- a/contrib/pg_trgm/README.pg_trgm
+++ b/contrib/pg_trgm/README.pg_trgm
+trgm - Trigram matching for PostgreSQL
+--------------------------------------
+Introduction
+	This module is sponsored by Delta-Soft Ltd., Moscow, Russia.
+	The pg_trgm contrib module provides functions and index classes
+	for determining the similarity of text based on trigram
+	matching.
+Definitions
+	Trigram (or Trigraph)
+	A trigram is a set of three consecutive characters taken
+	from a string.  A string is considered to have two spaces
+	prefixed and one space suffixed when determining the set
+	of trigrams that comprise the string.
+	eg. The set of trigrams in the word "cat" is "  c", " ca", 
+	"at " and "cat".
+Public Functions
+	real similarity(text, text)
+	Returns a number that indicates how closely matches the two
+	arguments are.  A zero result indicates that the two words
+	are completely dissimilar, and a result of one indicates that
+	the two words are identical.
+	real show_limit()
+	Returns the current similarity threshold used by the '%'
+	operator.  This in effect sets the minimum similarity between
+	two words in order that they be considered similar enough to
+	be misspellings of each other, for example.
+	real set_limit(real)
+	Sets the current similarity threshold that is used by the '%'
+	operator, and is returned by the show_limit() function.
+	text[] show_trgm(text)
+	Returns an array of all the trigrams of the supplied text
+	parameter.
+Public Operators
+	text % text (returns boolean)
+	The '%' operator returns TRUE if its two arguments have a similarity
+	that is greater than the similarity threshold set by set_limit(). It
+	will return FALSE if the similarity is less than the current
+	threshold.
+Public Index Operator Classes
+	gist_trgm_ops
+	The pg_trgm module comes with an index operator class that allows a
+	developer to create an index over a text column for the purpose
+	of very fast similarity searches.
+	To use this index, the '%' operator must be used and an appropriate
+	similarity threshold for the application must be set.
+	eg.
+	CREATE TABLE test_trgm (t text);
+	CREATE INDEX trgm_idx ON test_trgm USING gist (t gist_trgm_ops);
+	At this point, you will have an index on the t text column that you
+	can use for similarity searching.
+	eg.
+	SELECT
+		t,
+		similarity(t, 'word') AS sml
+	FROM
+		test_trgm
+	WHERE
+		t % 'word'
+	ORDER BY
+		sml DESC, t;
+	This will return all values in the text column that are sufficiently
+	similar to 'word', sorted from best match to worst.  The index will
+	be used to make this a fast operation over very large data sets.
+Tsearch2 Integration
+	Trigram matching is a very useful tool when used in conjunction
+	with a text index created by the Tsearch2 contrib module. (See
+	contrib/tsearch2)
+	The first step is to generate an auxiliary table containing all
+	the unique words in the Tsearch2 index:
+	CREATE TABLE words AS 
+		SELECT word FROM stat('SELECT vector FROM documents');
+	Where 'documents' is the table that contains the Tsearch2 index
+	column 'vector', of type 'tsvector'.
+	Next, create a trigram index on the word column:
+	CREATE INDEX words_idx ON words USING gist(word gist_trgm_ops);
+	Now, a SELECT query similar to the example above can be used to
+	suggest spellings for misspelled words in user search terms. A
+	useful extra clause is to ensure that the similar words are also
+	of similar length to the misspelled word.
+	Note: Since the 'words' table has been generated as a separate,
+	static table, it will need to be periodically regenerated so that
+	it remains up to date with the word list in the Tsearch2 index.
+Authors
+	Oleg Bartunov <oleg@sai.msu.su>, Moscow, Moscow University, Russia
+	Teodor Sigaev <teodor@sigaev.ru>, Moscow, Delta-Soft Ltd.,Russia
+Contributors
+	Christopher Kings-Lynne wrote this README file
+References
+	Tsearch2 Development Site
+	http://www.sai.msu.su/~megera/postgres/gist/tsearch/V2/
+	GiST Development Site
+	http://www.sai.msu.su/~megera/postgres/gist/
--- a/contrib/pg_trgm/data/trgm.data
+++ b/contrib/pg_trgm/data/trgm.data
+qwertyu0001
+qwertyu0002
+qwertyu0003
+qwertyu0004
+qwertyu0005
+qwertyu0006
+qwertyu0007
+qwertyu0008
+qwertyu0009
+qwertyu0010
+qwertyu0011
+qwertyu0012
+qwertyu0013
+qwertyu0014
+qwertyu0015
+qwertyu0016
+qwertyu0017
+qwertyu0018
+qwertyu0019
+qwertyu0020
+qwertyu0021
+qwertyu0022
+qwertyu0023
+qwertyu0024
+qwertyu0025
+qwertyu0026
+qwertyu0027
+qwertyu0028
+qwertyu0029
+qwertyu0030
+qwertyu0031
+qwertyu0032
+qwertyu0033
+qwertyu0034
+qwertyu0035
+qwertyu0036
+qwertyu0037
+qwertyu0038
+qwertyu0039
+qwertyu0040
+qwertyu0041
+qwertyu0042
+qwertyu0043
+qwertyu0044
+qwertyu0045
+qwertyu0046
+qwertyu0047
+qwertyu0048
+qwertyu0049
+qwertyu0050
+qwertyu0051
+qwertyu0052
+qwertyu0053
+qwertyu0054
+qwertyu0055
+qwertyu0056
+qwertyu0057
+qwertyu0058
+qwertyu0059
+qwertyu0060
+qwertyu0061
+qwertyu0062
+qwertyu0063
+qwertyu0064
+qwertyu0065
+qwertyu0066
+qwertyu0067
+qwertyu0068
+qwertyu0069
+qwertyu0070
+qwertyu0071
+qwertyu0072
+qwertyu0073
+qwertyu0074
+qwertyu0075
+qwertyu0076
+qwertyu0077
+qwertyu0078
+qwertyu0079
+qwertyu0080
+qwertyu0081
+qwertyu0082
+qwertyu0083
+qwertyu0084
+qwertyu0085
+qwertyu0086
+qwertyu0087
+qwertyu0088
+qwertyu0089
+qwertyu0090
+qwertyu0091
+qwertyu0092
+qwertyu0093
+qwertyu0094
+qwertyu0095
+qwertyu0096
+qwertyu0097
+qwertyu0098
+qwertyu0099
+qwertyu0100
+qwertyu0101
+qwertyu0102
+qwertyu0103
+qwertyu0104
+qwertyu0105
+qwertyu0106
+qwertyu0107
+qwertyu0108
+qwertyu0109
+qwertyu0110
+qwertyu0111
+qwertyu0112
+qwertyu0113
+qwertyu0114
+qwertyu0115
+qwertyu0116
+qwertyu0117
+qwertyu0118
+qwertyu0119
+qwertyu0120
+qwertyu0121
+qwertyu0122
+qwertyu0123
+qwertyu0124
+qwertyu0125
+qwertyu0126
+qwertyu0127
+qwertyu0128
+qwertyu0129
+qwertyu0130
+qwertyu0131
+qwertyu0132
+qwertyu0133
+qwertyu0134
+qwertyu0135
+qwertyu0136
+qwertyu0137
+qwertyu0138
+qwertyu0139
+qwertyu0140
+qwertyu0141
+qwertyu0142
+qwertyu0143
+qwertyu0144
+qwertyu0145
+qwertyu0146
+qwertyu0147
+qwertyu0148
+qwertyu0149
+qwertyu0150
+qwertyu0151
+qwertyu0152
+qwertyu0153
+qwertyu0154
+qwertyu0155
+qwertyu0156
+qwertyu0157
+qwertyu0158
+qwertyu0159
+qwertyu0160
+qwertyu0161
+qwertyu0162
+qwertyu0163
+qwertyu0164
+qwertyu0165
+qwertyu0166
+qwertyu0167
+qwertyu0168
+qwertyu0169
+qwertyu0170
+qwertyu0171
+qwertyu0172
+qwertyu0173
+qwertyu0174
+qwertyu0175
+qwertyu0176
+qwertyu0177
+qwertyu0178
+qwertyu0179
+qwertyu0180
+qwertyu0181
+qwertyu0182
+qwertyu0183
+qwertyu0184
+qwertyu0185
+qwertyu0186
+qwertyu0187
+qwertyu0188
+qwertyu0189
+qwertyu0190
+qwertyu0191
+qwertyu0192
+qwertyu0193
+qwertyu0194
+qwertyu0195
+qwertyu0196
+qwertyu0197
+qwertyu0198
+qwertyu0199
+qwertyu0200
+qwertyu0201
+qwertyu0202
+qwertyu0203
+qwertyu0204
+qwertyu0205
+qwertyu0206
+qwertyu0207
+qwertyu0208
+qwertyu0209
+qwertyu0210
+qwertyu0211
+qwertyu0212
+qwertyu0213
+qwertyu0214
+qwertyu0215
+qwertyu0216
+qwertyu0217
+qwertyu0218
+qwertyu0219
+qwertyu0220
+qwertyu0221
+qwertyu0222
+qwertyu0223
+qwertyu0224
+qwertyu0225
+qwertyu0226
+qwertyu0227
+qwertyu0228
+qwertyu0229
+qwertyu0230
+qwertyu0231
+qwertyu0232
+qwertyu0233
+qwertyu0234
+qwertyu0235
+qwertyu0236
+qwertyu0237
+qwertyu0238
+qwertyu0239
+qwertyu0240
+qwertyu0241
+qwertyu0242
+qwertyu0243
+qwertyu0244
+qwertyu0245
+qwertyu0246
+qwertyu0247
+qwertyu0248
+qwertyu0249
+qwertyu0250
+qwertyu0251
+qwertyu0252
+qwertyu0253
+qwertyu0254
+qwertyu0255
+qwertyu0256
+qwertyu0257
+qwertyu0258
+qwertyu0259
+qwertyu0260
+qwertyu0261
+qwertyu0262
+qwertyu0263
+qwertyu0264
+qwertyu0265
+qwertyu0266
+qwertyu0267
+qwertyu0268
+qwertyu0269
+qwertyu0270
+qwertyu0271
+qwertyu0272
+qwertyu0273
+qwertyu0274
+qwertyu0275
+qwertyu0276
+qwertyu0277
+qwertyu0278
+qwertyu0279
+qwertyu0280
+qwertyu0281
+qwertyu0282
+qwertyu0283
+qwertyu0284
+qwertyu0285
+qwertyu0286
+qwertyu0287
+qwertyu0288
+qwertyu0289
+qwertyu0290
+qwertyu0291
+qwertyu0292
+qwertyu0293
+qwertyu0294
+qwertyu0295
+qwertyu0296
+qwertyu0297
+qwertyu0298
+qwertyu0299
+qwertyu0300
+qwertyu0301
+qwertyu0302
+qwertyu0303
+qwertyu0304
+qwertyu0305
+qwertyu0306
+qwertyu0307
+qwertyu0308
+qwertyu0309
+qwertyu0310
+qwertyu0311
+qwertyu0312
+qwertyu0313
+qwertyu0314
+qwertyu0315
+qwertyu0316
+qwertyu0317
+qwertyu0318
+qwertyu0319
+qwertyu0320
+qwertyu0321
+qwertyu0322
+qwertyu0323
+qwertyu0324
+qwertyu0325
+qwertyu0326
+qwertyu0327
+qwertyu0328
+qwertyu0329
+qwertyu0330
+qwertyu0331
+qwertyu0332
+qwertyu0333
+qwertyu0334
+qwertyu0335
+qwertyu0336
+qwertyu0337
+qwertyu0338
+qwertyu0339
+qwertyu0340
+qwertyu0341
+qwertyu0342
+qwertyu0343
+qwertyu0344
+qwertyu0345
+qwertyu0346
+qwertyu0347
+qwertyu0348
+qwertyu0349
+qwertyu0350
+qwertyu0351
+qwertyu0352
+qwertyu0353
+qwertyu0354
+qwertyu0355
+qwertyu0356
+qwertyu0357
+qwertyu0358
+qwertyu0359
+qwertyu0360
+qwertyu0361
+qwertyu0362
+qwertyu0363
+qwertyu0364
+qwertyu0365
+qwertyu0366
+qwertyu0367
+qwertyu0368
+qwertyu0369
+qwertyu0370
+qwertyu0371
+qwertyu0372
+qwertyu0373
+qwertyu0374
+qwertyu0375
+qwertyu0376
+qwertyu0377
+qwertyu0378
+qwertyu0379
+qwertyu0380
+qwertyu0381
+qwertyu0382
+qwertyu0383
+qwertyu0384
+qwertyu0385
+qwertyu0386
+qwertyu0387
+qwertyu0388
+qwertyu0389
+qwertyu0390
+qwertyu0391
+qwertyu0392
+qwertyu0393
+qwertyu0394
+qwertyu0395
+qwertyu0396
+qwertyu0397
+qwertyu0398
+qwertyu0399
+qwertyu0400
+qwertyu0401
+qwertyu0402
+qwertyu0403
+qwertyu0404
+qwertyu0405
+qwertyu0406
+qwertyu0407
+qwertyu0408
+qwertyu0409
+qwertyu0410
+qwertyu0411
+qwertyu0412
+qwertyu0413
+qwertyu0414
+qwertyu0415
+qwertyu0416
+qwertyu0417
+qwertyu0418
+qwertyu0419
+qwertyu0420
+qwertyu0421
+qwertyu0422
+qwertyu0423
+qwertyu0424
+qwertyu0425
+qwertyu0426
+qwertyu0427
+qwertyu0428
+qwertyu0429
+qwertyu0430
+qwertyu0431
+qwertyu0432
+qwertyu0433
+qwertyu0434
+qwertyu0435
+qwertyu0436
+qwertyu0437
+qwertyu0438
+qwertyu0439
+qwertyu0440
+qwertyu0441
+qwertyu0442
+qwertyu0443
+qwertyu0444
+qwertyu0445
+qwertyu0446
+qwertyu0447
+qwertyu0448
+qwertyu0449
+qwertyu0450
+qwertyu0451
+qwertyu0452
+qwertyu0453
+qwertyu0454
+qwertyu0455
+qwertyu0456
+qwertyu0457
+qwertyu0458
+qwertyu0459
+qwertyu0460
+qwertyu0461
+qwertyu0462
+qwertyu0463
+qwertyu0464
+qwertyu0465
+qwertyu0466
+qwertyu0467
+qwertyu0468
+qwertyu0469
+qwertyu0470
+qwertyu0471
+qwertyu0472
+qwertyu0473
+qwertyu0474
+qwertyu0475
+qwertyu0476
+qwertyu0477
+qwertyu0478
+qwertyu0479
+qwertyu0480
+qwertyu0481
+qwertyu0482
+qwertyu0483
+qwertyu0484
+qwertyu0485
+qwertyu0486
+qwertyu0487
+qwertyu0488
+qwertyu0489
+qwertyu0490
+qwertyu0491
+qwertyu0492
+qwertyu0493
+qwertyu0494
+qwertyu0495
+qwertyu0496
+qwertyu0497
+qwertyu0498
+qwertyu0499
+qwertyu0500
+qwertyu0501
+qwertyu0502
+qwertyu0503
+qwertyu0504
+qwertyu0505
+qwertyu0506
+qwertyu0507
+qwertyu0508
+qwertyu0509
+qwertyu0510
+qwertyu0511
+qwertyu0512
+qwertyu0513
+qwertyu0514
+qwertyu0515
+qwertyu0516
+qwertyu0517
+qwertyu0518
+qwertyu0519
+qwertyu0520
+qwertyu0521
+qwertyu0522
+qwertyu0523
+qwertyu0524
+qwertyu0525
+qwertyu0526
+qwertyu0527
+qwertyu0528
+qwertyu0529
+qwertyu0530
+qwertyu0531
+qwertyu0532
+qwertyu0533
+qwertyu0534
+qwertyu0535
+qwertyu0536
+qwertyu0537
+qwertyu0538
+qwertyu0539
+qwertyu0540
+qwertyu0541
+qwertyu0542
+qwertyu0543
+qwertyu0544
+qwertyu0545
+qwertyu0546
+qwertyu0547
+qwertyu0548
+qwertyu0549
+qwertyu0550
+qwertyu0551
+qwertyu0552
+qwertyu0553
+qwertyu0554
+qwertyu0555
+qwertyu0556
+qwertyu0557
+qwertyu0558
+qwertyu0559
+qwertyu0560
+qwertyu0561
+qwertyu0562
+qwertyu0563
+qwertyu0564
+qwertyu0565
+qwertyu0566
+qwertyu0567
+qwertyu0568
+qwertyu0569
+qwertyu0570
+qwertyu0571
+qwertyu0572
+qwertyu0573
+qwertyu0574
+qwertyu0575
+qwertyu0576
+qwertyu0577
+qwertyu0578
+qwertyu0579
+qwertyu0580
+qwertyu0581
+qwertyu0582
+qwertyu0583
+qwertyu0584
+qwertyu0585
+qwertyu0586
+qwertyu0587
+qwertyu0588
+qwertyu0589
+qwertyu0590
+qwertyu0591
+qwertyu0592
+qwertyu0593
+qwertyu0594
+qwertyu0595
+qwertyu0596
+qwertyu0597
+qwertyu0598
+qwertyu0599
+qwertyu0600
+qwertyu0601
+qwertyu0602
+qwertyu0603
+qwertyu0604
+qwertyu0605
+qwertyu0606
+qwertyu0607
+qwertyu0608
+qwertyu0609
+qwertyu0610
+qwertyu0611
+qwertyu0612
+qwertyu0613
+qwertyu0614
+qwertyu0615
+qwertyu0616
+qwertyu0617
+qwertyu0618
+qwertyu0619
+qwertyu0620
+qwertyu0621
+qwertyu0622
+qwertyu0623
+qwertyu0624
+qwertyu0625
+qwertyu0626
+qwertyu0627
+qwertyu0628
+qwertyu0629
+qwertyu0630
+qwertyu0631
+qwertyu0632
+qwertyu0633
+qwertyu0634
+qwertyu0635
+qwertyu0636
+qwertyu0637
+qwertyu0638
+qwertyu0639
+qwertyu0640
+qwertyu0641
+qwertyu0642
+qwertyu0643
+qwertyu0644
+qwertyu0645
+qwertyu0646
+qwertyu0647
+qwertyu0648
+qwertyu0649
+qwertyu0650
+qwertyu0651
+qwertyu0652
+qwertyu0653
+qwertyu0654
+qwertyu0655
+qwertyu0656
+qwertyu0657
+qwertyu0658
+qwertyu0659
+qwertyu0660
+qwertyu0661
+qwertyu0662
+qwertyu0663
+qwertyu0664
+qwertyu0665
+qwertyu0666
+qwertyu0667
+qwertyu0668
+qwertyu0669
+qwertyu0670
+qwertyu0671
+qwertyu0672
+qwertyu0673
+qwertyu0674
+qwertyu0675
+qwertyu0676
+qwertyu0677
+qwertyu0678
+qwertyu0679
+qwertyu0680
+qwertyu0681
+qwertyu0682
+qwertyu0683
+qwertyu0684
+qwertyu0685
+qwertyu0686
+qwertyu0687
+qwertyu0688
+qwertyu0689
+qwertyu0690
+qwertyu0691
+qwertyu0692
+qwertyu0693
+qwertyu0694
+qwertyu0695
+qwertyu0696
+qwertyu0697
+qwertyu0698
+qwertyu0699
+qwertyu0700
+qwertyu0701
+qwertyu0702
+qwertyu0703
+qwertyu0704
+qwertyu0705
+qwertyu0706
+qwertyu0707
+qwertyu0708
+qwertyu0709
+qwertyu0710
+qwertyu0711
+qwertyu0712
+qwertyu0713
+qwertyu0714
+qwertyu0715
+qwertyu0716
+qwertyu0717
+qwertyu0718
+qwertyu0719
+qwertyu0720
+qwertyu0721
+qwertyu0722
+qwertyu0723
+qwertyu0724
+qwertyu0725
+qwertyu0726
+qwertyu0727
+qwertyu0728
+qwertyu0729
+qwertyu0730
+qwertyu0731
+qwertyu0732
+qwertyu0733
+qwertyu0734
+qwertyu0735
+qwertyu0736
+qwertyu0737
+qwertyu0738
+qwertyu0739
+qwertyu0740
+qwertyu0741
+qwertyu0742
+qwertyu0743
+qwertyu0744
+qwertyu0745
+qwertyu0746
+qwertyu0747
+qwertyu0748
+qwertyu0749
+qwertyu0750
+qwertyu0751
+qwertyu0752
+qwertyu0753
+qwertyu0754
+qwertyu0755
+qwertyu0756
+qwertyu0757
+qwertyu0758
+qwertyu0759
+qwertyu0760
+qwertyu0761
+qwertyu0762
+qwertyu0763
+qwertyu0764
+qwertyu0765
+qwertyu0766
+qwertyu0767
+qwertyu0768
+qwertyu0769
+qwertyu0770
+qwertyu0771
+qwertyu0772
+qwertyu0773
+qwertyu0774
+qwertyu0775
+qwertyu0776
+qwertyu0777
+qwertyu0778
+qwertyu0779
+qwertyu0780
+qwertyu0781
+qwertyu0782
+qwertyu0783
+qwertyu0784
+qwertyu0785
+qwertyu0786
+qwertyu0787
+qwertyu0788
+qwertyu0789
+qwertyu0790
+qwertyu0791
+qwertyu0792
+qwertyu0793
+qwertyu0794
+qwertyu0795
+qwertyu0796
+qwertyu0797
+qwertyu0798
+qwertyu0799
+qwertyu0800
+qwertyu0801
+qwertyu0802
+qwertyu0803
+qwertyu0804
+qwertyu0805
+qwertyu0806
+qwertyu0807
+qwertyu0808
+qwertyu0809
+qwertyu0810
+qwertyu0811
+qwertyu0812
+qwertyu0813
+qwertyu0814
+qwertyu0815
+qwertyu0816
+qwertyu0817
+qwertyu0818
+qwertyu0819
+qwertyu0820
+qwertyu0821
+qwertyu0822
+qwertyu0823
+qwertyu0824
+qwertyu0825
+qwertyu0826
+qwertyu0827
+qwertyu0828
+qwertyu0829
+qwertyu0830
+qwertyu0831
+qwertyu0832
+qwertyu0833
+qwertyu0834
+qwertyu0835
+qwertyu0836
+qwertyu0837
+qwertyu0838
+qwertyu0839
+qwertyu0840
+qwertyu0841
+qwertyu0842
+qwertyu0843
+qwertyu0844
+qwertyu0845
+qwertyu0846
+qwertyu0847
+qwertyu0848
+qwertyu0849
+qwertyu0850
+qwertyu0851
+qwertyu0852
+qwertyu0853
+qwertyu0854
+qwertyu0855
+qwertyu0856
+qwertyu0857
+qwertyu0858
+qwertyu0859
+qwertyu0860
+qwertyu0861
+qwertyu0862
+qwertyu0863
+qwertyu0864
+qwertyu0865
+qwertyu0866
+qwertyu0867
+qwertyu0868
+qwertyu0869
+qwertyu0870
+qwertyu0871
+qwertyu0872
+qwertyu0873
+qwertyu0874
+qwertyu0875
+qwertyu0876
+qwertyu0877
+qwertyu0878
+qwertyu0879
+qwertyu0880
+qwertyu0881
+qwertyu0882
+qwertyu0883
+qwertyu0884
+qwertyu0885
+qwertyu0886
+qwertyu0887
+qwertyu0888
+qwertyu0889
+qwertyu0890
+qwertyu0891
+qwertyu0892
+qwertyu0893
+qwertyu0894
+qwertyu0895
+qwertyu0896
+qwertyu0897
+qwertyu0898
+qwertyu0899
+qwertyu0900
+qwertyu0901
+qwertyu0902
+qwertyu0903
+qwertyu0904
+qwertyu0905
+qwertyu0906
+qwertyu0907
+qwertyu0908
+qwertyu0909
+qwertyu0910
+qwertyu0911
+qwertyu0912
+qwertyu0913
+qwertyu0914
+qwertyu0915
+qwertyu0916
+qwertyu0917
+qwertyu0918
+qwertyu0919
+qwertyu0920
+qwertyu0921
+qwertyu0922
+qwertyu0923
+qwertyu0924
+qwertyu0925
+qwertyu0926
+qwertyu0927
+qwertyu0928
+qwertyu0929
+qwertyu0930
+qwertyu0931
+qwertyu0932
+qwertyu0933
+qwertyu0934
+qwertyu0935
+qwertyu0936
+qwertyu0937
+qwertyu0938
+qwertyu0939
+qwertyu0940
+qwertyu0941
+qwertyu0942
+qwertyu0943
+qwertyu0944
+qwertyu0945
+qwertyu0946
+qwertyu0947
+qwertyu0948
+qwertyu0949
+qwertyu0950
+qwertyu0951
+qwertyu0952
+qwertyu0953
+qwertyu0954
+qwertyu0955
+qwertyu0956
+qwertyu0957
+qwertyu0958
+qwertyu0959
+qwertyu0960
+qwertyu0961
+qwertyu0962
+qwertyu0963
+qwertyu0964
+qwertyu0965
+qwertyu0966
+qwertyu0967
+qwertyu0968
+qwertyu0969
+qwertyu0970
+qwertyu0971
+qwertyu0972
+qwertyu0973
+qwertyu0974
+qwertyu0975
+qwertyu0976
+qwertyu0977
+qwertyu0978
+qwertyu0979
+qwertyu0980
+qwertyu0981
+qwertyu0982
+qwertyu0983
+qwertyu0984
+qwertyu0985
+qwertyu0986
+qwertyu0987
+qwertyu0988
+qwertyu0989
+qwertyu0990
+qwertyu0991
+qwertyu0992
+qwertyu0993
+qwertyu0994
+qwertyu0995
+qwertyu0996
+qwertyu0997
+qwertyu0998
+qwertyu0999
+qwertyu1000
--- a/contrib/pg_trgm/expected/pg_trgm.out
+++ b/contrib/pg_trgm/expected/pg_trgm.out
--- a/contrib/pg_trgm/pg_trgm.sql.in
+++ b/contrib/pg_trgm/pg_trgm.sql.in
+SET search_path = public;
+BEGIN;
+create function set_limit(float4)
+returns float4
+AS 'MODULE_PATHNAME'
+LANGUAGE 'C' with (isstrict,iscachable);
+create function show_limit()
+returns float4
+AS 'MODULE_PATHNAME'
+LANGUAGE 'C' with (isstrict,iscachable);
+create function show_trgm(text)
+returns _text
+AS 'MODULE_PATHNAME'
+LANGUAGE 'C' with (isstrict,iscachable);
+create function similarity(text,text)
+returns float4
+AS 'MODULE_PATHNAME'
+LANGUAGE 'C' with (isstrict,iscachable);
+create function similarity_op(text,text)
+returns bool
+AS 'MODULE_PATHNAME'
+LANGUAGE 'C' with (isstrict,iscachable);
+CREATE OPERATOR % (
+        LEFTARG = text,
+        RIGHTARG = text,
+        PROCEDURE = similarity_op,
+        COMMUTATOR = '%',
+        RESTRICT = contsel,
+        JOIN = contjoinsel
+);
+--gist key
+CREATE FUNCTION gtrgm_in(cstring)
+RETURNS gtrgm
+AS 'MODULE_PATHNAME'
+LANGUAGE 'C' with (isstrict);
+CREATE FUNCTION gtrgm_out(gtrgm)
+RETURNS cstring
+AS 'MODULE_PATHNAME'
+LANGUAGE 'C' with (isstrict);
+CREATE TYPE gtrgm (
+        INTERNALLENGTH = -1,
+        INPUT = gtrgm_in,
+        OUTPUT = gtrgm_out
+);
+-- support functions
+CREATE FUNCTION gtrgm_consistent(gtrgm,internal,int4)
+RETURNS bool
+AS 'MODULE_PATHNAME'
+LANGUAGE 'C';
+CREATE FUNCTION gtrgm_compress(internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE 'C';
+CREATE FUNCTION gtrgm_decompress(internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE 'C';
+CREATE FUNCTION gtrgm_penalty(internal,internal,internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE 'C' with (isstrict);
+CREATE FUNCTION gtrgm_picksplit(internal, internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE 'C';
+CREATE FUNCTION gtrgm_union(bytea, internal)
+RETURNS _int4
+AS 'MODULE_PATHNAME'
+LANGUAGE 'C';
+CREATE FUNCTION gtrgm_same(gtrgm, gtrgm, internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE 'C';
+-- create the operator class
+CREATE OPERATOR CLASS gist_trgm_ops
+FOR TYPE text USING gist
+AS
+        OPERATOR        1       % (text, text),
+        FUNCTION        1       gtrgm_consistent (gtrgm, internal, int4),
+        FUNCTION        2       gtrgm_union (bytea, internal),
+        FUNCTION        3       gtrgm_compress (internal),
+        FUNCTION        4       gtrgm_decompress (internal),
+        FUNCTION        5       gtrgm_penalty (internal, internal, internal),
+        FUNCTION        6       gtrgm_picksplit (internal, internal),
+        FUNCTION        7       gtrgm_same (gtrgm, gtrgm, internal),
+        STORAGE         gtrgm;
+COMMIT;
--- a/contrib/pg_trgm/sql/pg_trgm.sql
+++ b/contrib/pg_trgm/sql/pg_trgm.sql
+\set ECHO none
+\i pg_trgm.sql
+\set ECHO all
+select show_trgm('');
+select show_trgm('(*&^$@%@');
+select show_trgm('a b c');
+select show_trgm(' a b c ');
+select show_trgm('aA bB cC');
+select show_trgm(' aA bB cC ');
+select show_trgm('a b C0*%^');
+select similarity('wow','WOWa ');
+select similarity('wow',' WOW ');
+CREATE TABLE test_trgm(t text);
+\copy test_trgm from 'data/trgm.data
+select t,similarity(t,'qwertyu0988') as sml from test_trgm where t % 'qwertyu0988' order by sml desc, t;
+select t,similarity(t,'gwertyu0988') as sml from test_trgm where t % 'gwertyu0988' order by sml desc, t;
+select t,similarity(t,'gwertyu1988') as sml from test_trgm where t % 'gwertyu1988' order by sml desc, t;
+create index trgm_idx on test_trgm using gist (t gist_trgm_ops);
+set enable_seqscan=off;
+select t,similarity(t,'qwertyu0988') as sml from test_trgm where t % 'qwertyu0988' order by sml desc, t;
+select t,similarity(t,'gwertyu0988') as sml from test_trgm where t % 'gwertyu0988' order by sml desc, t;
+select t,similarity(t,'gwertyu1988') as sml from test_trgm where t % 'gwertyu1988' order by sml desc, t;
--- a/contrib/pg_trgm/trgm.h
+++ b/contrib/pg_trgm/trgm.h
+#ifndef __TRGM_H__
+#define __TRGM_H__
+#include "postgres.h"
+#include "access/gist.h"
+#include "access/itup.h"
+#include "utils/elog.h"
+#include "utils/palloc.h"
+#include "utils/builtins.h"
+#include "storage/bufpage.h"
+/* options */
+#define LPADDING        2
+#define RPADDING        1
+#define KEEPONLYALNUM
+#define IGNORECASE  
+#define DIVUNION
+typedef char trgm[3];
+#define CMPCHAR(a,b) ( ((a)==(b)) ? 0 : ( ((a)<(b)) ? -1 : 1 ) )
+#define CMPPCHAR(a,b,i)  CMPCHAR( *(((char*)(a))+i), *(((char*)(b))+i) ) 
+#define CMPTRGM(a,b) ( CMPPCHAR(a,b,0) ? CMPPCHAR(a,b,0) : ( CMPPCHAR(a,b,1) ? CMPPCHAR(a,b,1) : CMPPCHAR(a,b,2) ) )
+#define CPTRGM(a,b) do {		      	\
+	*(((char*)(a))+0) = *(((char*)(b))+0);	\
+	*(((char*)(a))+1) = *(((char*)(b))+1);	\
+	*(((char*)(a))+2) = *(((char*)(b))+2);	\
+} while(0);
+typedef struct {
+	int4	len;
+	uint8	flag;
+	char	data[1];
+} TRGM;
+#define TRGMHRDSIZE       (sizeof(int4)+sizeof(uint8))
+/* gist */
+#define BITBYTE 8
+#define SIGLENINT  3               /* >122 => key will toast, so very slow!!! */
+#define SIGLEN  ( sizeof(int)*SIGLENINT )
+#define SIGLENBIT (SIGLEN*BITBYTE - 1) /* see makesign */ 
+typedef char BITVEC[SIGLEN];
+typedef char *BITVECP;
+#define LOOPBYTE(a) \
+                for(i=0;i<SIGLEN;i++) {\
+                                a;\
+                }
+#define LOOPBIT(a) \
+                for(i=0;i<SIGLENBIT;i++) {\
+                                a;\
+                }
+#define GETBYTE(x,i) ( *( (BITVECP)(x) + (int)( (i) / BITBYTE ) ) )
+#define GETBITBYTE(x,i) ( ((char)(x)) >> i & 0x01 )
+#define CLRBIT(x,i)   GETBYTE(x,i) &= ~( 0x01 << ( (i) % BITBYTE ) )
+#define SETBIT(x,i)   GETBYTE(x,i) |=  ( 0x01 << ( (i) % BITBYTE ) )
+#define GETBIT(x,i) ( (GETBYTE(x,i) >> ( (i) % BITBYTE )) & 0x01 )
+#define HASHVAL(val) (((unsigned int)(val)) % SIGLENBIT)
+#define HASH(sign, val) SETBIT((sign), HASHVAL(val))
+#define ARRKEY          0x01
+#define SIGNKEY         0x02
+#define ALLISTRUE       0x04
+#define ISARRKEY(x) ( ((TRGM*)x)->flag & ARRKEY )
+#define ISSIGNKEY(x)    ( ((TRGM*)x)->flag & SIGNKEY )
+#define ISALLTRUE(x)    ( ((TRGM*)x)->flag & ALLISTRUE )
+#define CALCGTSIZE(flag, len) ( TRGMHRDSIZE + ( ( (flag) & ARRKEY ) ? ((len)*sizeof(trgm)) : (((flag) & ALLISTRUE) ? 0 : SIGLEN) ) )
+#define GETSIGN(x)      ( (BITVECP)( (char*)x+TRGMHRDSIZE ) )
+#define GETARR(x)       ( (trgm*)( (char*)x+TRGMHRDSIZE ) )
+#define ARRNELEM(x) ( ( ((TRGM*)x)->len - TRGMHRDSIZE )/sizeof(trgm) )
+extern float4 trgm_limit;
+TRGM* generate_trgm(char *str, int slen);
+float4 cnt_sml(TRGM *trg1, TRGM *trg2);
+#endif
--- a/contrib/pg_trgm/trgm_gist.c
+++ b/contrib/pg_trgm/trgm_gist.c
+#include "trgm.h"
+#include "access/gist.h"
+#include "access/itup.h"
+#include "access/rtree.h"
+#include "utils/elog.h"
+#include "utils/palloc.h"
+#include "utils/array.h"
+#include "utils/builtins.h"
+#include "storage/bufpage.h"
+#include "access/tuptoaster.h"
+PG_FUNCTION_INFO_V1(gtrgm_in);
+Datum		gtrgm_in(PG_FUNCTION_ARGS);
+PG_FUNCTION_INFO_V1(gtrgm_out);
+Datum		gtrgm_out(PG_FUNCTION_ARGS);
+PG_FUNCTION_INFO_V1(gtrgm_compress);
+Datum		gtrgm_compress(PG_FUNCTION_ARGS);
+PG_FUNCTION_INFO_V1(gtrgm_decompress);
+Datum		gtrgm_decompress(PG_FUNCTION_ARGS);
+PG_FUNCTION_INFO_V1(gtrgm_consistent);
+Datum		gtrgm_consistent(PG_FUNCTION_ARGS);
+PG_FUNCTION_INFO_V1(gtrgm_union);
+Datum		gtrgm_union(PG_FUNCTION_ARGS);
+PG_FUNCTION_INFO_V1(gtrgm_same);
+Datum		gtrgm_same(PG_FUNCTION_ARGS);
+PG_FUNCTION_INFO_V1(gtrgm_penalty);
+Datum		gtrgm_penalty(PG_FUNCTION_ARGS);
+PG_FUNCTION_INFO_V1(gtrgm_picksplit);
+Datum		gtrgm_picksplit(PG_FUNCTION_ARGS);
+#define GETENTRY(vec,pos) ((TRGM *) DatumGetPointer((vec)->vector[(pos)].key))
+#define SUMBIT(val) (		 \
+	GETBITBYTE(val,0) + \
+	GETBITBYTE(val,1) + \
+	GETBITBYTE(val,2) + \
+	GETBITBYTE(val,3) + \
+	GETBITBYTE(val,4) + \
+	GETBITBYTE(val,5) + \
+	GETBITBYTE(val,6) + \
+	GETBITBYTE(val,7)	\
+)
+Datum
+gtrgm_in(PG_FUNCTION_ARGS)
+{
+	elog(ERROR, "Not implemented");
+	PG_RETURN_DATUM(0);
+}
+Datum
+gtrgm_out(PG_FUNCTION_ARGS)
+{
+	elog(ERROR, "Not implemented");
+	PG_RETURN_DATUM(0);
+}
+static void
+makesign(BITVECP sign, TRGM * a)
+{
+	int4		k,
+				len = ARRNELEM(a);
+	trgm	   *ptr = GETARR(a);
+	int4 tmp=0;
+	MemSet((void *) sign, 0, sizeof(BITVEC));
+	SETBIT(sign, SIGLENBIT); /*set last unused bit*/
+	for (k = 0; k < len; k++) {
+		CPTRGM( ((char*)&tmp), ptr+k );
+		HASH(sign, tmp);
+	}
+}
+Datum
+gtrgm_compress(PG_FUNCTION_ARGS)
+{
+	GISTENTRY  *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
+	GISTENTRY  *retval = entry;
+	if (entry->leafkey)
+	{							/* trgm */
+		TRGM   *res;
+		text	   *toastedval = (text *) DatumGetPointer(entry->key);
+		text	   *val = (text *) DatumGetPointer(PG_DETOAST_DATUM(entry->key));
+		res = generate_trgm(VARDATA(val), VARSIZE(val) - VARHDRSZ);
+		if (val != toastedval)
+			pfree(val);
+		retval = (GISTENTRY *) palloc(sizeof(GISTENTRY));
+		gistentryinit(*retval, PointerGetDatum(res),
+					  entry->rel, entry->page,
+					  entry->offset, res->len, FALSE);
+	}
+	else if (ISSIGNKEY(DatumGetPointer(entry->key)) &&
+			 !ISALLTRUE(DatumGetPointer(entry->key)))
+	{
+		int4		i,
+					len;
+		TRGM   *res;
+		BITVECP		sign = GETSIGN(DatumGetPointer(entry->key));
+		LOOPBYTE(
+				 if ((sign[i] & 0xff) != 0xff)
+				 PG_RETURN_POINTER(retval);
+		);
+		len = CALCGTSIZE(SIGNKEY | ALLISTRUE, 0);
+		res = (TRGM *) palloc(len);
+		res->len = len;
+		res->flag = SIGNKEY | ALLISTRUE;
+		retval = (GISTENTRY *) palloc(sizeof(GISTENTRY));
+		gistentryinit(*retval, PointerGetDatum(res),
+					  entry->rel, entry->page,
+					  entry->offset, res->len, FALSE);
+	}
+	PG_RETURN_POINTER(retval);
+}
+Datum
+gtrgm_decompress(PG_FUNCTION_ARGS)
+{
+	PG_RETURN_DATUM(PG_GETARG_DATUM(0));
+}
+Datum
+gtrgm_consistent(PG_FUNCTION_ARGS)
+{
+	text  *query = (text *) PG_GETARG_TEXT_P(1);
+	TRGM   *key = (TRGM *) DatumGetPointer( ((GISTENTRY *) PG_GETARG_POINTER(0))->key );
+	TRGM   *qtrg = generate_trgm(VARDATA(query), VARSIZE(query) - VARHDRSZ);
+	int res=false;
+	if ( GIST_LEAF( (GISTENTRY *) PG_GETARG_POINTER(0) ) ) { /* all leafs contains orig trgm */
+		float4 tmpsml = cnt_sml(key,qtrg);
+			/* strange bug at freebsd 5.2.1 and gcc 3.3.3 */
+		res = ( *(int*)&tmpsml==*(int*)&trgm_limit || tmpsml > trgm_limit ) ? true : false;
+	} else if ( ISALLTRUE(key) ) { /* non-leaf contains signature */
+		res = true;
+	} else { /* non-leaf contains signature */
+		int4 count=0;
+		int4	k, len = ARRNELEM(qtrg);
+		trgm	   *ptr = GETARR(qtrg);
+		BITVECP	   sign = GETSIGN(key);
+		int4 tmp=0;
+		for (k = 0; k < len; k++) {
+			CPTRGM( ((char*)&tmp), ptr+k );
+			count += GETBIT(sign, HASHVAL(tmp));
+		}
+#ifdef DIVUNION
+		res = ( len==count ) ? true : ( ( ( ( ((float4)count) / ((float4)(len-count)) ) ) >= trgm_limit ) ? true : false );
+#else
+		res = (len==0) ? false : ( ( ( ( ((float4)count) / ((float4)len) ) ) >= trgm_limit ) ? true : false );
+#endif
+	}
+	PG_FREE_IF_COPY(query,1);
+	pfree(qtrg); 
+	PG_RETURN_BOOL(res);
+}
+static int4
+unionkey(BITVECP sbase, TRGM * add)
+{
+	int4		i;
+	if (ISSIGNKEY(add))
+	{
+		BITVECP		sadd = GETSIGN(add);
+		if (ISALLTRUE(add))
+			return 1;
+		LOOPBYTE(
+				 sbase[i] |= sadd[i];
+		);
+	}
+	else
+	{
+		trgm	   *ptr = GETARR(add);
+		int4 tmp=0;
+		for (i = 0; i < ARRNELEM(add); i++) {
+			CPTRGM( ((char*)&tmp), ptr+i );
+			HASH(sbase, tmp);
+		}
+	}
+	return 0;
+}
+Datum
+gtrgm_union(PG_FUNCTION_ARGS)
+{
+        GistEntryVector      *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0);
+        int4        len = entryvec->n;
+	int		   *size = (int *) PG_GETARG_POINTER(1);
+	BITVEC		base;
+	int4		i;
+	int4		flag = 0;
+	TRGM   *result;
+	MemSet((void *) base, 0, sizeof(BITVEC));
+	for (i = 0; i < len; i++)
+	{
+		if (unionkey(base, GETENTRY(entryvec, i)))
+		{
+			flag = ALLISTRUE;
+			break;
+		}
+	}
+	flag |= SIGNKEY;
+	len = CALCGTSIZE(flag, 0);
+	result = (TRGM *) palloc(len);
+	*size = result->len = len;
+	result->flag = flag;
+	if (!ISALLTRUE(result))
+		memcpy((void *) GETSIGN(result), (void *) base, sizeof(BITVEC));
+	PG_RETURN_POINTER(result);
+}
+Datum
+gtrgm_same(PG_FUNCTION_ARGS)
+{
+	TRGM   *a = (TRGM *) PG_GETARG_POINTER(0);
+	TRGM   *b = (TRGM *) PG_GETARG_POINTER(1);
+	bool	   *result = (bool *) PG_GETARG_POINTER(2);
+	if (ISSIGNKEY(a))
+	{							/* then b also ISSIGNKEY */
+		if (ISALLTRUE(a) && ISALLTRUE(b))
+			*result = true;
+		else if (ISALLTRUE(a))
+			*result = false;
+		else if (ISALLTRUE(b))
+			*result = false;
+		else
+		{
+			int4		i;
+			BITVECP		sa = GETSIGN(a),
+						sb = GETSIGN(b);
+			*result = true;
+			LOOPBYTE(
+					 if (sa[i] != sb[i])
+					 {
+				*result = false;
+				break;
+			}
+			);
+		}
+	}
+	else
+	{							/* a and b ISARRKEY */
+		int4		lena = ARRNELEM(a),
+					lenb = ARRNELEM(b);
+		if (lena != lenb)
+			*result = false;
+		else
+		{
+			trgm	   *ptra = GETARR(a),
+					   *ptrb = GETARR(b);
+			int4		i;
+			*result = true;
+			for (i = 0; i < lena; i++)
+				if (CMPTRGM(ptra+i, ptrb+i))
+				{
+					*result = false;
+					break;
+				}
+		}
+	}
+	PG_RETURN_POINTER(result);
+}
+static int4
+sizebitvec(BITVECP sign)
+{
+	int4		size = 0,
+				i;
+	LOOPBYTE(
+		size += SUMBIT(*(char *) sign);
+		sign = (BITVECP) (((char *) sign) + 1);
+	);
+	return size;
+}
+static int
+hemdistsign(BITVECP  a, BITVECP b) {
+	int i,dist=0;
+	LOOPBIT(
+		if ( GETBIT(a,i) != GETBIT(b,i) )
+			dist++;
+	);
+	return dist;
+}
+static int
+hemdist(TRGM   *a, TRGM   *b) {
+	if ( ISALLTRUE(a) ) {
+		if (ISALLTRUE(b))
+			return 0;
+		else
+			return SIGLENBIT-sizebitvec(GETSIGN(b));
+	} else if (ISALLTRUE(b))
+		return SIGLENBIT-sizebitvec(GETSIGN(a));
+	return hemdistsign( GETSIGN(a), GETSIGN(b) );
+}
+Datum
+gtrgm_penalty(PG_FUNCTION_ARGS)
+{
+	GISTENTRY  *origentry = (GISTENTRY *) PG_GETARG_POINTER(0); /* always ISSIGNKEY */
+	GISTENTRY  *newentry = (GISTENTRY *) PG_GETARG_POINTER(1);
+	float	   *penalty = (float *) PG_GETARG_POINTER(2);
+	TRGM   *origval = (TRGM *) DatumGetPointer(origentry->key);
+	TRGM   *newval = (TRGM *) DatumGetPointer(newentry->key);
+	BITVECP		orig = GETSIGN(origval);
+	*penalty = 0.0;
+	if (ISARRKEY(newval)) {
+		BITVEC sign;
+		makesign(sign, newval);
+		if ( ISALLTRUE(origval) ) 
+			*penalty=((float)(SIGLENBIT-sizebitvec(sign)))/(float)(SIGLENBIT+1);
+		else 
+			*penalty=hemdistsign(sign,orig);
+	} else {
+		*penalty=hemdist(origval,newval);
+	}
+	PG_RETURN_POINTER(penalty);
+}
+typedef struct
+{
+	bool		allistrue;
+	BITVEC		sign;
+}	CACHESIGN;
+static void
+fillcache(CACHESIGN * item, TRGM * key)
+{
+	item->allistrue = false;
+	if (ISARRKEY(key))
+		makesign(item->sign, key);
+	else if (ISALLTRUE(key))
+		item->allistrue = true;
+	else
+		memcpy((void *) item->sign, (void *) GETSIGN(key), sizeof(BITVEC));
+}
+#define WISH_F(a,b,c) (double)( -(double)(((a)-(b))*((a)-(b))*((a)-(b)))*(c) )
+typedef struct
+{
+	OffsetNumber pos;
+	int4		cost;
+} SPLITCOST;
+static int
+comparecost(const void *a, const void *b)
+{
+	if (((SPLITCOST *) a)->cost == ((SPLITCOST *) b)->cost)
+		return 0;
+	else
+		return (((SPLITCOST *) a)->cost > ((SPLITCOST *) b)->cost) ? 1 : -1;
+}
+static int
+hemdistcache(CACHESIGN   *a, CACHESIGN   *b) {
+	if ( a->allistrue ) {
+		if (b->allistrue)
+			return 0;
+		else
+			return SIGLENBIT-sizebitvec(b->sign);
+	} else if (b->allistrue)
+		return SIGLENBIT-sizebitvec(a->sign);
+	return hemdistsign( a->sign, b->sign );
+}
+Datum
+gtrgm_picksplit(PG_FUNCTION_ARGS)
+{
+        GistEntryVector      *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0);
+        OffsetNumber maxoff = entryvec->n - 2;
+	GIST_SPLITVEC *v = (GIST_SPLITVEC *) PG_GETARG_POINTER(1);
+	OffsetNumber k,
+				j;
+	TRGM   *datum_l,
+			   *datum_r;
+	BITVECP		union_l,
+				union_r;
+	int4		size_alpha,
+				size_beta;
+	int4		size_waste,
+				waste = -1;
+	int4		nbytes;
+	OffsetNumber seed_1 = 0,
+				seed_2 = 0;
+	OffsetNumber *left,
+			   *right;
+	BITVECP		ptr;
+	int			i;
+	CACHESIGN  *cache;
+	SPLITCOST  *costvector;
+	nbytes = (maxoff + 2) * sizeof(OffsetNumber);
+	v->spl_left = (OffsetNumber *) palloc(nbytes);
+	v->spl_right = (OffsetNumber *) palloc(nbytes);
+	cache = (CACHESIGN *) palloc(sizeof(CACHESIGN) * (maxoff + 2));
+	fillcache(&cache[FirstOffsetNumber], GETENTRY(entryvec, FirstOffsetNumber));
+	for (k = FirstOffsetNumber; k < maxoff; k = OffsetNumberNext(k)) {
+		for (j = OffsetNumberNext(k); j <= maxoff; j = OffsetNumberNext(j)) {
+			if (k == FirstOffsetNumber)
+				fillcache(&cache[j], GETENTRY(entryvec, j));
+			size_waste=hemdistcache(&(cache[j]),&(cache[k]));
+			if (size_waste > waste) {
+				waste = size_waste;
+				seed_1 = k;
+				seed_2 = j;
+			}
+		}
+	}
+	left = v->spl_left;
+	v->spl_nleft = 0;
+	right = v->spl_right;
+	v->spl_nright = 0;
+	if (seed_1 == 0 || seed_2 == 0) {
+		seed_1 = 1;
+		seed_2 = 2;
+	}
+	/* form initial .. */
+	if (cache[seed_1].allistrue) {
+		datum_l = (TRGM *) palloc(CALCGTSIZE(SIGNKEY | ALLISTRUE, 0));
+		datum_l->len = CALCGTSIZE(SIGNKEY | ALLISTRUE, 0);
+		datum_l->flag = SIGNKEY | ALLISTRUE;
+	} else {
+		datum_l = (TRGM *) palloc(CALCGTSIZE(SIGNKEY, 0));
+		datum_l->len = CALCGTSIZE(SIGNKEY, 0);
+		datum_l->flag = SIGNKEY;
+		memcpy((void *) GETSIGN(datum_l), (void *) cache[seed_1].sign, sizeof(BITVEC));
+	}
+	if (cache[seed_2].allistrue) {
+		datum_r = (TRGM *) palloc(CALCGTSIZE(SIGNKEY | ALLISTRUE, 0));
+		datum_r->len = CALCGTSIZE(SIGNKEY | ALLISTRUE, 0);
+		datum_r->flag = SIGNKEY | ALLISTRUE;
+	} else {
+		datum_r = (TRGM *) palloc(CALCGTSIZE(SIGNKEY, 0));
+		datum_r->len = CALCGTSIZE(SIGNKEY, 0);
+		datum_r->flag = SIGNKEY;
+		memcpy((void *) GETSIGN(datum_r), (void *) cache[seed_2].sign, sizeof(BITVEC));
+	}
+	union_l=GETSIGN(datum_l);
+	union_r=GETSIGN(datum_r);
+	maxoff = OffsetNumberNext(maxoff);
+	fillcache(&cache[maxoff], GETENTRY(entryvec, maxoff));
+	/* sort before ... */
+	costvector = (SPLITCOST *) palloc(sizeof(SPLITCOST) * maxoff);
+	for (j = FirstOffsetNumber; j <= maxoff; j = OffsetNumberNext(j)) {
+		costvector[j - 1].pos = j;
+		size_alpha = hemdistcache(&(cache[seed_1]), &(cache[j]));
+		size_beta  = hemdistcache(&(cache[seed_2]), &(cache[j]));
+		costvector[j - 1].cost = abs(size_alpha - size_beta);
+	}
+	qsort((void *) costvector, maxoff, sizeof(SPLITCOST), comparecost);
+	for (k = 0; k < maxoff; k++) {
+		j = costvector[k].pos;
+		if (j == seed_1) {
+			*left++ = j;
+			v->spl_nleft++;
+			continue;
+		} else if (j == seed_2) {
+			*right++ = j;
+			v->spl_nright++;
+			continue;
+		}
+		if (ISALLTRUE(datum_l) || cache[j].allistrue) {
+			if ( ISALLTRUE(datum_l) && cache[j].allistrue )
+				size_alpha=0;
+			else
+				size_alpha = SIGLENBIT-sizebitvec(  
+					( cache[j].allistrue ) ? GETSIGN(datum_l) : GETSIGN(cache[j].sign)  
+				);
+		} else {
+			size_alpha=hemdistsign(cache[j].sign,GETSIGN(datum_l));
+		}
+		if (ISALLTRUE(datum_r) || cache[j].allistrue) {
+			if ( ISALLTRUE(datum_r) && cache[j].allistrue )
+				size_beta=0;
+			else
+				size_beta = SIGLENBIT-sizebitvec(  
+					( cache[j].allistrue ) ? GETSIGN(datum_r) : GETSIGN(cache[j].sign)  
+				);
+		} else {
+			size_beta=hemdistsign(cache[j].sign,GETSIGN(datum_r));
+		}
+		if (size_alpha  < size_beta + WISH_F(v->spl_nleft, v->spl_nright, 0.1)) {
+			if (ISALLTRUE(datum_l) || cache[j].allistrue) {
+				if (! ISALLTRUE(datum_l) )
+					MemSet((void *) GETSIGN(datum_l), 0xff, sizeof(BITVEC));
+			} else {
+				ptr=cache[j].sign;
+				LOOPBYTE(
+					union_l[i] |= ptr[i];
+				);
+			}
+			*left++ = j;
+			v->spl_nleft++;
+		} else {
+			if (ISALLTRUE(datum_r) || cache[j].allistrue) {
+				if (! ISALLTRUE(datum_r) )
+					MemSet((void *) GETSIGN(datum_r), 0xff, sizeof(BITVEC));
+			} else {
+				ptr=cache[j].sign;
+				LOOPBYTE(
+					union_r[i] |= ptr[i];
+				);
+			}
+			*right++ = j;
+			v->spl_nright++;
+		}
+	}
+	*right = *left = FirstOffsetNumber;
+	pfree(costvector);
+	pfree(cache);
+	v->spl_ldatum = PointerGetDatum(datum_l);
+	v->spl_rdatum = PointerGetDatum(datum_r);
+	PG_RETURN_POINTER(v);
+}
--- a/contrib/pg_trgm/trgm_op.c
+++ b/contrib/pg_trgm/trgm_op.c
+#include "trgm.h"
+#include <ctype.h>
+#include "utils/array.h"
+#include "catalog/pg_type.h"
+float4 trgm_limit = 0.3;
+PG_FUNCTION_INFO_V1(set_limit);
+Datum set_limit(PG_FUNCTION_ARGS);
+Datum
+set_limit(PG_FUNCTION_ARGS) {
+	float4 nlimit = PG_GETARG_FLOAT4(0);
+	if ( nlimit < 0 || nlimit > 1.0 ) 
+		elog(ERROR,"Wrong limit, should be between 0 and 1");
+	trgm_limit = nlimit;
+	PG_RETURN_FLOAT4(trgm_limit);
+}
+PG_FUNCTION_INFO_V1(show_limit);
+Datum show_limit(PG_FUNCTION_ARGS);
+Datum
+show_limit(PG_FUNCTION_ARGS) {
+	PG_RETURN_FLOAT4(trgm_limit);
+}
+#define WORDWAIT        0
+#define INWORD          1
+static int
+comp_trgm(const void *a, const void *b) {
+	return CMPTRGM(a,b);
+}
+static int
+unique_array (trgm *a, int len) {
+	trgm *curend, *tmp;
+	curend = tmp = a;
+	while (tmp - a < len)
+		if ( CMPTRGM(tmp, curend) ) {
+			curend++;
+			CPTRGM(curend,tmp);
+			tmp++;
+		} else
+			tmp++;
+	return curend + 1 - a;
+}
+TRGM*
+generate_trgm(char *str, int slen) {
+	TRGM*	trg;
+	char	*buf,*sptr,*bufptr;
+	trgm	*tptr;
+	int     state=WORDWAIT;
+	int wl,len;
+	trg = (TRGM*) palloc(TRGMHRDSIZE+sizeof(trgm) * (slen/2 + 1) * 3);
+	trg->flag = ARRKEY;
+	trg->len = TRGMHRDSIZE;
+	if ( slen+LPADDING+RPADDING<3 || slen == 0 )
+		return trg;
+	tptr = GETARR(trg);
+	buf = palloc(sizeof(char) * (slen+4));
+	sptr = str;
+	if ( LPADDING > 0 ) {
+		*buf = ' ';
+		if ( LPADDING > 1 )
+			*(buf+1) = ' ';
+	}
+	bufptr = buf+LPADDING;
+	while( sptr-str < slen ) {
+		if ( state == WORDWAIT ) {
+			if ( 
+#ifdef	KEEPONLYALNUM
+	 			isalnum((unsigned char)*sptr)
+#else
+				!isspace( (unsigned char)*sptr )
+#endif
+				) {
+				*bufptr = *sptr; /* start put word in buffer */
+				bufptr++;
+				state = INWORD;
+				if ( sptr-str == slen-1 /* last char */ )
+					goto gettrg;
+			}
+		} else {
+			if (
+#ifdef	KEEPONLYALNUM
+	 			!isalnum((unsigned char)*sptr)
+#else
+				isspace( (unsigned char)*sptr )			
+#endif
+				) {
+gettrg:
+				/* word in buffer, so count trigrams */
+				*bufptr = ' ';
+				*(bufptr+1) = ' ';
+				wl = bufptr - (buf+LPADDING) - 2 + LPADDING + RPADDING;
+				if ( wl<=0 ) {
+					bufptr = buf+LPADDING;
+					state = WORDWAIT;
+					sptr++;
+					continue;
+				}
+#ifdef IGNORECASE
+				do { /* lower word */
+					int wwl = bufptr-buf;
+					bufptr = buf+LPADDING;
+					while( bufptr-buf < wwl ) {
+						*bufptr = tolower( (unsigned char) *bufptr );
+						bufptr++;
+					}
+				} while(0);
+#endif
+				bufptr = buf;
+				/* set trigrams */
+				while( bufptr-buf < wl ) {
+					CPTRGM(tptr, bufptr);
+					bufptr++;
+					tptr++;
+				}
+				bufptr = buf+LPADDING;
+				state = WORDWAIT;
+			} else {
+				*bufptr = *sptr; /* put in buffer */
+				bufptr++;
+				if ( sptr-str == slen-1 )
+					goto gettrg;
+			}
+		}
+		sptr++;
+	}
+	pfree(buf);
+	if ( (len=tptr-GETARR(trg)) == 0 ) 
+		return trg;
+	if ( len>0 ) {
+		qsort( (void*)GETARR(trg), len, sizeof(trgm), comp_trgm );
+		len = unique_array( GETARR(trg), len );
+	} 
+	trg->len = CALCGTSIZE(ARRKEY, len);
+	return trg;
+}
+PG_FUNCTION_INFO_V1(show_trgm);
+Datum show_trgm(PG_FUNCTION_ARGS);
+Datum
+show_trgm(PG_FUNCTION_ARGS) {
+	text       *in = PG_GETARG_TEXT_P(0);
+	TRGM	*trg;
+	Datum *d;
+	ArrayType *a;
+	trgm *ptr;
+	trg = generate_trgm(VARDATA(in), VARSIZE(in) - VARHDRSZ);
+	d = (Datum*)palloc( sizeof(Datum)*(1+ARRNELEM(trg)) );
+	ptr = GETARR(trg);
+	while( ptr-GETARR(trg) < ARRNELEM(trg) ) {
+		text *item=(text*)palloc(VARHDRSZ + 3);
+		VARATT_SIZEP(item) = VARHDRSZ+3;
+		CPTRGM(VARDATA(item), ptr);
+		d[ ptr-GETARR(trg) ] = PointerGetDatum(item);
+		ptr++;
+	}
+	a = construct_array(
+		d,
+		ARRNELEM(trg),
+		TEXTOID,
+		-1,
+		false,
+		'i'
+	);
+	ptr = GETARR(trg);
+	while( ptr-GETARR(trg) < ARRNELEM(trg) ) {
+		pfree(DatumGetPointer(d[ ptr-GETARR(trg) ]));
+		ptr++;
+	}
+	pfree(d);
+	pfree(trg);
+	PG_FREE_IF_COPY(in,0);
+	PG_RETURN_POINTER(a);
+}
+float4
+cnt_sml(TRGM *trg1, TRGM *trg2) {
+	trgm	*ptr1, *ptr2;
+	int count=0;
+	int len1, len2;
+	ptr1 = GETARR(trg1);
+	ptr2 = GETARR(trg2);
+	len1 = ARRNELEM(trg1);
+	len2 = ARRNELEM(trg2);
+	while( ptr1 - GETARR(trg1) < len1 && ptr2 - GETARR(trg2) < len2 ) {
+		int res = CMPTRGM(ptr1,ptr2);
+		if ( res < 0 ) {
+			ptr1++;
+		} else if ( res > 0 ) {
+			ptr2++;
+		} else {
+			ptr1++;
+			ptr2++;
+			count++;
+		}
+	}
+#ifdef DIVUNION
+	return ( ( ((float4)count) / ((float4)(len1+len2-count)) ) );
+#else
+	return ( ((float)count) / ((float)( (len1>len2) ? len1 : len2 )) );
+#endif
+}
+PG_FUNCTION_INFO_V1(similarity);
+Datum similarity(PG_FUNCTION_ARGS);
+Datum
+similarity(PG_FUNCTION_ARGS) {
+	text       *in1 = PG_GETARG_TEXT_P(0);
+	text       *in2 = PG_GETARG_TEXT_P(1);
+	TRGM    *trg1, *trg2;
+	float4 res;
+	trg1 = generate_trgm(VARDATA(in1), VARSIZE(in1) - VARHDRSZ);
+	trg2 = generate_trgm(VARDATA(in2), VARSIZE(in2) - VARHDRSZ);
+	res = cnt_sml(trg1,trg2);
+	pfree(trg1);
+	pfree(trg2);
+	PG_FREE_IF_COPY(in1,0);
+	PG_FREE_IF_COPY(in2,1);
+	PG_RETURN_FLOAT4(res);
+}
+PG_FUNCTION_INFO_V1(similarity_op);
+Datum similarity_op(PG_FUNCTION_ARGS);
+Datum
+similarity_op(PG_FUNCTION_ARGS) {
+	float4 res=DatumGetFloat4( DirectFunctionCall2(
+		similarity,
+		PG_GETARG_DATUM(0),
+		PG_GETARG_DATUM(1)
+	) );
+	PG_RETURN_BOOL( res >= trgm_limit );
+}