क्या PostgreSQL में किसी विशेष मान के लिए हर टेबल के हर कॉलम को खोजना संभव है ?
क्या PostgreSQL में किसी विशेष मान के लिए हर टेबल के हर कॉलम को खोजना संभव है ?
जवाबों:
कैसे डेटाबेस की सामग्री को डंप करने के बारे में, फिर उपयोग करना grep
?
$ pg_dump --data-only --inserts -U postgres your-db-name > a.tmp
$ grep United a.tmp
INSERT INTO countries VALUES ('US', 'United States');
INSERT INTO countries VALUES ('GB', 'United Kingdom');
समान उपयोगिता, pg_dump, आउटपुट में कॉलम नाम शामिल कर सकती है। बस --inserts
करने के लिए बदल जाते हैं --column-inserts
। इस तरह आप विशिष्ट कॉलम नामों की खोज कर सकते हैं। लेकिन अगर मैं कॉलम नामों की तलाश में था, तो मैं शायद डेटा के बजाय स्कीमा डंप कर दूंगा।
$ pg_dump --data-only --column-inserts -U postgres your-db-name > a.tmp
$ grep country_code a.tmp
INSERT INTO countries (iso_country_code, iso_country_name) VALUES ('US', 'United States');
INSERT INTO countries (iso_country_code, iso_country_name) VALUES ('GB', 'United Kingdom');
ALTER DATABASE your_db_name SET bytea_output = 'escape';
इसे डंप करने से पहले डेटाबेस (या कॉपी कॉपी) पर आवश्यकता हो सकती है। (मैं सिर्फ एक के लिए यह निर्दिष्ट करने के लिए एक तरह से नहीं दिखाई दे रही है pg_dump
आदेश।)
यहां एक pl / pgsql फ़ंक्शन है जो रिकॉर्ड्स को रेखांकित करता है जहां किसी भी कॉलम में एक विशिष्ट मूल्य होता है। यह पाठ प्रारूप में खोज करने के लिए तर्कों के रूप में लेता है, तालिका नामों की एक सरणी खोज करने के लिए (सभी तालिकाओं में चूक) और स्कीमा नामों की एक सरणी (सभी स्कीमा नामों को चूकता है)।
यह स्कीमा, तालिका का नाम, स्तंभ और छद्म-स्तंभ का नाम ctid
(तालिका में पंक्ति का गैर-टिकाऊ भौतिक स्थान, सिस्टम कॉलम देखें ) के साथ एक तालिका संरचना लौटाता है
CREATE OR REPLACE FUNCTION search_columns(
needle text,
haystack_tables name[] default '{}',
haystack_schema name[] default '{}'
)
RETURNS table(schemaname text, tablename text, columnname text, rowctid text)
AS $$
begin
FOR schemaname,tablename,columnname IN
SELECT c.table_schema,c.table_name,c.column_name
FROM information_schema.columns c
JOIN information_schema.tables t ON
(t.table_name=c.table_name AND t.table_schema=c.table_schema)
JOIN information_schema.table_privileges p ON
(t.table_name=p.table_name AND t.table_schema=p.table_schema
AND p.privilege_type='SELECT')
JOIN information_schema.schemata s ON
(s.schema_name=t.table_schema)
WHERE (c.table_name=ANY(haystack_tables) OR haystack_tables='{}')
AND (c.table_schema=ANY(haystack_schema) OR haystack_schema='{}')
AND t.table_type='BASE TABLE'
LOOP
FOR rowctid IN
EXECUTE format('SELECT ctid FROM %I.%I WHERE cast(%I as text)=%L',
schemaname,
tablename,
columnname,
needle
)
LOOP
-- uncomment next line to get some progress report
-- RAISE NOTICE 'hit in %.%', schemaname, tablename;
RETURN NEXT;
END LOOP;
END LOOP;
END;
$$ language plpgsql;
ज़िथुब पर संस्करण भी देखेंइसी सिद्धांत के आधार लेकिन कुछ गति और रिपोर्टिंग सुधारों को जोड़ना।
एक परीक्षण डेटाबेस में उपयोग के उदाहरण:
search_columns ('फोब्बर') से * चुनें; योजनाबद्ध नाम | टैब्लेम | कॉलमनाम | rowctid ------------ + ----------- + ------------ + --------- जनता | s3 | usename | (0,11) जनता | s2 | relname | (7,29) जनता | w | शरीर | (0,2) (3 पंक्तियाँ)
search_columns से (* 'फ़ोबार', '{w}') का चयन करें; योजनाबद्ध नाम | टैब्लेम | कॉलमनाम | rowctid ------------ + ----------- + ------------ + --------- जनता | w | शरीर | (0,2) (1 पंक्ति)
search_columns ('foobar', array (select table_name :: name from information_schema.tables जहां से table_name जैसे 's%'), array ['public']; योजनाबद्ध नाम | टैब्लेम | कॉलमनाम | rowctid ------------ + ----------- + ------------ + --------- जनता | s2 | relname | (7,29) जनता | s3 | usename | (0,11) (2 पंक्तियाँ)
public से चुनें *। जहां ctid = '(0,2)'; शीर्षक | शरीर | tsv ------- + -------- + --------------------- टोटो | फोब्बर | 'फोबार': 2 'टोटो': 1
सख्त समानता के बजाय एक नियमित अभिव्यक्ति के खिलाफ परीक्षण करने के लिए, grep की तरह, क्वेरी का यह हिस्सा:
SELECT ctid FROM %I.%I WHERE cast(%I as text)=%L
इसे बदला जा सकता है:
SELECT ctid FROM %I.%I WHERE cast(%I as text) ~ %L
असंवेदनशील तुलना के मामले में, आप लिख सकते हैं:
SELECT ctid FROM %I.%I WHERE lower(cast(%I as text)) = lower(%L)
~*
कम () से अधिक पर्याप्त। लेकिन वैसे भी t.*
उपरोक्त उत्तर का हिस्सा नहीं है। कॉलम द्वारा खोज स्तंभ स्तंभ विभाजकों के कारण मान के रूप में पंक्ति को खोजने के समान नहीं है।
किसी विशेष मान के लिए हर तालिका के हर स्तंभ को खोजने के लिए
यह परिभाषित नहीं करता है कि वास्तव में कैसे मिलान किया जाए।
न ही यह परिभाषित करता है कि वास्तव में क्या लौटना है।
मान लिया जाये कि:
regclass
) और टुपल आईडी ( ctid
) लौटाएं , क्योंकि यह सबसे सरल है।यहाँ एक मृत सरल, तेज और थोड़ा गंदा तरीका है:
CREATE OR REPLACE FUNCTION search_whole_db(_like_pattern text)
RETURNS TABLE(_tbl regclass, _ctid tid) AS
$func$
BEGIN
FOR _tbl IN
SELECT c.oid::regclass
FROM pg_class c
JOIN pg_namespace n ON n.oid = relnamespace
WHERE c.relkind = 'r' -- only tables
AND n.nspname !~ '^(pg_|information_schema)' -- exclude system schemas
ORDER BY n.nspname, c.relname
LOOP
RETURN QUERY EXECUTE format(
'SELECT $1, ctid FROM %s t WHERE t::text ~~ %L'
, _tbl, '%' || _like_pattern || '%')
USING _tbl;
END LOOP;
END
$func$ LANGUAGE plpgsql;
कॉल करें:
SELECT * FROM search_whole_db('mypattern');
संलग्नक के बिना खोज पैटर्न प्रदान करें %
।
थोड़ा गंदा क्यों?
यदि text
प्रतिनिधित्व में पंक्ति के लिए विभाजक और सज्जाकार खोज पैटर्न का हिस्सा हो सकते हैं, तो गलत सकारात्मकता हो सकती है:
,
डिफ़ॉल्ट रूप से()
"
\
एस्केप चार के रूप में जोड़ा जा सकता हैऔर कुछ स्तंभों का पाठ निरूपण स्थानीय सेटिंग्स पर निर्भर हो सकता है - लेकिन यह अस्पष्टता प्रश्न के लिए निहित है, मेरे समाधान के लिए नहीं।
प्रत्येक योग्यता पंक्ति को एक बार ही लौटाया जाता है , भले ही वह कई बार मेल खाता हो (जैसा कि अन्य उत्तरों के विपरीत है)।
यह सिस्टम कैटलॉग को छोड़कर पूरे डीबी को खोजता है। आम तौर पर समाप्त होने में लंबा समय लगेगा । आप कुछ विशेष स्कीमा / तालिकाओं (या यहां तक कि स्तंभों) को प्रतिबंधित करना चाहते हैं, जैसे अन्य उत्तरों में दिखाए गए हैं। या नोटिस और प्रगति सूचक जोड़ें, एक अन्य उत्तर में भी प्रदर्शित किया गया।
regclass
ऑब्जेक्ट पहचानकर्ता प्रकार तालिका नाम, स्कीमा योग्य जहां आवश्यक वर्तमान के अनुसार को स्पष्ट करने के लिए के रूप में प्रस्तुत किया जाता है search_path
:
क्या है ctid
?
आप खोज पैटर्न में विशेष अर्थ वाले पात्रों से बच सकते हैं। देख:
और अगर किसी को लगता है कि यह मदद कर सकता है। यहां @Daniel Vérité का कार्य है, एक अन्य परम के साथ जो स्तंभों के नामों को स्वीकार करते हैं जिन्हें खोज में उपयोग किया जा सकता है। इस तरह से यह प्रसंस्करण के समय को कम करता है। कम से कम मेरे परीक्षण में यह बहुत कम हो गया।
CREATE OR REPLACE FUNCTION search_columns(
needle text,
haystack_columns name[] default '{}',
haystack_tables name[] default '{}',
haystack_schema name[] default '{public}'
)
RETURNS table(schemaname text, tablename text, columnname text, rowctid text)
AS $$
begin
FOR schemaname,tablename,columnname IN
SELECT c.table_schema,c.table_name,c.column_name
FROM information_schema.columns c
JOIN information_schema.tables t ON
(t.table_name=c.table_name AND t.table_schema=c.table_schema)
WHERE (c.table_name=ANY(haystack_tables) OR haystack_tables='{}')
AND c.table_schema=ANY(haystack_schema)
AND (c.column_name=ANY(haystack_columns) OR haystack_columns='{}')
AND t.table_type='BASE TABLE'
LOOP
EXECUTE format('SELECT ctid FROM %I.%I WHERE cast(%I as text)=%L',
schemaname,
tablename,
columnname,
needle
) INTO rowctid;
IF rowctid is not null THEN
RETURN NEXT;
END IF;
END LOOP;
END;
$$ language plpgsql;
Bellow ऊपर बनाए गए search_function के उपयोग का एक उदाहरण है।
SELECT * FROM search_columns('86192700'
, array(SELECT DISTINCT a.column_name::name FROM information_schema.columns AS a
INNER JOIN information_schema.tables as b ON (b.table_catalog = a.table_catalog AND b.table_schema = a.table_schema AND b.table_name = a.table_name)
WHERE
a.column_name iLIKE '%cep%'
AND b.table_type = 'BASE TABLE'
AND b.table_schema = 'public'
)
, array(SELECT b.table_name::name FROM information_schema.columns AS a
INNER JOIN information_schema.tables as b ON (b.table_catalog = a.table_catalog AND b.table_schema = a.table_schema AND b.table_name = a.table_name)
WHERE
a.column_name iLIKE '%cep%'
AND b.table_type = 'BASE TABLE'
AND b.table_schema = 'public')
);
एक नई प्रक्रिया के भंडारण के बिना आप एक कोड ब्लॉक का उपयोग कर सकते हैं और घटनाओं की एक तालिका प्राप्त करने के लिए निष्पादित कर सकते हैं। आप स्कीमा, तालिका या स्तंभ नाम से परिणाम फ़िल्टर कर सकते हैं।
DO $$
DECLARE
value int := 0;
sql text := 'The constructed select statement';
rec1 record;
rec2 record;
BEGIN
DROP TABLE IF EXISTS _x;
CREATE TEMPORARY TABLE _x (
schema_name text,
table_name text,
column_name text,
found text
);
FOR rec1 IN
SELECT table_schema, table_name, column_name
FROM information_schema.columns
WHERE table_name <> '_x'
AND UPPER(column_name) LIKE UPPER('%%')
AND table_schema <> 'pg_catalog'
AND table_schema <> 'information_schema'
AND data_type IN ('character varying', 'text', 'character', 'char', 'varchar')
LOOP
sql := concat('SELECT ', rec1."column_name", ' AS "found" FROM ',rec1."table_schema" , '.',rec1."table_name" , ' WHERE UPPER(',rec1."column_name" , ') LIKE UPPER(''','%my_substring_to_find_goes_here%' , ''')');
RAISE NOTICE '%', sql;
BEGIN
FOR rec2 IN EXECUTE sql LOOP
RAISE NOTICE '%', sql;
INSERT INTO _x VALUES (rec1."table_schema", rec1."table_name", rec1."column_name", rec2."found");
END LOOP;
EXCEPTION WHEN OTHERS THEN
END;
END LOOP;
END; $$;
SELECT * FROM _x;
एक फ़ंक्शन बनाने या बाहरी उपकरण का उपयोग किए बिना इसे प्राप्त करने का एक तरीका है। Postgres ' query_to_xml()
फ़ंक्शन का उपयोग करके जो किसी क्वेरी को गतिशील रूप से किसी अन्य क्वेरी के अंदर चला सकता है, कई टेबलों पर पाठ खोजना संभव है। यह सभी तालिकाओं के लिए पंक्ति-विवरण प्राप्त करने के मेरे उत्तर पर आधारित है :
foo
स्कीमा में सभी तालिकाओं में स्ट्रिंग की खोज करने के लिए , निम्नलिखित का उपयोग किया जा सकता है:
with found_rows as (
select format('%I.%I', table_schema, table_name) as table_name,
query_to_xml(format('select to_jsonb(t) as table_row
from %I.%I as t
where t::text like ''%%foo%%'' ', table_schema, table_name),
true, false, '') as table_rows
from information_schema.tables
where table_schema = 'public'
)
select table_name, x.table_row
from found_rows f
left join xmltable('//table/row'
passing table_rows
columns
table_row text path 'table_row') as x on true
ध्यान दें कि xmltable
10 या नए पोस्टग्रेज की आवश्यकता होती है। पुराने पोस्टग्रेज संस्करण के लिए, यह xpath () का उपयोग करके भी किया जा सकता है।
with found_rows as (
select format('%I.%I', table_schema, table_name) as table_name,
query_to_xml(format('select to_jsonb(t) as table_row
from %I.%I as t
where t::text like ''%%foo%%'' ', table_schema, table_name),
true, false, '') as table_rows
from information_schema.tables
where table_schema = 'public'
)
select table_name, x.table_row
from found_rows f
cross join unnest(xpath('/table/row/table_row/text()', table_rows)) as r(data)
सामान्य टेबल एक्सप्रेशन ( WITH ...
) का उपयोग केवल सुविधा के लिए किया जाता है। यह public
स्कीमा में सभी तालिकाओं के माध्यम से लूप करता है । प्रत्येक तालिका के लिए निम्न क्वेरी को query_to_xml()
फ़ंक्शन के माध्यम से चलाया जाता है :
select to_jsonb(t)
from some_table t
where t::text like '%foo%';
जहां क्लॉज का उपयोग यह सुनिश्चित करने के लिए किया जाता है कि XML सामग्री की महंगी पीढ़ी केवल उन पंक्तियों के लिए की जाती है जिसमें खोज स्ट्रिंग होती है। यह कुछ इस तरह लौट सकता है:
<table xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
<row>
<table_row>{"id": 42, "some_column": "foobar"}</table_row>
</row>
</table>
पूर्ण पंक्ति का रूपांतरण jsonb
किया जाता है, ताकि परिणाम में कोई यह देख सके कि कौन सा मूल्य किस स्तंभ से संबंधित है।
उपरोक्त कुछ इस तरह से लौट सकता है:
table_name | table_row
-------------+----------------------------------------
public.foo | {"id": 1, "some_column": "foobar"}
public.bar | {"id": 42, "another_column": "barfoo"}
ERROR: 42883: function format("unknown", information_schema.sql_identifier, information_schema.sql_identifier) does not exist
format('%I.%I', table_schema::text, table_name::text)
ERROR: 42883: function format("unknown", character varying, character varying) does not exist
format()
फंक्शन नहीं है
प्रगति रिपोर्टिंग कार्यक्षमता के साथ यहाँ @Daniel Vérité का कार्य है। यह तीन तरीकों से प्रगति की रिपोर्ट करता है:
_
CREATE OR REPLACE FUNCTION search_columns(
needle text,
haystack_tables name[] default '{}',
haystack_schema name[] default '{public}',
progress_seq text default NULL
)
RETURNS table(schemaname text, tablename text, columnname text, rowctid text)
AS $$
DECLARE
currenttable text;
columnscount integer;
foundintables text[];
foundincolumns text[];
begin
currenttable='';
columnscount = (SELECT count(1)
FROM information_schema.columns c
JOIN information_schema.tables t ON
(t.table_name=c.table_name AND t.table_schema=c.table_schema)
WHERE (c.table_name=ANY(haystack_tables) OR haystack_tables='{}')
AND c.table_schema=ANY(haystack_schema)
AND t.table_type='BASE TABLE')::integer;
PERFORM setval(progress_seq::regclass, columnscount);
FOR schemaname,tablename,columnname IN
SELECT c.table_schema,c.table_name,c.column_name
FROM information_schema.columns c
JOIN information_schema.tables t ON
(t.table_name=c.table_name AND t.table_schema=c.table_schema)
WHERE (c.table_name=ANY(haystack_tables) OR haystack_tables='{}')
AND c.table_schema=ANY(haystack_schema)
AND t.table_type='BASE TABLE'
LOOP
EXECUTE format('SELECT ctid FROM %I.%I WHERE cast(%I as text)=%L',
schemaname,
tablename,
columnname,
needle
) INTO rowctid;
IF rowctid is not null THEN
RETURN NEXT;
foundintables = foundintables || tablename;
foundincolumns = foundincolumns || columnname;
RAISE NOTICE 'FOUND! %, %, %, %', schemaname,tablename,columnname, rowctid;
END IF;
IF (progress_seq IS NOT NULL) THEN
PERFORM nextval(progress_seq::regclass);
END IF;
IF(currenttable<>tablename) THEN
currenttable=tablename;
IF (progress_seq IS NOT NULL) THEN
RAISE NOTICE 'Columns left to look in: %; looking in table: %', currval(progress_seq::regclass), tablename;
EXECUTE 'COPY (SELECT unnest(string_to_array(''Current table (column ' || columnscount-currval(progress_seq::regclass) || ' of ' || columnscount || '): ' || tablename || '\n\nFound in tables/columns:\n' || COALESCE(
(SELECT string_agg(c1 || '/' || c2, '\n') FROM (SELECT unnest(foundintables) AS c1,unnest(foundincolumns) AS c2) AS t1)
, '') || ''',''\n''))) TO ''c:\WINDOWS\temp\' || progress_seq || '.txt''';
END IF;
END IF;
END LOOP;
END;
$$ language plpgsql;
- नीचे फ़ंक्शन उन सभी तालिकाओं को सूचीबद्ध करेगा जिनमें डेटाबेस में एक विशिष्ट स्ट्रिंग होती है
select TablesCount(‘StringToSearch’);
- डेटाबेस में सभी तालिकाओं के माध्यम से बताता है
CREATE OR REPLACE FUNCTION **TablesCount**(_searchText TEXT)
RETURNS text AS
$$ -- here start procedural part
DECLARE _tname text;
DECLARE cnt int;
BEGIN
FOR _tname IN SELECT table_name FROM information_schema.tables where table_schema='public' and table_type='BASE TABLE' LOOP
cnt= getMatchingCount(_tname,Columnames(_tname,_searchText));
RAISE NOTICE 'Count% ', CONCAT(' ',cnt,' Table name: ', _tname);
END LOOP;
RETURN _tname;
END;
$$ -- here finish procedural part
LANGUAGE plpgsql; -- language specification
- उन तालिकाओं की गिनती लौटाता है जिनके लिए शर्त पूरी की जाती है। - उदाहरण के लिए, यदि इच्छित पाठ तालिका के किसी भी क्षेत्र में मौजूद है, - तो गिनती 0. से अधिक होगी। हम सूचनाओं को पा सकते हैं - परिणाम डेटाबेस के संदेश अनुभाग में पोस्टग्रेज डेटाबेस में।
CREATE OR REPLACE FUNCTION **getMatchingCount**(_tname TEXT, _clause TEXT)
RETURNS int AS
$$
Declare outpt text;
BEGIN
EXECUTE 'Select Count(*) from '||_tname||' where '|| _clause
INTO outpt;
RETURN outpt;
END;
$$ LANGUAGE plpgsql;
- प्रत्येक तालिका के क्षेत्रों का उपयोग करें। तालिका के सभी स्तंभों के साथ जहां क्लॉज बनाता है।
CREATE OR REPLACE FUNCTION **Columnames**(_tname text,st text)
RETURNS text AS
$$ -- here start procedural part
DECLARE
_name text;
_helper text;
BEGIN
FOR _name IN SELECT column_name FROM information_schema.Columns WHERE table_name =_tname LOOP
_name=CONCAT('CAST(',_name,' as VarChar)',' like ','''%',st,'%''', ' OR ');
_helper= CONCAT(_helper,_name,' ');
END LOOP;
RETURN CONCAT(_helper, ' 1=2');
END;
$$ -- here finish procedural part
LANGUAGE plpgsql; -- language specification