Postgres स्ट्रिंग सरणी पर केस-असंवेदनशील अनुक्रमणिका बनाना

@ सौरभ नंदा:आपने जो पोस्ट किया है, उसके समान, आप अपने वर्चर ऐरे को लोअरकेस में बदलने के लिए एक सरल फ़ंक्शन भी बना सकते हैं:

CREATE OR REPLACE FUNCTION array_lowercase(varchar[]) RETURNS varchar[] AS
$BODY$
  SELECT array_agg(q.tag) FROM (
    SELECT btrim(lower(unnest($1)))::varchar AS tag
  ) AS q;
$BODY$
  language sql IMMUTABLE;

ध्यान दें कि मैं रिक्त स्थान के टैग को भी ट्रिम कर रहा हूं। यह आपके लिए आवश्यक नहीं हो सकता है लेकिन मैं आमतौर पर निरंतरता के लिए करता हूं।

परीक्षण:

SELECT array_lowercase(array['Hello','WOrLD']);
 array_lowercase 
-----------------
 {hello,world}
(1 row)

जैसा कि सौरभ ने बताया, आप फिर एक GIN इंडेक्स बना सकते हैं:

CREATE INDEX ix_tags ON tagtable USING GIN(array_lowercase(tags));

और क्वेरी:

SELECT * FROM tagtable WHERE ARRAY['mytag'::varchar] && array_lowercase(tags);

अद्यतन करें: WHILE . का प्रदर्शन बनाम array_agg/unnest

मैंने 100K 10 तत्व text[] . की तालिका बनाई है सरणी (12 वर्ण यादृच्छिक मिश्रित केस स्ट्रिंग) और प्रत्येक फ़ंक्शन का परीक्षण किया।

array_agg/unnest फ़ंक्शन लौटा:

EXPLAIN ANALYZE VERBOSE SELECT array_lowercase(data) FROM test;
                                                       QUERY PLAN                                                       
------------------------------------------------------------------------------------------------------------------------
 Seq Scan on public.test  (cost=0.00..28703.00 rows=100000 width=184) (actual time=0.320..3041.292 rows=100000 loops=1)
   Output: array_lowercase((data)::character varying[])
 Total runtime: 3174.690 ms
(3 rows)

WHILE फ़ंक्शन लौटा:

EXPLAIN ANALYZE VERBOSE SELECT array_lowercase_while(data) FROM test;
                                                       QUERY PLAN                                                       
------------------------------------------------------------------------------------------------------------------------
 Seq Scan on public.test  (cost=0.00..28703.00 rows=100000 width=184) (actual time=5.128..4356.647 rows=100000 loops=1)
   Output: array_lowercase_while((data)::character varying[])
 Total runtime: 4485.226 ms
(3 rows)

अद्यतन 2: FOREACH बनाम WHILE अंतिम प्रयोग के रूप में, मैंने FOREACH का उपयोग करने के लिए WHILE फ़ंक्शन को बदल दिया:

CREATE OR REPLACE FUNCTION array_lowercase_foreach(p_input varchar[]) RETURNS varchar[] AS $BODY$
DECLARE
    el text;
    r varchar[];
BEGIN
    FOREACH el IN ARRAY p_input LOOP
        r := r || btrim(lower(el))::varchar;
    END LOOP;
    RETURN r;
END;
$BODY$
  language 'plpgsql'

परिणाम WHILE . के समान प्रतीत हुए :

EXPLAIN ANALYZE VERBOSE SELECT array_lowercase_foreach(data) FROM test;
                                                       QUERY PLAN                                                       
------------------------------------------------------------------------------------------------------------------------
 Seq Scan on public.test  (cost=0.00..28703.00 rows=100000 width=184) (actual time=0.707..4106.867 rows=100000 loops=1)
   Output: array_lowercase_foreach((data)::character varying[])
 Total runtime: 4239.958 ms
(3 rows)

हालांकि मेरे परीक्षण किसी भी तरह से कठोर नहीं हैं, मैंने प्रत्येक संस्करण को कई बार चलाया और संख्याओं को प्रतिनिधि के रूप में पाया, यह सुझाव देते हुए कि SQL विधि (array_agg/unnest) सबसे तेज़ है।