Эта функция подробно рассматривалась во второй части статьи "Функции для документирования баз данных PostgreSQL".

Со времени публикации той статьи прошло 6 лет. В ней приведены функции актуальные для PostgreSQL версий 9.3, 9.4. В последующих версиях были внесены изменения в структуру каталога pg_am. В результате нерабочими оказались функции, возвращающие характеристики индексов. Причина в том, что из каталога pg_am удалён признак amcanorder, определяющий возможность упорядочения данных атрибутов индекса. Поэтому в следующих версиях PostgreSQL порядок расположения атрибутов индекса (ASC, DESC) определяется без учета значения признака amcanorder. И как следствие возникает ошибка выполнения функции.

Здесь рассматривается измененная версия функции admtf_Table_Indexes

SELECT inxcls.relname AS r_IndexName ,inxam.amname AS r_IndexType,inx.indisunique AS r_isUnique,inx.indisprimary AS r_isPrimary,
			STRING_AGG(attr.attname|| CASE inx.indoption[inx.No] & 1 WHEN 1 THEN ' DESC' ELSE ' ASC'	END,
				c_Delimiter ORDER BY inx.No)
		FROM (SELECT i.indrelid, i.indexrelid,i.indisunique,i.indisprimary,i.indkey::SMALLINT[], 
				i.indoption::SMALLINT[],generate_subscripts(i.indkey, 1) as No FROM pg_index i) inx	
			                            INNER JOIN pg_class inxcls ON inx.indexrelid=inxcls.oid 
					INNER JOIN pg_am inxam ON inxcls.relam=inxam.oid
					INNER JOIN  pg_class tbl ON inx.indrelid=tbl.oid
					INNER JOIN pg_namespace nsp ON tbl.relnamespace=nsp.oid 
					INNER JOIN pg_attribute attr ON attr.attrelid=tbl.OID AND attr.attnum=inx.indkey[inx.No]
				WHERE LOWER(nsp.nspname)=LOWER(a_SchemaName) AND LOWER(tbl.relname)=LOWER(a_TableName)
				GROUP BY inxcls.relname,inxam.amname,inx.indisunique,inx.indisprimary
				ORDER BY inxcls.relname;

CASE inx.indoption[inx.No] & 1 
                                        WHEN 1 THEN ' DESC' 
                                        ELSE ' ASC'  END;

-- Первый вариант - классический
        SELECT  attr.*,tbl.*
                FROM pg_class tbl
                    INNER JOIN pg_attribute attr ON attr.attrelid=tbl.oid
					INNER JOIN pg_namespace nsp ON tbl.relnamespace=nsp.oid 
                WHERE tbl.relname==a_SchemaName AND nsp.nspname=a_SchemaName
                        AND attr.attname=a_AttributeName
                ORDER BY tbl.relname,attr.attname;
-- Второй вариант - без каталога pg_namespace с использованием типа regclass
        SELECT  attr.*,tbl.*
                FROM pg_class tbl
                    INNER JOIN pg_attribute attr ON attr.attrelid=tbl.oid
                WHERE tbl.oid=(a_SchemaName||'.'||a_TableName)::regclass
                        AND attr.attname=a_AttributeName
                ORDER BY tbl.relname,attr.attname;
-- Третий вариант - только с каталогом pg_attribute с использованием типа regclass
        SELECT  attr.*
                FROM pg_attribute attr 
                WHERE attr.attrelid=(a_SchemaName||'.'||a_TableName)::regclass
                        AND attr.attname=a_AttributeName
                ORDER BY attr.attname;

SELECT ARRAY_AGG(tbl.relname) 
FROM pg_class tbl INNER JOIN pg_namespace nsp ON tbl.relnamespace=nsp.oid 
WHERE LOWER(nsp.nspname)=LOWER(a_SchemaName) AND tbl.relkind=LOWER('r') AND (a_WHEREoption);

v_ForeignKeyRole:=admfn_Table_ForeignKeyRole(a_SchemaName,a_TableName,a_FKConstrantName);
IF v_ForeignKeyRole='Constrained' THEN	v_CurrSign:=admfn_Table_ConstrainedLinkSign(a_SchemaName,a_TableName,a_FKConstrantName);	v_LinkSign:=v_CurrSign||':'||'1';
ELSIF v_ForeignKeyRole='Referenced'THEN	v_ConstrainedTableName:=admfn_ForeignKey_ConstrainedTableName(a_SchemaName,a_FKConstrantName);	v_CurrSign:=admfn_Table_ConstrainedLinkSign(a_SchemaName,v_ConstrainedTableName,a_FKConstrantName);	v_LinkSign:= '1'||':'||v_CurrSign;
ELSE	v_CurrSign:=NULL;
END IF;

SELECT CASE (a_SchemaName ||'.'||a_TableName)::regclass WHEN con.conrelid THEN 'Constrained'								WHEN con.confrelid THEN 'Referenced' END
FROM pg_constraint con
WHERE LOWER(con.conname)=LOWER(a_FKConstrantName) AND con.contype='f';

ALTER TABLE IF EXISTS public.streetsynonym
		ADD CONSTRAINT fk_streetsynonym_street FOREIGN KEY (wcrccode, streetid, localityid)
			REFERENCES public.street (wcrccode, streetid, localityid) MATCH FULL
			ON UPDATE NO ACTION
			ON DELETE NO ACTION;

SELECT bl.relname
FROM pg_constraint con 	
  INNER JOIN pg_namespace nspc ON con.connamespace = nspc.oid
  INNER JOIN pg_class tbl ON con.conrelid=tbl.oid
WHERE nspc.nspname=LOWER(a_SchemaName) AND con.contype ='f'	
   AND con.conname =LOWER(a_FKConstrantName);

SELECT ARRAY_AGG(att.attname)
FROM (SELECT c.conrelid,c.conkey, GENERATE_SUBSCRIPTS(c.conkey, 1) PKAttributeID 
		FROM pg_constraint c 
		WHERE c.contype='p' AND c.conrelid=(LOWER(a_SchemaName)||'.'||LOWER(a_TableName))::regclass
		ORDER BY PKAttributeID) patt
	INNER JOIN pg_attribute att ON att.attrelid=patt.TableOID AND att.attnum=patt.PKAttributeID;

SELECT ARRAY_AGG(att.attname)
FROM (SELECT c.conrelid,c.conkey, GENERATE_SUBSCRIPTS(c.conkey, 1) PKAttributeID 
		FROM pg_constraint c 
		WHERE c.contype='f' AND c.conrelid=(LOWER(a_SchemaName)||'.'||LOWER(a_TableName))::regclass 
			AND c.conname=LOWER(TRIM(a_FKConstrantName))
		ORDER BY PKAttributeID) patt
	INNER JOIN pg_attribute att ON att.attrelid=patt.TableOID AND att.attnum=patt.PKAttributeID;

SELECT inx.indisunique
		FROM pg_index inx 
		WHERE inx.indrelid=(TRIM(LOWER(a_SchemaName))||'.'||TRIM(LOWER(a_TableName)))::regclass AND inx.indisunique
			AND (inx.indisprimary=FALSE OR inx.indisprimary = a_isPrimaryNeed)

SELECT ti.r_IndexName,ti.r_IndexType,ti.r_isUnique,ti.r_isPrimary,ti.r_IndexKeyNames
		FROM admtf_Table_Indexes(a_SchemaName, a_TableName, a_isPrimaryNeed) ti 
		WHERE ti.r_isUnique;

v_CurrentElement:=SUBSTRING(v_CurrentElement FROM 2 FOR LENGTH(v_CurrentElement)-2)

v_CurrentElement:=SUBSTRING(v_CurrentElement FROM 2 FOR LENGTH(v_CurrentElement)-2)

BEGIN TRANSACTION; 
DROP FUNCTION IF EXISTS admtf_Table_Indexes (a_SchemaName NAME, a_TableName NAME);
DROP FUNCTION IF EXISTS admtf_Table_Indexes (a_SchemaName NAME, a_TableName NAME,a_isOrderNeed BOOLEAN);
/*******************************************************************************************************/
/*  Функция возвращает список индексов таблицы								*/
/*------------------------------------------------------------------------------------------------------*/
/*  Это универсальная версия функции, которая может выполняться как в POSTGRESQL 9.3., 			*/
/*  так и в следующих версиях	                                						*/
/********************************************************************************************************/
CREATE OR REPLACE FUNCTION admtf_Table_Indexes
			(a_SchemaName	NAME default 'public',/* название схемы базы данных		*/				
			a_TableName	NAME default NULL, 	/* Название таблицы */
			a_isOrderNeed	BOOLEAN default TRUE	/* Нужно ли добавлять признак порядка сортировки для каждого атрибута индекса? */
 )

RETURNS  TABLE (r_IndexName NAME,r_IndexType NAME,r_isUnique BOOLEAN,r_isPrimary BOOLEAN, r_IndexKeyNames Text) AS
$BODY$
DECLARE
	c_IndexKind             CONSTANT CHAR:='i';
	c_Delimiter             CONSTANT VARCHAR(2):=',';
	c_AmCanOrderAttrName    CONSTANT VARCHAR(256):='amcanorder';
	c_AdmnSchemaName        CONSTANT VARCHAR(256):='pg_catalog';
	c_withOrder             CONSTANT BOOLEAN:=TRUE; /* Обязательно добавлять признак порядка сортировки для каждого атрибута индекса */
	v_IndexRec		RECORD;			/* Данные об индексе*/
	v_Scale			INTEGER;		/* Масштаб колонки */
	v_TableOID		INTEGER;		/* OID таблицы*/
	v_IndexOID		INTEGER;		/* OID индекса*/
	v_IndexKeyNos		SMALLINT[];		/* Массив порядковых номеров атрибутов*/
	v_IndexKeyOps		SMALLINT[];		/* Массив опций атрибутов индекса*/
	v_IndexName		NAME;			/* Название индекса */
	v_IndexAMName		NAME;			/* Наименование типа индекса (метода доступа) */
	v_isUnique	 	BOOLEAN;		/* Признак уникальности индекса*/
	v_isPrimary	 	BOOLEAN;		/* Признак того что индекс представляет Primary KEY таблицы*/
	v_AttributeNum		INTEGER;		/* Порядковый номер атрибута*/
	v_AttributeOrderCode	INTEGER;		/* Признак упорядоченности атрибута*/
	v_AttributeName	NAME;			/* Наименование атрибута*/
	v_AmCanOrder		BOOLEAN;	 	/* Поддерживает ли метод доступа упорядоченное сканирование по значению */
							/* индексируемого столбца?*/
	v_OrderDirect		VARCHAR(10);		/* Направление упорядоченности атрибута в индексе*/
	v_IndexKeyNames	TEXT;			/* Строка со списком атрибутов индекса*/
	v_IndexAttributeLBound	INTEGER;		/* Нижний индекс масссива атрибутов индекса*/		
	v_IndexAttributeUBound	INTEGER;		/* Верхний индекс масссива атрибутов индекса*/		
	v_IndexAttributeIndx	INTEGER;		/* Текущий индекс масссива атрибутов индекса*/		
	v_pg_am_Version	INTEGER; 	/* Версия таблицы 'pg_am':  0 - версия postgresql ниже 9.6; 1 - версия postgresql выше 9.6  */
	v_isOrderNeed		BOOLEAN; 	/* Нужно ли добавлять признак порядка сортировки для каждого атрибута индекса? */
	v_SELECTStatement	TEXT; 		/* Оператор SELECT  */
	--******************************************************************************************************		
BEGIN
	v_isOrderNeed:=COALESCE(a_isOrderNeed,c_withOrder);
	IF  admfn_Table_isAttributeExists(c_AdmnSchemaName,'pg_am',c_AmCanOrderAttrName) THEN
		v_pg_am_Version:=0;
 	ELSE
		v_pg_am_Version:=1;
	END IF;
	FOR v_IndexRec IN SELECT inxcls.oid AS IndexOID,tbl.oid AS TableOID,inxcls.relname AS IndexName,
				inxam.amname AS IndexAMName,inx.indisunique AS isUnique,inx.indisprimary isPrimary,
				inx.indkey::SMALLINT[] AS IndexKeyNos,inx.indoption::SMALLINT[] AS IndexKeyOps, TRUE AS AmCanOrder
			FROM pg_index inx 
				INNER JOIN pg_class inxcls ON inx.indexrelid=inxcls.oid 
				INNER JOIN pg_am inxam ON inxcls.relam=inxam.oid
				INNER JOIN  pg_class tbl ON inx.indrelid=tbl.oid
				INNER JOIN pg_namespace nsp ON tbl.relnamespace=nsp.oid 
			WHERE LOWER(nsp.nspname)=LOWER(a_SchemaName) AND inxcls.relkind=c_IndexKind
				AND tbl.relname=LOWER(a_TableName)
			ORDER BY inxam.amname, inxcls.relname LOOP
		v_IndexOID:=v_IndexRec.IndexOID;
		v_TableOID:=v_IndexRec.TableOID;
		v_IndexName:=v_IndexRec.IndexName;
		v_IndexAMName:=v_IndexRec.IndexAMName;
		v_isUnique:=v_IndexRec.isUnique;
		v_isPrimary:=v_IndexRec.isPrimary;
		v_IndexKeyNos:=v_IndexRec.IndexKeyNos;
		v_IndexKeyOps:=v_IndexRec.IndexKeyOps;
		v_AmCanOrder:=v_IndexRec.AmCanOrder;
		v_IndexKeyNames:='';
		v_IndexAttributeLBound:=array_lower(v_IndexKeyNos,1);
		v_IndexAttributeUBound:=array_upper(v_IndexKeyNos,1);
 		IF v_pg_am_Version=0 THEN
			v_SELECTStatement:='SELECT inxam.amcanorder AS AmCanOrder FROM pg_am AS inxam
				WHERE inxam.oid='||TRIM(TO_CHAR(v_IndexOID,'9999999999'));
			EXECUTE v_SELECTStatement INTO v_AmCanOrder;  
		END IF;  
		FOR v_IndexAttributeIndx IN v_IndexAttributeLBound .. v_IndexAttributeUBound
		LOOP
			v_AttributeNum:=v_IndexKeyNos[v_IndexAttributeIndx];
			v_AttributeOrderCode:=v_IndexKeyOps[v_IndexAttributeIndx];
			SELECT INTO v_AttributeName attr.attname::VARCHAR(100) AS r_AttributeName
				FROM pg_attribute attr 
				WHERE attr.attrelid=v_TableOID AND attr.attnum=v_AttributeNum;
			v_OrderDirect:=CASE WHEN NOT v_AmCanOrder THEN ''
					ELSE CASE WHEN v_AttributeOrderCode & 1=1 THEN 'DESC' 
						  ELSE 'ASC' 
					      END 
					END;
			v_IndexKeyNames:=v_IndexKeyNames||CASE WHEN v_IndexKeyNames='' THEN '' ELSE c_Delimiter||' ' END || 
						v_AttributeName||CASE WHEN NOT v_isOrderNeed OR v_OrderDirect='' THEN '' 
									ELSE ' '||v_OrderDirect END;	
		END LOOP;		
		RETURN QUERY SELECT v_IndexName,v_IndexAMName,v_isUnique,v_isPrimary,v_IndexKeyNames;					
	END LOOP;			
	RETURN;
END
$BODY$
LANGUAGE plpgsql;
COMMENT ON FUNCTION admtf_Table_Indexes(a_SchemaName NAME, a_TableName NAME,a_isOrderNeed BOOLEAN) IS 'Возвращает список индексов таблицы';
--ROLLBACK TRANSACTION;
COMMIT TRANSACTION;

BEGIN TRANSACTION;
DROP FUNCTION IF EXISTS admtf_Table_Indexes (a_SchemaName VARCHAR(256), a_TableName VARCHAR(256));
DROP FUNCTION IF EXISTS admtf_Table_Indexes (a_SchemaName VARCHAR(256), a_TableName VARCHAR(256),a_isOrderNeed BOOLEAN);
/********************************************************************************************************/
/*  Функция возвращает список индексов таблицы								*/
/********************************************************************************************************/
CREATE OR REPLACE FUNCTION admtf_Table_Indexes
			(a_SchemaName	VARCHAR(256) default 'public',/* название схемы базы данных		*/				
			a_TableName	VARCHAR(256) default NULL, 	/* Название таблицы */
			a_isOrderNeed	BOOLEAN default TRUE		/* Нужно ли добавлять признак порядка сортировки */
									/* для каждого атрибута индекса? */
)

RETURNS  TABLE (r_IndexName VARCHAR(256),r_IndexType VARCHAR(256),r_isUnique BOOLEAN,r_isPrimary BOOLEAN, r_IndexKeyNames TEXT) AS
$BODY$
DECLARE
--******************************************************************************************************		
BEGIN
	RETURN QUERY SELECT ti.r_IndexName::VARCHAR(256),ti.r_IndexType::VARCHAR(256),ti.r_isUnique::BOOLEAN,
				ti.r_isPrimary::BOOLEAN, ti.r_IndexKeyNames::TEXT
			FROM admtf_Table_Indexes(a_SchemaName::NAME,a_TableName::NAME,a_isOrderNeed) ti;
END
$BODY$
LANGUAGE plpgsql;
COMMENT ON FUNCTION admtf_Table_Indexes(a_SchemaName VARCHAR(256), a_TableName VARCHAR(256),a_isOrderNeed BOOLEAN)
					IS 'Возвращает список индексов таблицы';
--ROLLBACK TRANSACTION;
COMMIT TRANSACTION;
SELECT * FROM admtf_Table_Indexes('public'::NAME,'Street'::NAME,FALSE);
SELECT * FROM admtf_Table_Indexes('public'::VARCHAR(256),'Street'::VARCHAR(256));

BEGIN TRANSACTION;
DROP FUNCTION IF EXISTS admfn_Table_isAttributeExists (a_SchemaName VARCHAR(256),a_TableName VARCHAR(256),a_AttributeName VARCHAR(256));
/********************************************************************************************************/
/*  Функция возвращает признак наличия в таблице атрибута (колонки) с заданным именем			*/
/********************************************************************************************************/
CREATE OR REPLACE FUNCTION admfn_Table_isAttributeExists
			(a_SchemaName	VARCHAR(256) default 'public',	/* название схемы базы данных*/
			a_TableName	VARCHAR(256) default NULL,	/* Название таблицы */
			a_AttributeName VARCHAR(256) default NULL	/* Название атрибута*/
) 
RETURNS  BOOLEAN AS
$BODY$
DECLARE	c_TableKind	CONSTANT CHAR:='r';
	c_DoubleQuote	CONSTANT CHAR:='"';
	v_TableOID		OID;			/*OID таблицы */
	v_AttributeNo		SMALLINT;		/* Порядковый номер найденного атрибута */
	v_AttributeName		VARCHAR(256);		/* Название найденного атрибута */

	v_isAttributeExists	BOOLEAN;		/* признак наличия аттрибута в таблице */
	--******************************************************************************************************		
BEGIN
	v_TableOID:=NULL;	
	IF STRPOS(a_TableName, c_DoubleQuote)>0 OR cnfn_String_IsLatin(a_TableName)<>'LatinAll' THEN
		SELECT INTO v_TableOID tbl.oid 
				FROM pg_class tbl 
		
					INNER JOIN pg_namespace nsp ON tbl.relnamespace=nsp.oid 
				WHERE nsp.nspname=a_SchemaName AND tbl.relname=REPLACE(a_TableName,c_DoubleQuote,'') AND tbl.relkind=LOWER(c_TableKind);

	ELSE
		SELECT INTO v_TableOID tbl.oid 
				FROM pg_class tbl 
		
					INNER JOIN pg_namespace nsp ON tbl.relnamespace=nsp.oid 
				WHERE LOWER(nsp.nspname)=LOWER(a_SchemaName) AND LOWER(tbl.relname)=LOWER(a_TableName) AND tbl.relkind=LOWER(c_TableKind);
	END IF;			
	IF NOT FOUND THEN 
		v_TableOID:=NULL;		
	END IF;
	IF v_TableOID IS NULL THEN 		
		v_isAttributeExists:=NULL;
	ELSE	
		IF STRPOS(a_AttributeName, c_DoubleQuote)>0 OR cnfn_String_IsLatin(a_AttributeName)<>'LatinAll' THEN
			SELECT INTO v_AttributeName,v_AttributeNo att.attname,att.attnum FROM pg_attribute att 
					WHERE att.attrelid=v_TableOID AND att.attname=REPLACE(a_AttributeName,c_DoubleQuote,''); 
		ELSE
			SELECT INTO v_AttributeName,v_AttributeNo att.attname,att.attnum FROM pg_attribute att 
					WHERE att.attrelid=v_TableOID AND att.attname=LOWER(a_AttributeName); 
		END IF;
		IF FOUND THEN
			v_isAttributeExists:=true;
		ELSE
			v_isAttributeExists:=false;
		END IF;
	END IF;
	RETURN v_isAttributeExists;
END
$BODY$
LANGUAGE plpgsql;
COMMENT ON FUNCTION admfn_Table_isAttributeExists(a_SchemaName VARCHAR(256),a_TableName VARCHAR(256),a_AttributeName VARCHAR(256)) IS 'Возвращает признак наличия в таблице атрибута (колонки) с заданным именем';
--ROLLBACK TRANSACTION;
COMMIT TRANSACTION;
SELECT admfn_Table_isAttributeExists('public','Street','StreetTypeAcrm'),
       admfn_Table_isAttributeExists('public','Street','StreetTypeName'),
       admfn_Table_isAttributeExists('public','StreetType','StreetTypeName');

BEGIN TRANSACTION;
DROP FUNCTION IF EXISTS admfn_Table_TableNameArray (a_SchemaName VARCHAR(256),a_WHEREoption VARCHAR(256));
/********************************************************************************************************/
/*  Функция возвращает массив названий таблиц, созданный из записей запроса на выбор таблиц 		*/
/* из системного каталога, условие которого передано одним из параметров			  	*/
/********************************************************************************************************/
CREATE OR REPLACE FUNCTION admfn_Table_TableNameArray
			(a_SchemaName	VARCHAR(256) default 'public',	/* название схемы базы данных		*/				
			a_WHEREoption	VARCHAR(1000) default NULL	/* условие запроса на выбор таблиц из системного каталога */
			
	
 )										 

RETURNS  VARCHAR(256)[] AS
$BODY$
DECLARE	c_TableKind	CONSTANT CHAR:='r';
	c_SELECT_StatementBase CONSTANT VARCHAR(1000):='SELECT tbl.relname FROM pg_class tbl INNER JOIN pg_namespace nsp ON tbl.relnamespace=nsp.oid 
								WHERE LOWER(nsp.nspname)=LOWER('|| quote_literal(a_SchemaName)||') AND tbl.relkind=LOWER('||quote_literal(c_TableKind)||')';
	c_ORDER_BY_OPTION CONSTANT VARCHAR(100):='ORDER BY tbl.relname';

	cursor_pg_class refcursor;

	v_TableRowCount		INTEGER;		/* Счетчик выбранных таблиц*/
	v_SELECT_Statement 	VARCHAR(1000);		/* Текст оператора SELECT для выбора таблиц*/
	v_AloneTableName 	VARCHAR(256);		/* Название одной из выбранных таблиц */
	v_TableNameArray	VARCHAR(256)[];		/* Массив выбранных таблиц  */
	v_isExpressionCorrect	BOOLEAN;		/* Признак правильности выражения WHERE  */
	v_Return_Error		INTEGER:=0;		/* Код возврата*/
	--******************************************************************************************************		
BEGIN		
	v_SELECT_Statement:=c_SELECT_StatementBase || CASE WHEN COALESCE(TRIM(a_WHEREoption),'')='' THEN ' ' ELSE ' AND ('||TRIM(a_WHEREoption)||') ' END
							|| c_ORDER_BY_OPTION || ';';
    BEGIN
        EXECUTE v_SELECT_Statement;
        v_isExpressionCorrect:=TRUE;
        IF v_Return_Error=0 AND v_SELECT_Statement IS NOT NULL AND v_isExpressionCorrect THEN							
            OPEN cursor_pg_class FOR EXECUTE v_SELECT_Statement;
            v_TableRowCount:=0;
            FETCH FIRST FROM cursor_pg_class INTO v_AloneTableName;
            WHILE FOUND
            LOOP
                v_TableRowCount:=v_TableRowCount+1;	
                v_TableNameArray[v_TableRowCount]:=CASE WHEN v_AloneTableName~ E'[A-ZА-ЯЁ]' THEN ''''||v_AloneTableName||'''' ELSE v_AloneTableName END;
                FETCH NEXT  FROM cursor_pg_class INTO v_AloneTableName;
            END LOOP;
            CLOSE cursor_pg_class;
        END IF;	
        EXCEPTION
       WHEN OTHERS THEN
            v_isExpressionCorrect:=FALSE;
            v_TableNameArray:=NULL;
            RAISE NOTICE 'ОШИБКА. Проверьте правильность ВЫРАЖЕНИЯ для WHERE. 
                          ПАРАМЕТРЫ создания: ********************************************************************
                        Схема                           - "%"
                        условие выбора                  - "%"
                        Системный код (SQLSTATE)        - "%"
                        Системное сообщение (SQLERRM)   - "%"
                                            **********************************************************************',
                                           a_SchemaName,a_WHEREoption,SQLSTATE,SQLERRM;

    END;

	RETURN v_TableNameArray;
END
$BODY$
LANGUAGE plpgsql;
COMMENT ON FUNCTION admfn_Table_TableNameArray(a_SchemaName VARCHAR(256),a_WHEREoption VARCHAR(1000)) IS 'Возвращает массив названий таблиц, созданный из записей запроса';

--ROLLBACK TRANSACTION;
COMMIT TRANSACTION;
SELECT * FROM unnest(admfn_Table_TableNameArray('public','tbl.relname ~* E''^Street'''));

BEGIN TRANSACTION;
DROP FUNCTION IF EXISTS admfn_Table_LinkSign (a_SchemaName NAME,a_TableName NAME,a_FKConstrantName NAME);
/************************************************************************************************************************/
/*  Функция возвращает Возвращает признак связи между таблицами ('N:1','1:1'), соответствующей ограничению Foreign Key	*/
/************************************************************************************************************************/
CREATE OR REPLACE FUNCTION admfn_Table_LinkSign
			(a_SchemaName		NAME default 'public',	/* название схемы базы данных		*/				
			a_TableName		NAME default NULL,	/* Название таблицы */
			a_FKConstrantName	NAME default NULL	/* Название ограничения ForeignKey */
)
RETURNS  VARCHAR(5) AS
$BODY$
DECLARE	c_ManySign		CONSTANT CHAR:='N';
	c_OneSign		CONSTANT CHAR:='1';
	c_DelimiterSign		CONSTANT CHAR:=':';
	c_ReferencedRole	CONSTANT VARCHAR(20):='Referenced';	/* Обозначение таблицы, на которую ссылается 'внешний ключ */
	c_ConstrainedRole	CONSTANT VARCHAR(20):='Constrained';	/* обозначение  таблицы, которая содержат ограничение 'внешний ключ' */
	v_ForeignKeyRole		VARCHAR(20);			/* РОль таблицы в ограничении 'внешний ключ' */
	v_CurrSign		CHAR;				/* Признак таблицы в текущей связи */
	v_LinkSign		VARCHAR(5);			/* Признак связи по отношения к таклице*/
	v_ConstrainedTableName	NAME;			/* Название таблицы, которая содержат ограничение 'внешний ключ' */
	--******************************************************************************************************		
BEGIN		
	v_ForeignKeyRole	:=admfn_Table_ForeignKeyRole(a_SchemaName,a_TableName,a_FKConstrantName);
	IF v_ForeignKeyRole=c_ConstrainedRole THEN
		v_CurrSign:=admfn_Table_ConstrainedLinkSign(a_SchemaName,a_TableName,a_FKConstrantName);
		v_LinkSign:=v_CurrSign||c_DelimiterSign||c_OneSign;		
	ELSIF v_ForeignKeyRole=c_ReferencedRole THEN
		v_ConstrainedTableName:=admfn_ForeignKey_ConstrainedTableName(a_SchemaName,a_FKConstrantName);
		v_CurrSign:=admfn_Table_ConstrainedLinkSign(a_SchemaName,v_ConstrainedTableName,a_FKConstrantName);
		v_LinkSign:=c_OneSign||c_DelimiterSign||v_CurrSign;
	ELSE
		v_CurrSign:=NULL;
	END IF;	
	RETURN v_LinkSign;
END
$BODY$
LANGUAGE plpgsql;
COMMENT ON FUNCTION admfn_Table_LinkSign(a_SchemaName NAME,a_TableName NAME,a_FKConstrantName NAME) IS 'Возвращает признак связи между таблицами (''N:1'',''1:1''), соответствующей ограничению Foreign Key  ';
--ROLLBACK TRANSACTION;
COMMIT TRANSACTION;
BEGIN TRANSACTION;
DROP FUNCTION IF EXISTS admfn_Table_LinkSign (a_SchemaName VARCHAR(256),a_TableName VARCHAR(256),a_FKConstrantName VARCHAR(256));
/********************************************************************************************************/
/*  Функция возвращает Возвращает признак связи между таблицами ('N:1','1:1'), соответствующей ограничению Foreign Key	*/
/************************************************************************************************************************/
CREATE OR REPLACE FUNCTION admfn_Table_LinkSign
			(a_SchemaName		VARCHAR(256) default 'public',	/* название схемы базы данных		*/				
			a_TableName		VARCHAR(256) default NULL,	/* Название таблицы */
			a_FKConstrantName	VARCHAR(256) default NULL	/* Название ограничения ForeignKey */
			
	
 )										 

RETURNS  VARCHAR(5) AS
$BODY$
DECLARE	v_LinkSign		VARCHAR(5);			/* Признак связи по отношения к таклице*/
	--******************************************************************************************************		
BEGIN		
	v_LinkSign:=admfn_Table_LinkSign(a_SchemaName::NAME,a_TableName::NAME,a_FKConstrantName::NAME);
	RETURN v_LinkSign;

END
$BODY$
LANGUAGE plpgsql;
COMMENT ON FUNCTION admfn_Table_LinkSign(a_SchemaName VARCHAR(256),a_TableName VARCHAR(256),a_FKConstrantName VARCHAR(256)) IS 'Возвращает признак связи между таблицами (''N:1'',''1:1''), соответствующей ограничению Foreign Key  ';
COMMIT TRANSACTION;
--ROLLBACK TRANSACTION;
SELECT admfn_Table_LinkSign('public'::name,'Street'::name,'fk_street_StreetType'::name);--N:1
SELECT admfn_Table_LinkSign('public'::name,'Street'::name,'fk_streetsynonym_street'::name); --1:N
SELECT admfn_Table_LinkSign('public'::name,'StreetSynonym'::name,'fk_streetsynonym_street'::name); --N:1

BEGIN TRANSACTION;
DROP FUNCTION IF EXISTS admfn_Table_ForeignKeyRole(a_SchemaName name, a_TableName name,a_FKConstrantName name);
/********************************************************************************************************/
/*  Функция возвращает признак роли (места) таблицы в ограничении ForeignKey:							*/
/*  Referenced  - таблица, на которую ссылается 'внешний ключ'                                          */
/*  Constrained - таблица, которая ссылается на другаю таблицу через 'внешний ключ'                     */
/********************************************************************************************************/
CREATE OR REPLACE FUNCTION admfn_Table_ForeignKeyRole
			(a_SchemaName		name default 'public',	/* название схемы базы данных		*/				
			a_TableName		name default NULL,	/* Название таблицы */
			a_FKConstrantName	name default NULL	/* Название ограничения ForeignKey */
	
 )										 

RETURNS VARCHAR(10) AS
$BODY$
DECLARE
	c_ForeignTypeType	CONSTANT VARCHAR(2):='f';	/* Буквенное обозначение типа ограничения 'внешний ключ' */
	c_ReferencedRole	CONSTANT VARCHAR(20):='Referenced';	/* Обозначение таблицы, на которую ссылается 'внешний ключ' */
	c_ConstrainedRole	CONSTANT VARCHAR(20):='Constrained';	/* обозначение  таблицы, которая содержат ограничение 'внешний ключ' */
	v_ForeignKeyRole		VARCHAR(20);				/* РОль таблицы в ограничении 'внешний ключ' */
	--******************************************************************************************************		
BEGIN		
	v_ForeignKeyRole:=NULL;		
	SELECT INTO v_ForeignKeyRole CASE WHEN (SELECT tbl.relname FROM pg_class tbl WHERE con.conrelid=tbl.oid) =LOWER(a_TableName)
						THEN c_ConstrainedRole 
					WHEN (SELECT reftbl.relname FROM pg_class reftbl WHERE con.confrelid=reftbl.oid) =LOWER(a_TableName)
						THEN c_ReferencedRole
					ELSE 
						NULL
				END		
			FROM pg_constraint con INNER JOIN pg_namespace nsp ON con.connamespace=nsp.oid 
			WHERE LOWER(nsp.nspname)=LOWER(a_SchemaName) AND LOWER(con.conname)=LOWER(a_FKConstrantName)
				AND con.contype=c_ForeignTypeType;
	RETURN v_ForeignKeyRole;
END
$BODY$
LANGUAGE plpgsql;
COMMENT ON FUNCTION admfn_Table_ForeignKeyRole(a_SchemaName name, a_TableName name,a_FKConstrantName name) 
            IS 'Возвращает признак роли (места) таблицы в ограничении ForeignKey: Referenced  - таблица, на которую ссылается "внешний ключ"; Constrained - таблица, которая ссылается на другаю таблицу через "внешний ключ"';

--ROLLBACK TRANSACTION;
COMMIT TRANSACTION;
BEGIN TRANSACTION;
DROP FUNCTION IF EXISTS admfn_Table_ForeignKeyRole(a_SchemaName VARCHAR(256), a_TableName VARCHAR(256),a_FKConstrantName VARCHAR(256));
/********************************************************************************************************/
/*  Функция возвращает признак роли (места) таблицы в ограничении ForeignKey:							*/
/*  Referenced  - таблица, на которую ссылается 'внешний ключ'                                          */
/*  Constrained - таблица, которая ссылается на другаю таблицу через 'внешний ключ'                     */
/********************************************************************************************************/
CREATE OR REPLACE FUNCTION admfn_Table_ForeignKeyRole
			(a_SchemaName	VARCHAR(256) default 'public',	/* название схемы базы данных */
			a_TableName	VARCHAR(256) default NULL,	/* Название таблицы */
			a_FKConstrantName	VARCHAR(256) default NULL	/* Название ограничения ForeignKey */
	
 )										 

RETURNS   VARCHAR(10) AS
$BODY$
DECLARE
	c_ForeignTypeType	CONSTANT VARCHAR(2):='f';	/* Буквенное обозначение типа ограничения 'внешний ключ ключ' */
	c_ReferencedRole	CONSTANT VARCHAR(20):='Referenced';	/* Обозначение таблицы, на которую ссылается 'внешний ключ */
	c_ConstrainedRole	CONSTANT VARCHAR(20):='Constrained';	/* обозначение  таблицы, которая содержат ограничение 'внешний ключ' */
	v_ForeignKeyRole		VARCHAR(20);				/* РОль таблицы в ограничении 'внешний ключ' */
	--******************************************************************************************************		
BEGIN		
	v_ForeignKeyRole:=admfn_Table_ForeignKeyRole(a_SchemaName::NAME,a_TableName::NAME,a_FKConstrantName::NAME);
	RETURN v_ForeignKeyRole;
END
$BODY$
LANGUAGE plpgsql;
COMMENT ON FUNCTION admfn_Table_ForeignKeyRole(a_SchemaName VARCHAR(256), a_TableName VARCHAR(256),a_FKConstrantName VARCHAR(256)) 
            IS 'Возвращает признак роли (места) таблицы в ограничении ForeignKey: Referenced  - таблица, на которую ссылается "внешний ключ"; Constrained - таблица, которая ссылается на другаю таблицу через "внешний ключ"';


--ROLLBACK TRANSACTION;
COMMIT TRANSACTION;

SELECT admfn_Table_ForeignKeyRole('public'::name,'Street'::name,'fk_StreetSynonym_Street'::name);
SELECT admfn_Table_ForeignKeyRole('public'::name,'StreetSynonym'::name,'fk_StreetSynonym_Street'::name);

BEGIN TRANSACTION;
DROP FUNCTION IF EXISTS admfn_Table_ConstrainedLinkSign (a_SchemaName NAME,a_TableName NAME,a_FKConstrantName NAME);
/********************************************************************************************************************/
/*  Функция возвращает признак количества записей, участвующих в связи, соответствующей ограничению Foreign Key,    */ 
/*  со стороны таблицы: "N" - много,"1"- одна.                                                                      */
/*------------------------------------------------------------------------------------------------------------------*/
/* admfn_Table_ConstrainedLinkSign('public'::VARCHAR,'Street'::VARCHAR,'fk_StreetSynonym_Street'::VARCHAR);         */
/*------------------------------------------------------------------------------------------------------------------*/
/*  "1"                                                                                                             */
/*------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------*/
/* admfn_Table_ConstrainedLinkSign('public'::VARCHAR,'StreetSynonym'::VARCHAR,'fk_StreetSynonym_Street'::VARCHAR);  */
/*------------------------------------------------------------------------------------------------------------------*/
/*  "N"                                                                                                             */
/********************************************************************************************************************/
CREATE OR REPLACE FUNCTION admfn_Table_ConstrainedLinkSign
			(a_SchemaName		NAME default 'public',	/* название схемы базы данных		*/				
			a_TableName	NAME default NULL,	/* Название таблицы */
			a_FKConstrantName	NAME default NULL	/* Название ограничения ForeignKey */
			
	
 )										 

RETURNS  VARCHAR(1) AS
$BODY$
DECLARE	c_ManySign		CONSTANT CHAR:='N';
	c_OneSign		    CONSTANT CHAR:='1';
	c_DelimiterSign		CONSTANT CHAR:=':';
	c_DelimiterKeys		CONSTANT VARCHAR(2):=',';
	c_ConstraintType	CONSTANT VARCHAR(2):='u';	/* Буквенное обозначение типа ограничения 'уникальный ключ' */
	c_ForeignTypeType	CONSTANT VARCHAR(2):='f';	/* Буквенное обозначение типа ограничения 'внешний ключ ключ' */
	c_ReferencedRole	CONSTANT VARCHAR(20):='Referenced';	/* Обозначение таблицы, на которую ссылается 'внешний ключ */
	c_ConstrainedRole	CONSTANT VARCHAR(20):='Constrained';	/* обозначение  таблицы, которая содержат ограничение 'внешний ключ' */
	c_withoutOrder      CONSTANT BOOLEAN:=FALSE; /* Не добавлять признак порядка сортировки для каждого атрибута индекса */
	v_ForeignKeyRole		VARCHAR(20);			/* РОль таблицы в ограничении 'внешний ключ' */
	v_UniqueIndex		RECORD;				/* Запись об уникальном индексе таблицы*/
	v_UniqueConstraint	RECORD;				/* Запись об уникальном  уникальном ключе таблицы*/
	v_IndexKeyNames		TEXT;			/* Строка со списком атрибутов индекса*/
	v_CurrSign		CHAR;				/* Признак таблицы в текущей связи */
	v_TablePK		NAME[];			/* Массив Названий атрибутов, составляющих внешний ключ */
	v_TableFK		NAME[];			/* Массив Названий атрибутов, составляющих внешний ключ */
	v_TableIK		NAME[];			/* Массив Названий атрибутов, в составе индекса */
	v_TableUK		NAME[];			/* Массив Названий атрибутов, составляющих уникальный ключ (уникальное значение) */
	v_IndexName		NAME;			/* Название индекса */
	v_ConstraintName	NAME;			/* Название ограничения */
	v_ConstraintType	VARCHAR(256);			/* Буквенное обозначение типа ограничения */
	v_LinkSign		VARCHAR(5);			/* Признак связи по отношения к таклице*/
    v_haveUniqueIndexes	BOOLEAN;		/* признак наличия уникальных индексов в описании таблицы */
	--******************************************************************************************************		
BEGIN		
	v_CurrSign:=c_ManySign;
	v_TableFK:=admfn_Table_TableFK(a_SchemaName,a_TableName,a_FKConstrantName);
	v_TablePK:=admfn_Table_TablePK(a_SchemaName,a_TableName);
 	v_haveUniqueIndexes:=admfn_Table_haveUniqueIndexes(a_SchemaName,a_TableName);
	IF v_TableFK=v_TablePK THEN /* CONSTRAINT в составе таблицы a_TableName и атрибуты первичного ключа совпадают с атрибутами внешнего*/
		v_CurrSign:=c_OneSign;
	ELSIF COALESCE(v_TableFK,ARRAY[NULL::NAME])=ARRAY[NULL::NAME] THEN /* CONSTRAINT ссылается на таблицу a_TableName*/
		v_ForeignKeyRole:=admfn_Table_ForeignKeyRole(a_SchemaName,a_TableName,a_FKConstrantName);
		v_CurrSign:=CASE WHEN v_ForeignKeyRole = c_ReferencedRole THEN c_OneSign ELSE NULL END;
	ELSIF v_haveUniqueIndexes THEN /* проверка совпадения списка атрибутов внешнего ключа и уникального индекса*/                                               
		FOR v_UniqueConstraint IN SELECT * FROM  admtf_Table_UniqueIndexes(a_SchemaName,a_TableName,c_withoutOrder)
						WHERE NOT r_isPrimary ORDER BY r_IndexName LOOP
			v_IndexName:=v_UniqueConstraint.r_IndexName;
			v_IndexKeyNames=v_UniqueConstraint.r_IndexKeyNames;
			v_TableIK:=string_to_array(v_IndexKeyNames, c_DelimiterKeys);
 			IF v_TableFK=v_TableIK THEN
				v_CurrSign:=c_OneSign;
			END IF;
		END LOOP;
	ELSE /* проверка совпадения списка атрибутов внешнего ключа и уникального CONSTRAINT UNIQUE*/  
		FOR v_UniqueConstraint IN SELECT * FROM admtf_Table_Constraintes(a_SchemaName,a_TableName)
						WHERE r_ConstraintType=c_ConstraintType ORDER BY r_ConstraintName 
		LOOP
			v_ConstraintName:=v_UniqueConstraint.r_ConstraintName;
			v_TableUK:=string_to_array(v_UniqueConstraint.r_ConstraintKeyNames, c_DelimiterKeys);
			IF v_TableFK=v_TableUK THEN
				v_CurrSign:=c_OneSign;
			END IF;
		END LOOP;
	END IF;
	RETURN v_CurrSign;

END
$BODY$
LANGUAGE plpgsql;
COMMENT ON FUNCTION admfn_Table_ConstrainedLinkSign(a_SchemaName NAME,a_TableName NAME,a_FKConstrantName NAME) 
IS 'Возвращает признак количества записей, участвующих в связи, соответствующей ограничению Foreign Key,со стороны таблицы: "N" - много,"1"- одна.';

COMMIT TRANSACTION;
--ROLLBACK TRANSACTION;
BEGIN TRANSACTION;
DROP FUNCTION IF EXISTS admfn_Table_ConstrainedLinkSign (a_SchemaName VARCHAR(256),a_TableName VARCHAR(256),a_FKConstrantName VARCHAR(256));
/********************************************************************************************************************/
/*  Функция возвращает признак количества записей, участвующих в связи, соответствующей ограничению Foreign Key,    */ 
/*  со стороны таблицы: "N" - много,"1"- одна.                                                                      */
/*------------------------------------------------------------------------------------------------------------------*/
/* admfn_Table_ConstrainedLinkSign('public'::VARCHAR,'Street'::VARCHAR,'fk_StreetSynonym_Street'::VARCHAR);         */
/*------------------------------------------------------------------------------------------------------------------*/
/*  "1"                                                                                                             */
/*------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------*/
/* admfn_Table_ConstrainedLinkSign('public'::VARCHAR,'StreetSynonym'::VARCHAR,'fk_StreetSynonym_Street'::VARCHAR);  */
/*------------------------------------------------------------------------------------------------------------------*/
/*  "N"                                                                                                             */
/********************************************************************************************************************/
CREATE OR REPLACE FUNCTION admfn_Table_ConstrainedLinkSign
			(a_SchemaName		VARCHAR(256) default 'public',/* название схемы базы данных	*/
			a_TableName		VARCHAR(256) default NULL,	/* Название таблицы */
			a_FKConstrantName	VARCHAR(256) default NULL	/* Название ограничения ForeignKey */
)

RETURNS  VARCHAR(5) AS
$BODY$
DECLARE	v_CurrSign		CHAR; 	 /* Признак таблицы в текущей связи */
	--******************************************************************************************************		
BEGIN		
	v_CurrSign:=admfn_Table_ConstrainedLinkSign(a_SchemaName::NAME,a_TableName::NAME,a_FKConstrantName::NAME);
	RETURN v_CurrSign;

END
$BODY$
LANGUAGE plpgsql;
COMMENT ON FUNCTION admfn_Table_ConstrainedLinkSign(a_SchemaName VARCHAR(256),a_TableName VARCHAR(256),a_FKConstrantName VARCHAR(256)) 
IS 'Возвращает признак количества записей, участвующих в связи, соответствующей ограничению Foreign Key,со стороны таблицы: "N" - много,"1"- одна.';
COMMIT TRANSACTION;
--ROLLBACK TRANSACTION;
SELECT admfn_Table_ConstrainedLinkSign('public'::VARCHAR,'Street'::VARCHAR,'fk_StreetSynonym_Street'::VARCHAR);--"1"
SELECT admfn_Table_ConstrainedLinkSign('public'::VARCHAR,'StreetSynonym'::VARCHAR,'fk_StreetSynonym_Street'::VARCHAR);--"N"

BEGIN TRANSACTION;
DROP FUNCTION IF EXISTS admfn_ForeignKey_ConstrainedTableName (a_SchemaName name,a_FKConstrantName name);
/*******************************************************************************************************/
/*  Функция возвращает название таблицы, в которой объявлен внешний ключ					*/
/*******************************************************************************************************/
CREATE OR REPLACE FUNCTION admfn_ForeignKey_ConstrainedTableName
				(a_SchemaName		name default 'public',	/* название схемы базы данных		*/
				a_FKConstrantName	name default NULL	/* Название внешнего ключа таблицы */
 )
RETURNS  name AS
$BODY$
DECLARE	
	v_ConstrainedTableName	name;	/* Наименование таблицы, на которую ссылается внешний ключ */
	--******************************************************************************************************		
BEGIN		
	 SELECT INTO v_ConstrainedTableName
				tbl.relname
		FROM pg_constraint con 
			INNER JOIN pg_namespace nspc ON con.connamespace = nspc.oid 
			INNER JOIN pg_class tbl ON con.conrelid=tbl.oid

							
		WHERE nspc.nspname=LOWER(a_SchemaName) AND con.contype =c_ForeignKeyKind
			AND con.conname =LOWER(a_FKConstrantName);
		
	RETURN v_ConstrainedTableName;
END
$BODY$
LANGUAGE plpgsql;
COMMENT ON FUNCTION admfn_ForeignKey_ConstrainedTableName(a_SchemaName name,a_FKConstrantName name) IS 'Возвращает название таблицы, в которой объявлен внешний ключ';
--ROLLBACK TRANSACTION;
COMMIT TRANSACTION;
BEGIN TRANSACTION;
DROP FUNCTION IF EXISTS admfn_ForeignKey_ConstrainedTableName (a_SchemaName VARCHAR(256),a_FKConstrantName VARCHAR(256));
/********************************************************************************************************/
/*  Функция возвращает название таблицы, в которой объявлен внешний ключ	*/
/********************************************************************************************************/
CREATE OR REPLACE FUNCTION admfn_ForeignKey_ConstrainedTableName
				(a_SchemaName		VARCHAR(256) default 'public',	/* название схемы базы данных		*/
				a_FKConstrantName	VARCHAR(256) default NULL	/* Название внешнего ключа таблицы */
 )										 

RETURNS  VARCHAR(256) AS
$BODY$
DECLARE	
	c_ForeignKeyKind	CONSTANT CHAR:='f';
	v_ConstrainedTableName	VARCHAR(256);	/* Наименование таблицы, на которую ссылается внешний ключ */
	--******************************************************************************************************		
BEGIN		
	 v_ConstrainedTableName:=admfn_ForeignKey_ConstrainedTableName(a_SchemaName::NAME,a_FKConstrantName::NAME);
	RETURN v_ConstrainedTableName;
END
$BODY$
LANGUAGE plpgsql;
COMMENT ON FUNCTION admfn_ForeignKey_ConstrainedTableName(a_SchemaName VARCHAR(256),a_FKConstrantName VARCHAR(256)) IS 'Возвращает название таблицы, в которой объявлен внешний ключ';
--ROLLBACK TRANSACTION;
COMMIT TRANSACTION;
SELECT * FROM admfn_ForeignKey_ConstrainedTableName('public'::VARCHAR(256),'fk_StreetSynonym_Street'::VARCHAR(256));
SELECT * FROM admfn_ForeignKey_ConstrainedTableName('public'::VARCHAR(256),'fk_StreetTypeSynonym_StreetType'::VARCHAR(256));
SELECT * FROM admfn_ForeignKey_ConstrainedTableName('public'::NAME,'fk_StreetSynonym_Street'::NAME);
SELECT * FROM admfn_ForeignKey_ConstrainedTableName('public'::NAME,'fk_StreetTypeSynonym_StreetType'::NAME);

BEGIN TRANSACTION;
DROP FUNCTION IF EXISTS admfn_Table_TablePK (a_SchemaName VARCHAR(256),a_TableName VARCHAR(256));
/********************************************************************************************************/
/*  Функция возвращает массив названий атрибутов, составляющих первичный ключ				*/
/********************************************************************************************************/
CREATE OR REPLACE FUNCTION admfn_Table_TablePK
			(a_SchemaName	VARCHAR(256) default 'public',	/* название схемы базы данных	 */
			a_TableName	VARCHAR(256) default NULL	/* Название таблицы */
)

RETURNS  VARCHAR(256)[] AS
$BODY$
DECLARE	c_TableKind	CONSTANT CHAR:='r';
	c_PrimaryKeyKind	CONSTANT CHAR:='p';
	c_PKAttributeList_NDims CONSTANT INTEGER:=1;	/* Размерность массива атрибутов первичного ключа*/
	v_TableOID		OID;			/*OID таблицы */
	v_PKAttributeList	SMALLINT[];	/* Список ИД атрибутов, составляющих первичный ключ */
	v_PKAttributeID		SMALLINT;	/* ИД атрибута, первичного ключа */
	v_PKAttributeNo		SMALLINT;	/* Порядковый номер атрибута, первичного ключа */
	v_PKAttributeName	VARCHAR(256);	/* Название атрибута, составляющих первичный ключ */

	v_TablePK	VARCHAR(256)[];			/* Названий атрибутов, составляющих первичный ключ */
	--******************************************************************************************************		
BEGIN		
	SELECT INTO v_TableOID tbl.oid FROM pg_class tbl 
				INNER JOIN pg_namespace nsp ON tbl.relnamespace=nsp.oid 
			WHERE LOWER(nsp.nspname)=LOWER(a_SchemaName) AND LOWER(tbl.relname)=LOWER(a_TableName)
				AND tbl.relkind=LOWER(c_TableKind); 
	SELECT INTO v_PKAttributeList conkey FROM pg_constraint c WHERE c.contype=c_PrimaryKeyKind and c.conrelid=v_TableOID;
	IF FOUND  AND v_PKAttributeList IS NOT NULL THEN
		v_PKAttributeNo:=array_lower(v_PKAttributeList,c_PKAttributeList_NDims);
		FOREACH v_PKAttributeID	 IN ARRAY v_PKAttributeList
		LOOP
			SELECT INTO v_PKAttributeName att.attname FROM pg_attribute att 
									WHERE att.attrelid=v_TableOID AND att.attnum=v_PKAttributeID;
			v_TablePK[v_PKAttributeNo]:=v_PKAttributeName;
			v_PKAttributeNo := v_PKAttributeNo + 1;
		END LOOP;
	END IF;

	RETURN v_TablePK;
END
$BODY$
LANGUAGE plpgsql;
COMMENT ON FUNCTION admfn_Table_TablePK(a_SchemaName VARCHAR(256),a_TableName VARCHAR(256)) IS 'Возвращает массив названий атрибутов, составляющих первичный ключ';
DROP FUNCTION IF EXISTS admfn_Table_TablePK (a_SchemaName name,a_TableName name);
/********************************************************************************************************/
/*  Функция возвращает массив названий атрибутов, составляющих первичный ключ				*/
/********************************************************************************************************/
CREATE OR REPLACE FUNCTION admfn_Table_TablePK
			(a_SchemaName	name default 'public',	/* название схемы базы данных		*/				
			a_TableName	name default NULL	/* Название таблицы */
			
	
 )										 

RETURNS  name[] AS
$BODY$
DECLARE	c_TableKind	CONSTANT CHAR:='r';
	c_PrimaryKeyKind	CONSTANT CHAR:='p';
	c_PKAttributeList_NDims CONSTANT INTEGER:=1;	/* Размерность массива атрибутов первичного ключа*/
	v_TableOID	OID;			/*OID таблицы */
	v_PKAttributeList	SMALLINT[];	/* Список ИД атрибутов, составляющих первичный ключ */
	v_PKAttributeID		SMALLINT;	/* ИД атрибута, первичного ключа */
	v_PKAttributeNo		SMALLINT;	/* Порядковый номер атрибута, первичного ключа */
	v_PKAttributeName	name;		/* Название атрибута, составляющих первичный ключ */

	v_TablePK	name[];			/* Названий атрибутов, составляющих первичный ключ */
	--******************************************************************************************************		
BEGIN		
	SELECT INTO v_TableOID tbl.oid FROM pg_class tbl 
				INNER JOIN pg_namespace nsp ON tbl.relnamespace=nsp.oid 
			WHERE LOWER(nsp.nspname)=LOWER(a_SchemaName) AND LOWER(tbl.relname)=LOWER(a_TableName)
				AND tbl.relkind=LOWER(c_TableKind); 
	SELECT INTO v_PKAttributeList conkey FROM pg_constraint c WHERE c.contype=c_PrimaryKeyKind and c.conrelid=v_TableOID;
	IF FOUND AND v_PKAttributeList IS NOT NULL THEN
		v_PKAttributeNo:=array_lower(v_PKAttributeList,c_PKAttributeList_NDims);
		FOREACH v_PKAttributeID	 IN ARRAY v_PKAttributeList
		LOOP
			SELECT INTO v_PKAttributeName att.attname FROM pg_attribute att WHERE att.attrelid=v_TableOID
										AND att.attnum=v_PKAttributeID;
			v_TablePK[v_PKAttributeNo]:=v_PKAttributeName;
			v_PKAttributeNo := v_PKAttributeNo + 1;
		END LOOP;
	END IF;

	RETURN v_TablePK;
END
$BODY$
LANGUAGE plpgsql;
COMMENT ON FUNCTION admfn_Table_TablePK(a_SchemaName name,a_TableName name) IS 'Возвращает массив названий атрибутов, составляющих первичный ключ';
--ROLLBACK TRANSACTION;
COMMIT TRANSACTION;
SELECT admfn_Table_TablePK('public'::name,'Street'::name);
SELECT admfn_Table_TablePK('public':: VARCHAR,'Street'::VARCHAR);

BEGIN TRANSACTION;
DROP FUNCTION IF EXISTS admfn_Table_TableFK (a_SchemaName VARCHAR(256),a_TableName VARCHAR(256),a_FKConstrantName VARCHAR(256));
/********************************************************************************************************/
/*  Функция возвращает массив названий атрибутов таблицы, составляющих внешний ключ			*/
/********************************************************************************************************/
CREATE OR REPLACE FUNCTION admfn_Table_TableFK
			(a_SchemaName		VARCHAR(256) default 'public',	/* название схемы базы данных*/
			a_TableName		VARCHAR(256) default NULL,	/* Название таблицы */
			a_FKConstrantName	VARCHAR(256) default NULL	/* Название ограничения ForeignKey */
)

RETURNS  VARCHAR(256)[] AS
$BODY$
DECLARE	c_TableKind	CONSTANT CHAR:='r';
	c_ForeignKeyKind	CONSTANT CHAR:='f';
	c_FKAttributeList_NDims CONSTANT INTEGER:=1;	/* Размерность массива атрибутов внешнего ключа*/
	v_TableOID		OID;			/*OID таблицы */
	v_FKAttributeList	SMALLINT[];	/* Список ИД атрибутов, составляющих внешний ключ */
	v_FKAttributeID		SMALLINT;	/* ИД атрибута, внешнего ключа */
	v_FKAttributeNo		SMALLINT;	/* Порядковый номер атрибута, внешнего ключа */
	v_FKAttributeName	VARCHAR(256);	/* Название атрибута, составляющих внешний ключ */

	v_TableFK	VARCHAR(256)[];			/* Названий атрибутов, составляющих внешний ключ */
	--******************************************************************************************************		
BEGIN
	SELECT INTO v_TableOID tbl.oid FROM pg_class tbl 
				INNER JOIN pg_namespace nsp ON tbl.relnamespace=nsp.oid 
			WHERE LOWER(nsp.nspname)=LOWER(a_SchemaName) AND LOWER(tbl.relname)=LOWER(a_TableName)
				AND tbl.relkind=LOWER(c_TableKind); 
	SELECT INTO v_FKAttributeList conkey FROM pg_constraint c WHERE c.contype=c_ForeignKeyKind and c.conrelid=v_TableOID
										AND c.conname=LOWER(TRIM(a_FKConstrantName));
	IF FOUND  AND v_FKAttributeList IS NOT NULL THEN
		v_FKAttributeNo:=array_lower(v_FKAttributeList,c_FKAttributeList_NDims);
		FOREACH v_FKAttributeID	 IN ARRAY v_FKAttributeList
		LOOP
			SELECT INTO v_FKAttributeName att.attname FROM pg_attribute att WHERE att.attrelid=v_TableOID
													AND att.attnum=v_FKAttributeID;
			v_TableFK[v_FKAttributeNo]:=v_FKAttributeName;
			v_FKAttributeNo := v_FKAttributeNo + 1;
		END LOOP;
	END IF;

	RETURN v_TableFK;
END
$BODY$
LANGUAGE plpgsql;
COMMENT ON FUNCTION admfn_Table_TableFK(a_SchemaName VARCHAR(256),a_TableName VARCHAR(256),a_FKConstrantName VARCHAR(256)) IS 'Возвращает массив названий атрибутов таблицы, составляющих внешний ключ';
DROP FUNCTION IF EXISTS admfn_Table_TableFK (a_SchemaName name,a_TableName name,a_FKConstrantName name);
/********************************************************************************************************/
/*  Функция возвращает массив названий атрибутов таблицы, составляющих внешний ключ			*/
/********************************************************************************************************/
CREATE OR REPLACE FUNCTION admfn_Table_TableFK
			(a_SchemaName		name default 'public',	/* название схемы базы данных*/
			a_TableName		name default NULL,	/* Название таблицы */
			a_FKConstrantName	name default NULL	/* Название ограничения ForeignKey */
) 

RETURNS  name[] AS
$BODY$
DECLARE	c_TableKind	CONSTANT CHAR:='r';
	c_ForeignKeyKind	CONSTANT CHAR:='f';
	c_FKAttributeList_NDims CONSTANT INTEGER:=1;	/* Размерность массива атрибутов внешнего ключа*/
	v_TableOID	OID;			/*OID таблицы */
	v_FKAttributeList	SMALLINT[];	/* Список ИД атрибутов, составляющих внешний ключ */
	v_FKAttributeID		SMALLINT;	/* ИД атрибута, внешнего ключа */
	v_FKAttributeNo		SMALLINT;	/* Порядковый номер атрибута, внешнего ключа */
	v_FKAttributeName	name;		/* Название атрибута, составляющих внешний ключ */
	v_TableFK	name[];			/* Названий атрибутов, составляющих внешний ключ */
	--******************************************************************************************************
BEGIN
	SELECT INTO v_TableOID tbl.oid FROM pg_class tbl 
				INNER JOIN pg_namespace nsp ON tbl.relnamespace=nsp.oid 
			WHERE LOWER(nsp.nspname)=LOWER(a_SchemaName) AND LOWER(tbl.relname)=LOWER(a_TableName)
				AND tbl.relkind=LOWER(c_TableKind); 
	SELECT INTO v_FKAttributeList conkey FROM pg_constraint c WHERE c.contype=c_ForeignKeyKind and c.conrelid=v_TableOID
										AND c.conname=LOWER(TRIM(a_FKConstrantName));
	IF FOUND AND v_FKAttributeList IS NOT NULL THEN
		v_FKAttributeNo:=array_lower(v_FKAttributeList,c_FKAttributeList_NDims);
		FOREACH v_FKAttributeID	 IN ARRAY v_FKAttributeList
		LOOP
			SELECT INTO v_FKAttributeName att.attname FROM pg_attribute att WHERE att.attrelid=v_TableOID
													AND att.attnum=v_FKAttributeID;
			v_TableFK[v_FKAttributeNo]:=v_FKAttributeName;
			v_FKAttributeNo := v_FKAttributeNo + 1;
		END LOOP;
	END IF;
	RETURN v_TableFK;
END
$BODY$
LANGUAGE plpgsql;
COMMENT ON FUNCTION admfn_Table_TableFK(a_SchemaName name,a_TableName name,a_FKConstrantName name) IS 'Возвращает массив названий атрибутов таблицы, составляющих внешний ключ';
--ROLLBACK TRANSACTION;
COMMIT TRANSACTION;
SELECT admfn_Table_TableFK('public'::name,'StreetSynonym'::name,'fk_streetsynonym_street'::name);--'{wcrccode,localityid,streetid}'

BEGIN TRANSACTION;
DROP FUNCTION IF EXISTS admfn_Table_haveUniqueIndexes (a_SchemaName NAME,a_TableName NAME,a_isPrimaryNeed BOOLEAN);
/********************************************************************************************************/
/*  Функция возвращает признак наличия уникальных индексов в описании таблицы					*/
/********************************************************************************************************/
CREATE OR REPLACE FUNCTION admfn_Table_haveUniqueIndexes
			(a_SchemaName   NAME default 'public',	/* название схемы базы данных		*/
			a_TableName     NAME default NULL, 		/* Название таблицы */
			a_isPrimaryNeed BOOLEAN default FALSE	/* Нужно ли учитывать уникальный индекс на основе первичного ключа*/
									/*PRIMARY KEY? */
) 

RETURNS  BOOLEAN AS
$BODY$
DECLARE
	c_SchemaName    CONSTANT NAME:='public';	/* название схемы базы данных		*/				
	c_isPrimaryNeed CONSTANT BOOLEAN:=FALSE;	/* Не нажно учитывать уникальный индекс на основе первичного ключа PRIMARY KEY */
	v_haveUniqueIndexes	BOOLEAN:=FALSE;	/* признак наличия уникальных индексов в описании таблицы */
	v_SchemaName		NAME; 			/* название схемы базы данных		*/			
	v_isPrimaryNeed	BOOLEAN;		/* Нужно ли учитывать уникальный индекс на основе первичного ключа PRIMARY KEY? */
	v_isINDEXExists	BOOLEAN;		/* Существуют ли  интедсксы в таблице*/
	--******************************************************************************************************		
BEGIN
	v_SchemaName:=COALESCE(a_SchemaName,c_SchemaName);
	v_isPrimaryNeed:=COALESCE(a_isPrimaryNeed,c_isPrimaryNeed);
	SELECT INTO v_haveUniqueIndexes inx.indisunique
		FROM pg_index inx 
		WHERE inx.indrelid=(TRIM(LOWER(a_SchemaName))||'.'||TRIM(LOWER(a_TableName)))::regclass AND inx.indisunique
			AND (inx.indisprimary=FALSE OR inx.indisprimary = v_isPrimaryNeed)  ;
	RETURN COALESCE(v_haveUniqueIndexes,FALSE);
END
$BODY$
LANGUAGE plpgsql;
COMMENT ON FUNCTION admfn_Table_haveUniqueIndexes(a_SchemaName NAME,a_TableName NAME,a_isPrimaryNeed BOOLEAN) 
                                    IS 'Функция возвращает признак наличия уникальных индексов в описании таблицы';
--ROLLBACK TRANSACTION;
COMMIT TRANSACTION;
BEGIN TRANSACTION;
DROP FUNCTION IF EXISTS admfn_Table_haveUniqueIndexes (a_SchemaName VARCHAR(256),a_TableName VARCHAR(256),a_isPrimaryNeed BOOLEAN);
/********************************************************************************************************/
/*  Функция возвращает признак наличия уникальных индексов в описании таблицы					*/
/********************************************************************************************************/
CREATE OR REPLACE FUNCTION admfn_Table_haveUniqueIndexes
			(a_SchemaName   VARCHAR(256) default 'public',	/* название схемы базы данных */
			a_TableName     VARCHAR(256) default NULL, 		/* Название таблицы */
			a_isPrimaryNeed BOOLEAN default FALSE		/* Нужно ли учитывать уникальный индекс на основе */
										/* первичного ключа PRIMARY KEY? */
) 

RETURNS  BOOLEAN AS
$BODY$
DECLARE
	v_haveUniqueIndexes	BOOLEAN:=FALSE;		/* признак наличия уникальных индексов в описании таблицы */
	--******************************************************************************************************		
BEGIN
	v_haveUniqueIndexes:=admfn_Table_haveUniqueIndexes(a_SchemaName::NAME,a_TableName::NAME,a_isPrimaryNeed);
	RETURN COALESCE(v_haveUniqueIndexes,FALSE);
END
$BODY$
LANGUAGE plpgsql;
COMMENT ON FUNCTION admfn_Table_haveUniqueIndexes(a_SchemaName VARCHAR(256),a_TableName VARCHAR(256),a_isPrimaryNeed BOOLEAN) 
				IS 'Функция возвращает признак наличия уникальных индексов в описании таблицы';
--ROLLBACK TRANSACTION;
COMMIT TRANSACTION;
SELECT admfn_Table_haveUniqueIndexes('public'::VARCHAR(256),'Street'::VARCHAR(256)) Street;

BEGIN TRANSACTION;
DROP FUNCTION IF EXISTS cnfn_Array_LowerCase(a_SourceArray VARCHAR(8000)[]);
/************************************************************************************************************************/
/* Возвращает массив строк из строчных букв										*/
/************************************************************************************************************************/
CREATE OR REPLACE FUNCTION cnfn_Array_LowerCase(
				a_SourceArray VARCHAR(8000)[] /* Исходный массив */
			)

RETURNS   VARCHAR(8000)[] AS
$BODY$
DECLARE
	v_LowerCaseArray VARCHAR(8000)[]; 	/* Массив, с неповторяющимися элементами */
	v_CurrentElement VARCHAR(8000); 		/* Текущий элемент массива */
	v_ElementAsArray  VARCHAR(8000)[1]; 	/* Текущий элемент, как массив */
	
--******************************************************************************************************       
--******************************************************************************************************
 BEGIN
     --**************************************************************************************** 
	v_LowerCaseArray:='{}';
    IF COALESCE(a_SourceArray,'{}')<>'{}' THEN
        FOREACH v_CurrentElement  IN ARRAY a_SourceArray LOOP
            v_ElementAsArray:='{}';
            v_CurrentElement:=LOWER(v_CurrentElement);
            v_ElementAsArray:=array_append(v_ElementAsArray,v_CurrentElement);
            IF NOT (v_ElementAsArray <@ v_LowerCaseArray) THEN
                v_LowerCaseArray:=array_append(v_LowerCaseArray,v_CurrentElement);
            END IF;
        END LOOP;
    END IF;
 	RETURN v_LowerCaseArray;
  END;
  $BODY$
 LANGUAGE plpgsql;
COMMENT ON FUNCTION cnfn_Array_LowerCase(a_SourceArray VARCHAR(8000)[])
					IS 'Возвращает массив строк из строчных букв ';


--ROLLBACK TRANSACTION;
COMMIT TRANSACTION;
SELECT cnfn_Array_LowerCase(NULL::VARCHAR(256)[]);
SELECT cnfn_Array_LowerCase('{}'::VARCHAR(256)[]);
SELECT cnfn_Array_LowerCase('{fias_ActualStatus,fias_ACTUAL,fias_addressobjects}'::VARCHAR(256)[]);
SELECT cnfn_Array_LowerCase('{ОдИн,Два,ТРИ, черыре}'::VARCHAR(256)[]);

BEGIN TRANSACTION;
DROP FUNCTION IF EXISTS cnfn_Array_QuotesWrapperWithout(a_SourceArray VARCHAR(8000)[]);
/************************************************************************************************************************/
/* Возвращает массив строк, в которых удалены начальная и конечная одиночные кавычки, если такие есть					*/
/************************************************************************************************************************/
CREATE OR REPLACE FUNCTION cnfn_Array_QuotesWrapperWithout(
				a_SourceArray VARCHAR(8000)[] /* Исходный массив */
			)

RETURNS   VARCHAR(8000)[] AS
$BODY$
DECLARE
	v_QuotesWrapperWithoutArray VARCHAR(8000)[]; 	/* Массив, с неповторяющимися элементами */
	v_CurrentElement VARCHAR(8000); 		/* Текущий элемент массива */
	v_ElementAsArray  VARCHAR(8000)[1]; 	/* Текущий элемент, как массив */
	
--******************************************************************************************************       
--******************************************************************************************************
 BEGIN
     --**************************************************************************************** 
	v_QuotesWrapperWithoutArray:='{}';
    IF COALESCE(a_SourceArray,'{}')<>'{}' THEN
        FOREACH v_CurrentElement  IN ARRAY a_SourceArray LOOP
            v_ElementAsArray:='{}';
            v_CurrentElement:=TRIM(v_CurrentElement);
            v_CurrentElement:=CASE WHEN LEFT(v_CurrentElement,1)='''' AND RIGHT(v_CurrentElement,1)='''' 
                                                                     THEN SUBSTRING(v_CurrentElement FROM 2 FOR LENGTH(v_CurrentElement)-2)
                                                                     ELSE v_CurrentElement END;
            v_ElementAsArray:=array_append(v_ElementAsArray,v_CurrentElement);
            v_QuotesWrapperWithoutArray:=array_append(v_QuotesWrapperWithoutArray,v_CurrentElement);
        END LOOP;
    END IF;
    RETURN v_QuotesWrapperWithoutArray;
  END;
  $BODY$
 LANGUAGE plpgsql;
COMMENT ON FUNCTION cnfn_Array_QuotesWrapperWithout(a_SourceArray VARCHAR(8000)[])
					IS 'Возвращает массив строк, в которых удалены начальная и конечная одиночные кавычки, если такие есть';


--ROLLBACK TRANSACTION;
COMMIT TRANSACTION;
SELECT cnfn_Array_QuotesWrapperWithout(NULL::VARCHAR(256)[]);
SELECT cnfn_Array_QuotesWrapperWithout('{}'::VARCHAR(256)[]);
SELECT cnfn_Array_QuotesWrapperWithout(ARRAY['''fias_ActualStatus''','''{''','}','fias_ACTUAL']::VARCHAR(256)[]);

Архив PostgreSQL_for_PlantUML.rar развёртывается в форме набора вложенных папок с файлами, список которых демонстрирует Таблица 24.

Создание контрольного примера лучше всего начать с создания новой базы данных PostgreSQL, например, с названием «Sandbox» (Песочница). После этого следует открыть папку PostgreSQL_for_PlantUML\ControlExample\Install, содержащую все файлы необходимые для создания контрольного примера.

Первым следует выполнить скрипт «TotalSchema.sql», содержащий описания всех таблиц контрольного примера и связей между ними на языке описания данных (DDL[*⁶]) СУБД Posgresql.

Затем должен быть выполнен скрипт «TotalSQLScript.sql», предназначенный для создания всех процедур и функций в базе данных.

При условии безошибочного исполнения этих двух скриптов, контрольный пример можно считать созданным. Остаётся проверить правильность его создания, для этого необходимо выполнить скрипт «TotalScript_test.sql», содержащий операторы проверки выполнимости всех созданных функций.

ВНИМАНИЕ. Процедуры в качестве одного из параметров принимают путь папки, в которой должны создаваться PlantUML-скрипты. Этот путь должен быть заменён на тот, где должны создаваться PlantUML-скрипты на Вашем компьютере. Тесты выполнимости процедур находятся в самом начале скрипта «TotalScript_test.sql».

Дополнительно в этой папке находятся два файла DROP «TotalSchema.sql» и «DROP ALL Functions.sql» со скриптами для удаления всех таблиц и функций соответственно.

Во вложенной папке ControlExample находятся файлы со скриптами создания процедур и функций, разбитых на группы так, как показывает Таблица 25.

Назначение файлов из других вложенных папок соответствует назначениям самих папок.

Контрольный пример кроме процедур и функций состоит из четырёх таблиц: Список улиц (Street), Список синонимов названий улиц (StreetSynonym), Справочник типов улиц (StreetType), Список синонимов наименований типов улиц (StreetTypeSynonym).
Так как рассматриваемые в статье функции обращаются к данным каталога базы данных, а не к данным самих таблиц, то подробное описание назначения таблиц схемы здесь не приводится.

Рис. 17 показывает связи между таблицами, образованные по описаниям их внешних ключей и уникальных индексов. Поэтому «TotalSchema.sql» содержит операторы создания индексов таблиц.

ALTER TABLE IF EXISTS Street   DROP CONSTRAINT IF EXISTS fk_Street_StreetType;
ALTER TABLE IF EXISTS StreetSynonym   DROP CONSTRAINT IF EXISTS fk_StreetSynonym_Street;
ALTER TABLE IF EXISTS StreetTypeSynonym DROP CONSTRAINT IF EXISTS fk_StreetTypeSynonym_StreetType;
DROP TABLE IF EXISTS StreetSynonym;
DROP TABLE IF EXISTS Street;
DROP TABLE IF EXISTS StreetTypeSynonym;
DROP TABLE IF EXISTS StreetType;
DROP DOMAIN IF EXISTS  WCRCCode;
DROP DOMAIN IF EXISTS  LocalityID;
DROP DOMAIN IF EXISTS  StreetID;
DROP DOMAIN IF EXISTS  StreetTypeAcrm;
DROP DOMAIN IF EXISTS public.SynonymID;
CREATE DOMAIN public.WCRCCode AS SMALLINT NOT NULL;
COMMENT ON DOMAIN public.WCRCCode IS 'Код ОКСМ (общероссийский классификатор стран мира).';
CREATE DOMAIN public.LocalityID AS SMALLINT NOT NULL;
COMMENT ON DOMAIN public.LocalityID IS 'ИД населенного пункта';
CREATE DOMAIN public.StreetID AS SMALLINT NOT NULL;
COMMENT ON DOMAIN public.StreetID IS 'ИД улицы населенного пункта';
CREATE DOMAIN public.StreetTypeAcrm AS CHAR(10) NOT NULL;
COMMENT ON DOMAIN public.StreetTypeAcrm  IS 'Краткие названия типов улиц населенных пунктов';
CREATE DOMAIN public.SynonymID AS SMALLINT NULL;
COMMENT ON DOMAIN public.SynonymID IS 'ИД синонима названия (териториии, населенного пункта, улицы и т.д.).';
CREATE TABLE IF NOT EXISTS StreetType(
	StreetTypeAcrm StreetTypeAcrm NOT NULL,
	StreetTypeName varchar(30) NULL,
 CONSTRAINT XPKStreetType PRIMARY KEY(StreetTypeAcrm))WITH (OIDS=false);
COMMENT ON TABLE StreetType IS 'Справочник типов улиц'; 
COMMENT ON COLUMN StreetType.StreetTypeAcrm IS 'Акроним (буквенный код) типа улицы';
COMMENT ON COLUMN StreetType.StreetTypeName IS 'Наименование типа улицы';
DELETE FROM StreetType;
insert into StreetType values ('УЛ  ', 'Улица'); 
insert into StreetType values ('ПР-КТ', 'Проспект'); 
insert into StreetType values ('ПЕР ', 'Переулок'); 
insert into StreetType values ('ПЛ  ', 'Площадь'); 
insert into StreetType values ('ПРОЕЗД', 'Проезд'); 
insert into StreetType values ('ПЕРЕЕЗД', 'Переезд'); 
insert into StreetType values ('ПЛОЩАДКА', 'Площадка');
insert into StreetType values ('ПРОСЕЛОК', 'Проселок');
insert into StreetType values ('ПРОСЕК', 'Просек');
insert into StreetType values ('ПРОСЕКА', 'Просека');
insert into StreetType values ('ПРОУЛ', 'Проулок');



insert into StreetType values ('УРЧЩ', 'Урочище'); 
insert into StreetType values ('ЗАС ', 'Застава'); 
insert into StreetType values ('ЗЗД ', 'Заезд');
insert into StreetType values ('КВ-Л', 'Квартал'); 
insert into StreetType values ('НАБ ', 'Набережная'); 
insert into StreetType values ('МГСТР', 'Магистраль');
insert into StreetType values ('МКР ', 'Микрорайон'); 
insert into StreetType values ('ТРАКТ', 'Тракт'); 
insert into StreetType values ('САД ', 'Сад'); 
insert into StreetType values ('СТ  ', 'Станция'); 
insert into StreetType values ('ПСТН', 'Полустанок'); 
insert into StreetType values ('РЗД ', 'Разъезд'); 
insert into StreetType values ('РЯД ', 'Ряд(ы)');

insert into StreetType values ('СЛ  ', 'Слобода'); 
insert into StreetType values ('ТЕР ', 'Территория'); 
insert into StreetType values ('Ш   ', 'Шоссе'); 
insert into StreetType values ('Б-Р', 'Бульвар'); 
insert into StreetType values ('НИЗВ', 'Неизвестно'); 
insert into StreetType values ('СКВР', 'Сквер'); 
insert into StreetType values ('С-К ', 'Спуск');
insert into StreetType values ('СЗД ', 'Съезд');

insert into StreetType values ('ТУП', 'Тупик'); 
insert into StreetType values ('НП  ', 'Населенный пункт'); 
insert into StreetType values ('ГОРОДОК', 'Городок'); 
insert into StreetType values ('КМ', 'Километр'); 



insert into StreetType values ('ААЛ', 'Аал'); 
insert into StreetType values ('АЛЛЕЯ', 'Аллея'); 
insert into StreetType values ('АРБАН', 'Арбан'); 
insert into StreetType values ('ВЫСЕЛ', 'Выселки(ок)'); 
insert into StreetType values ('ВЪЕЗД', 'Въезд'); 
insert into StreetType values ('ДОР', 'Дорога'); 
insert into StreetType values ('КОЛЬЦО', 'Кольцо'); 
insert into StreetType values ('КОСА', 'Коса'); 

insert into StreetType values ('ЛИНИЯ', 'Линия'); 
insert into StreetType values ('ОСТ-В', 'Остров'); 

CREATE TABLE IF NOT EXISTS StreetTypeSynonym(
	StreetTypeAcrm StreetTypeAcrm NOT NULL,
	SynonymID SynonymID NOT NULL,
	StreetTypeSynonymAcrm VARCHAR(15) NULL,
 CONSTRAINT XPKStreetTypeSynonym PRIMARY KEY(StreetTypeAcrm,SynonymID))WITH (OIDS=false);
COMMENT ON TABLE StreetTypeSynonym IS 'Справочник синонимов типов улиц'; 
COMMENT ON COLUMN StreetTypeSynonym.StreetTypeAcrm IS 'Акроним (буквенный код) типа улицы';
COMMENT ON COLUMN StreetTypeSynonym.SynonymID IS 'ИД (идентификатор) синонима типа улицы';
COMMENT ON COLUMN StreetTypeSynonym.StreetTypeSynonymAcrm  IS 'Акроним (буквенный код) синонима типа улицы';
INSERT INTO StreetTypeSynonym(StreetTypeAcrm,SynonymID,StreetTypeSynonymAcrm) VALUES('АЛЛЕЯ',1,'АЛЛЕЯ');
INSERT INTO StreetTypeSynonym(StreetTypeAcrm,SynonymID,StreetTypeSynonymAcrm) VALUES('Б-Р',1,'Б-Р.');
INSERT INTO StreetTypeSynonym(StreetTypeAcrm,SynonymID,StreetTypeSynonymAcrm) VALUES('Б-Р',2,'БУЛ.');
INSERT INTO StreetTypeSynonym(StreetTypeAcrm,SynonymID,StreetTypeSynonymAcrm) VALUES('Б-Р',3,'БУЛ');
INSERT INTO StreetTypeSynonym(StreetTypeAcrm,SynonymID,StreetTypeSynonymAcrm) VALUES('Б-Р',4,'БУЛЬВАР');
INSERT INTO StreetTypeSynonym(StreetTypeAcrm,SynonymID,StreetTypeSynonymAcrm) VALUES('ДОР',1,'ДОР.');
INSERT INTO StreetTypeSynonym(StreetTypeAcrm,SynonymID,StreetTypeSynonymAcrm) VALUES('ДОР',2,'АВТОДОР.');
INSERT INTO StreetTypeSynonym(StreetTypeAcrm,SynonymID,StreetTypeSynonymAcrm) VALUES('ДОР',3,'АВТОДОР');
INSERT INTO StreetTypeSynonym(StreetTypeAcrm,SynonymID,StreetTypeSynonymAcrm) VALUES('КВ-Л',1,'КВ-Л.');
INSERT INTO StreetTypeSynonym(StreetTypeAcrm,SynonymID,StreetTypeSynonymAcrm) VALUES('КВ-Л',2,'КВАРТАЛ');
INSERT INTO StreetTypeSynonym(StreetTypeAcrm,SynonymID,StreetTypeSynonymAcrm) VALUES('КВ-Л',3,'КВ.');
INSERT INTO StreetTypeSynonym(StreetTypeAcrm,SynonymID,StreetTypeSynonymAcrm) VALUES('КВ-Л',4,'КВ');
INSERT INTO StreetTypeSynonym(StreetTypeAcrm,SynonymID,StreetTypeSynonymAcrm) VALUES('МКР',1,'МИКР.');
INSERT INTO StreetTypeSynonym(StreetTypeAcrm,SynonymID,StreetTypeSynonymAcrm) VALUES('МКР',2,'МИКР');
INSERT INTO StreetTypeSynonym(StreetTypeAcrm,SynonymID,StreetTypeSynonymAcrm) VALUES('МКР',3,'МИКРОРАЙОН');
INSERT INTO StreetTypeSynonym(StreetTypeAcrm,SynonymID,StreetTypeSynonymAcrm) VALUES('МКР',4,'МКР.');
INSERT INTO StreetTypeSynonym(StreetTypeAcrm,SynonymID,StreetTypeSynonymAcrm) VALUES('МКР',5,'МКРН');
INSERT INTO StreetTypeSynonym(StreetTypeAcrm,SynonymID,StreetTypeSynonymAcrm) VALUES('МКР',6,'МКРН.');
INSERT INTO StreetTypeSynonym(StreetTypeAcrm,SynonymID,StreetTypeSynonymAcrm) VALUES('МКР',7,'М-Н');
INSERT INTO StreetTypeSynonym(StreetTypeAcrm,SynonymID,StreetTypeSynonymAcrm) VALUES('МКР',8,'М-ОН');

INSERT INTO StreetTypeSynonym(StreetTypeAcrm,SynonymID,StreetTypeSynonymAcrm) VALUES('НАБ',1,'НАБ.');
INSERT INTO StreetTypeSynonym(StreetTypeAcrm,SynonymID,StreetTypeSynonymAcrm) VALUES('НАБ',2,'НАБЕРЕЖНАЯ');
INSERT INTO StreetTypeSynonym(StreetTypeAcrm,SynonymID,StreetTypeSynonymAcrm) VALUES('ОСТ-В',1,'О-В');
INSERT INTO StreetTypeSynonym(StreetTypeAcrm,SynonymID,StreetTypeSynonymAcrm) VALUES('ОСТ-В',2,'ОСТРОВ');
INSERT INTO StreetTypeSynonym(StreetTypeAcrm,SynonymID,StreetTypeSynonymAcrm) VALUES('ОСТ-В',3,'О');
INSERT INTO StreetTypeSynonym(StreetTypeAcrm,SynonymID,StreetTypeSynonymAcrm) VALUES('ОСТ-В',4,'О.');
INSERT INTO StreetTypeSynonym(StreetTypeAcrm,SynonymID,StreetTypeSynonymAcrm) VALUES('ПЕР',1,'ПЕР.');
INSERT INTO StreetTypeSynonym(StreetTypeAcrm,SynonymID,StreetTypeSynonymAcrm) VALUES('ПЕР',2,'ПЕРЕУЛОК');
INSERT INTO StreetTypeSynonym(StreetTypeAcrm,SynonymID,StreetTypeSynonymAcrm) VALUES('ПЛ',1,'ПЛ.');
INSERT INTO StreetTypeSynonym(StreetTypeAcrm,SynonymID,StreetTypeSynonymAcrm) VALUES('ПЛ',2,'ПЛОЩАДЬ');
INSERT INTO StreetTypeSynonym(StreetTypeAcrm,SynonymID,StreetTypeSynonymAcrm) VALUES('ПР-КТ',1,'ПР-КТ.');
INSERT INTO StreetTypeSynonym(StreetTypeAcrm,SynonymID,StreetTypeSynonymAcrm) VALUES('ПР-КТ',2,'ПРОСП.');
INSERT INTO StreetTypeSynonym(StreetTypeAcrm,SynonymID,StreetTypeSynonymAcrm) VALUES('ПР-КТ',3,'ПРОСП');
INSERT INTO StreetTypeSynonym(StreetTypeAcrm,SynonymID,StreetTypeSynonymAcrm) VALUES('ПР-КТ',4,'ПР.');
INSERT INTO StreetTypeSynonym(StreetTypeAcrm,SynonymID,StreetTypeSynonymAcrm) VALUES('ПР-КТ',5,'ПР');
INSERT INTO StreetTypeSynonym(StreetTypeAcrm,SynonymID,StreetTypeSynonymAcrm) VALUES('РЗД',1,'РЗД.');
INSERT INTO StreetTypeSynonym(StreetTypeAcrm,SynonymID,StreetTypeSynonymAcrm) VALUES('СКВР',1,'СКВР.');
INSERT INTO StreetTypeSynonym(StreetTypeAcrm,SynonymID,StreetTypeSynonymAcrm) VALUES('СКВР',2,'СКВЕР');
INSERT INTO StreetTypeSynonym(StreetTypeAcrm,SynonymID,StreetTypeSynonymAcrm) VALUES('СКВР',3,'С-Р');

INSERT INTO StreetTypeSynonym(StreetTypeAcrm,SynonymID,StreetTypeSynonymAcrm) VALUES('ТУП',1,'ТУП.');
INSERT INTO StreetTypeSynonym(StreetTypeAcrm,SynonymID,StreetTypeSynonymAcrm) VALUES('ТУП',2,'ТУПИК');
INSERT INTO StreetTypeSynonym(StreetTypeAcrm,SynonymID,StreetTypeSynonymAcrm) VALUES('ТЕР',1,'ТЕР.');
INSERT INTO StreetTypeSynonym(StreetTypeAcrm,SynonymID,StreetTypeSynonymAcrm) VALUES('ТЕР',2,'ТЕРРИТОРИЯ');
INSERT INTO StreetTypeSynonym(StreetTypeAcrm,SynonymID,StreetTypeSynonymAcrm) VALUES('ТЕР',3,'ПРОМЗОНА');
INSERT INTO StreetTypeSynonym(StreetTypeAcrm,SynonymID,StreetTypeSynonymAcrm) VALUES('ТЕР',4,'П/Р');
INSERT INTO StreetTypeSynonym(StreetTypeAcrm,SynonymID,StreetTypeSynonymAcrm) VALUES('ТЕР',5,'ПРОМРАЙОН');
INSERT INTO StreetTypeSynonym(StreetTypeAcrm,SynonymID,StreetTypeSynonymAcrm) VALUES('ТЕР',6,'ЗОНА');
INSERT INTO StreetTypeSynonym(StreetTypeAcrm,SynonymID,StreetTypeSynonymAcrm) VALUES('ТЕР',7,'П\Р');
INSERT INTO StreetTypeSynonym(StreetTypeAcrm,SynonymID,StreetTypeSynonymAcrm) VALUES('УЛ',1,'УЛ.');
INSERT INTO StreetTypeSynonym(StreetTypeAcrm,SynonymID,StreetTypeSynonymAcrm) VALUES('УЛ',2,'УЛИЦА');
INSERT INTO StreetTypeSynonym(StreetTypeAcrm,SynonymID,StreetTypeSynonymAcrm) VALUES('Ш',1,'Ш.');
INSERT INTO StreetTypeSynonym(StreetTypeAcrm,SynonymID,StreetTypeSynonymAcrm) VALUES('Ш',2,'ШОССЕ');
INSERT INTO StreetTypeSynonym(StreetTypeAcrm,SynonymID,StreetTypeSynonymAcrm) VALUES('ПРОУЛ',1,'ПРОУЛ.');
INSERT INTO StreetTypeSynonym(StreetTypeAcrm,SynonymID,StreetTypeSynonymAcrm) VALUES('ПРОУЛ',2,'ПРОУЛОК');

CREATE TABLE IF NOT EXISTS Street(
	WCRCCode WCRCCode NOT NULL,
	LocalityID LocalityID NOT NULL,
	StreetID StreetID NOT NULL,
	StreetTypeAcrm StreetTypeAcrm NULL,
	StreetName varchar(150) NOT NULL,
	StreetTSVector TSVector NULL,
	StreetTSLiteVector TSVector NULL,
 CONSTRAINT XPKStreet PRIMARY KEY(WCRCCode,LocalityID,StreetID)) WITH (OIDS=false);
 COMMENT ON TABLE Street IS 'Список улиц в населенных пунктах'; 
COMMENT ON COLUMN Street.WCRCCode IS 'Код страны';
COMMENT ON COLUMN Street.LocalityID IS 'ИД населенного пункта';
COMMENT ON COLUMN Street.StreetID IS 'ИД улицы населенного пункта';
COMMENT ON COLUMN Street.StreetTypeAcrm IS 'Акроним типа улицы';
COMMENT ON COLUMN Street.StreetName IS 'Наименование улицы населенного пункта';
COMMENT ON COLUMN Street.StreetTSVector IS 'Расширенные характеристики улицы в населенном пункте, преобразованные в вектор полнотекстового поиска';
COMMENT ON COLUMN Street.StreetTSLiteVector IS 'Характеристики улицы в населенном пункте, преобразованные в вектор полнотекстового поиска';

CREATE  INDEX XIE1Street ON Street (WCRCCode,LocalityID,StreetTypeAcrm,StreetName);
COMMENT ON INDEX XIE1Street IS 'Индекс по типу и названию улицы населенного пункта';
CREATE  INDEX XIE2Street ON Street (WCRCCode,LocalityID,StreetName);
COMMENT ON INDEX XIE2Street IS 'Индекс по названию улицы населенного пункта';
CREATE  INDEX XIE3Street ON Street (StreetName);
COMMENT ON INDEX XIE3Street IS 'Индекс по названиям улиц во всех населенных пунктов';
CREATE INDEX XTS1Street ON Street USING gin(StreetTSVector);	
COMMENT ON INDEX XTS1Street IS 'Полнотекстовый индекс по названиях улицы, населенного пункта, териитории и их синонимам';
CREATE INDEX XTS2Street ON Street USING gin(StreetTSLiteVector);	
COMMENT ON INDEX XTS1Street IS 'Полнотекстовый индекс только по названию улицы в населенном пункте и его синонимам';
INSERT INTO Street(WCRCCode,LocalityID,StreetID,StreetTypeAcrm,StreetName) 
VALUES(   643,     11,    401, 'УЛ', 'им. газеты "Пионерская правда"');
INSERT INTO Street(WCRCCode,LocalityID,StreetID,StreetTypeAcrm,StreetName) VALUES(   643,11,1518,'ПР-КТ','им.газеты "Красноярский рабочий"');
UPDATE Street SET StreetTypeAcrm='Б-Р '
		WHERE StreetTypeAcrm='БУЛВ';
UPDATE Street SET StreetTypeAcrm='ПРОЕЗД'
		WHERE StreetTypeAcrm='ПР-Д';
UPDATE Street SET StreetTypeAcrm='ПР-КТ'
		WHERE StreetTypeAcrm='ПР-Т';
UPDATE Street SET StreetTypeAcrm='ТРАКТ'
		WHERE StreetTypeAcrm='ТРКТ';
UPDATE Street SET StreetTypeAcrm='ТУП'
		WHERE StreetTypeAcrm='ТУПК';

CREATE TABLE IF NOT EXISTS StreetSynonym(
	WCRCCode WCRCCode NOT NULL,
	LocalityID LocalityID NOT NULL,
	StreetID StreetID NOT NULL,
	SynonymID SynonymID NOT NULL,
	StreetTypeAcrm StreetTypeAcrm NULL,
	StreetSynonymName varchar(200) NULL,
 CONSTRAINT XPKStreetSynonym PRIMARY KEY(WCRCCode,LocalityID,StreetID,SynonymID))WITH (OIDS=false);
COMMENT ON TABLE StreetSynonym IS 'Список синонимов названий улиц в населенных пунктах';  
COMMENT ON COLUMN StreetSynonym.WCRCCode IS 'Код страны';
COMMENT ON COLUMN StreetSynonym.LocalityID IS 'ИД населенного пункта';
COMMENT ON COLUMN StreetSynonym.StreetID IS 'ИД улицы населенного пункта';
COMMENT ON COLUMN StreetSynonym.SynonymID IS 'ИД синонима улицы населенного пункта';
COMMENT ON COLUMN StreetSynonym.StreetTypeAcrm IS 'Акроним типа синонима улицы';
COMMENT ON COLUMN StreetSynonym.StreetSynonymName IS 'Наименование синонима улицы населенного пункта';
CREATE  INDEX XIE1StreetSynonym ON StreetSynonym (WCRCCode,LocalityID,StreetID,StreetTypeAcrm,StreetSynonymName);
COMMENT ON INDEX XIE1StreetSynonym IS 'Индекс по типу и названию синонима улицы населенного пункта';
CREATE  INDEX XIE2StreetSynonym ON StreetSynonym (WCRCCode,LocalityID,StreetID,StreetSynonymName);
COMMENT ON INDEX XIE2StreetSynonym IS 'Индекс по названию синонима улицы населенного пункта';

CREATE  INDEX XIE3StreetSynonym ON StreetSynonym (StreetSynonymName);
COMMENT ON INDEX XIE3StreetSynonym IS 'Индекс по названию синонимов всех улиц во всех населенных пунктах';
INSERT INTO StreetSynonym(WCRCCode,LocalityID,StreetID,SynonymID,StreetTypeAcrm,StreetSynonymName) VALUES(   643,     11,    401,      3, 'УЛ', 'им газеты Пионерская Правда');
INSERT INTO StreetSynonym(WCRCCode,LocalityID,StreetID,SynonymID,StreetTypeAcrm,StreetSynonymName) VALUES(   643,     11,    401,      4, 'УЛ', 'им. газеты Пионерская Правда');
INSERT INTO StreetSynonym(WCRCCode,LocalityID,StreetID,SynonymID,StreetTypeAcrm,StreetSynonymName) VALUES(   643,     11,    401,      5, 'УЛ', 'им газеты "Пионерская Правда"');
INSERT INTO StreetSynonym(WCRCCode,LocalityID,StreetID,SynonymID,StreetTypeAcrm,StreetSynonymName) VALUES(   643,     11,    401,      6, 'УЛ', 'Пионерской Правды');
INSERT INTO StreetSynonym(WCRCCode,LocalityID,StreetID,SynonymID,StreetTypeAcrm,StreetSynonymName) VALUES(   643,     11,    401,      7, 'УЛ', 'газеты "Пионерская правда"');
INSERT INTO StreetSynonym(WCRCCode,LocalityID,StreetID,SynonymID,StreetTypeAcrm,StreetSynonymName) VALUES(   643,     11,    401,      8, 'УЛ', 'газеты Пионерская Правда');
INSERT INTO StreetSynonym(WCRCCode,LocalityID,StreetID,SynonymID,StreetTypeAcrm,StreetSynonymName) VALUES(   643,     11,    401,      9, 'УЛ', 'газеты Пионерской Правды');
INSERT INTO StreetSynonym(WCRCCode,LocalityID,StreetID,SynonymID,StreetTypeAcrm,StreetSynonymName) VALUES(   643,     11,    401,     10, 'УЛ', 'газеты "Пионерской Правды"');
INSERT INTO StreetSynonym(WCRCCode,LocalityID,StreetID,SynonymID,StreetTypeAcrm,StreetSynonymName) VALUES(   643,     11,    401,     11, 'УЛ', '"Пионерской Правды"');
INSERT INTO StreetSynonym(WCRCCode,LocalityID,StreetID,SynonymID,StreetTypeAcrm,StreetSynonymName) VALUES(   643,     11,    401,     12, 'УЛ', 'им.газеты "Пионерская правда"');
INSERT INTO StreetSynonym(WCRCCode,LocalityID,StreetID,SynonymID,StreetTypeAcrm,StreetSynonymName) VALUES(   643,     11,    401,     13, 'УЛ', 'им.газеты Пионерская Правда');
INSERT INTO StreetSynonym(WCRCCode,LocalityID,StreetID,SynonymID,StreetTypeAcrm,StreetSynonymName) VALUES(   643,     11,    401,     14, 'УЛ', 'им.газеты Пионерской Правды');
INSERT INTO StreetSynonym(WCRCCode,LocalityID,StreetID,SynonymID,StreetTypeAcrm,StreetSynonymName) VALUES(   643,     11,    401,     15, 'УЛ', 'им.газеты "Пионерской Правды"');
INSERT INTO StreetSynonym(WCRCCode,LocalityID,StreetID,SynonymID,StreetTypeAcrm,StreetSynonymName) VALUES(   643,     11,    401,     16, 'УЛ', 'им. газеты Пионерской Правды');
INSERT INTO StreetSynonym(WCRCCode,LocalityID,StreetID,SynonymID,StreetTypeAcrm,StreetSynonymName) VALUES(   643,     11,    401,     17, 'УЛ', 'им. газеты "Пионерской Правды"');
INSERT INTO StreetSynonym(WCRCCode,LocalityID,StreetID,SynonymID,StreetTypeAcrm,StreetSynonymName) VALUES(   643,     11,    401,     18, 'УЛ', 'им газеты Пионерской Правды');
INSERT INTO StreetSynonym(WCRCCode,LocalityID,StreetID,SynonymID,StreetTypeAcrm,StreetSynonymName) VALUES(   643,     11,    401,     19, 'УЛ', 'им газеты "Пионерской Правды"');
INSERT INTO StreetSynonym(WCRCCode,LocalityID,StreetID,SynonymID,StreetTypeAcrm,StreetSynonymName) VALUES(   643,     11,    401,     20, 'УЛ', 'имени газеты "Пионерская правда"');
INSERT INTO StreetSynonym(WCRCCode,LocalityID,StreetID,SynonymID,StreetTypeAcrm,StreetSynonymName) VALUES(   643,     11,    401,     21, 'УЛ', 'имени газеты Пионерская Правда');
INSERT INTO StreetSynonym(WCRCCode,LocalityID,StreetID,SynonymID,StreetTypeAcrm,StreetSynonymName) VALUES(   643,     11,    401,     22, 'УЛ', 'имени газеты Пионерской Правды');
INSERT INTO StreetSynonym(WCRCCode,LocalityID,StreetID,SynonymID,StreetTypeAcrm,StreetSynonymName) VALUES(   643,     11,    401,     23, 'УЛ', 'имени газеты "Пионерской Правды"');
INSERT INTO StreetSynonym(WCRCCode,LocalityID,StreetID,SynonymID,StreetTypeAcrm,StreetSynonymName) VALUES(   643,     11,   1518,      2, 'ПР-КТ', 'имени газеты Красноярский Рабочий');
INSERT INTO StreetSynonym(WCRCCode,LocalityID,StreetID,SynonymID,StreetTypeAcrm,StreetSynonymName) VALUES(   643,     11,   1518,      3, 'ПР-КТ', 'газеты Красноярский Рабочий');
INSERT INTO StreetSynonym(WCRCCode,LocalityID,StreetID,SynonymID,StreetTypeAcrm,StreetSynonymName) VALUES(   643,     11,   1518,      4, 'ПР-КТ', 'им. газеты "Красноярский рабочий"');
INSERT INTO StreetSynonym(WCRCCode,LocalityID,StreetID,SynonymID,StreetTypeAcrm,StreetSynonymName) VALUES(   643,     11,   1518,      5, 'ПР-КТ', 'имени газеты "Красноярский Рабочий"');
INSERT INTO StreetSynonym(WCRCCode,LocalityID,StreetID,SynonymID,StreetTypeAcrm,StreetSynonymName) VALUES(   643,     11,   1518,      6, 'ПР-КТ', 'им. газ. "Красноярский рабочий"');
INSERT INTO StreetSynonym(WCRCCode,LocalityID,StreetID,SynonymID,StreetTypeAcrm,StreetSynonymName) VALUES(   643,     11,   1518,      7, 'ПР-КТ', 'им.газ."Красноярский рабочий"');
INSERT INTO StreetSynonym(WCRCCode,LocalityID,StreetID,SynonymID,StreetTypeAcrm,StreetSynonymName) VALUES(   643,     11,   1518,      8, 'ПР-КТ', 'им.газ.Красноярский рабочий');
INSERT INTO StreetSynonym(WCRCCode,LocalityID,StreetID,SynonymID,StreetTypeAcrm,StreetSynonymName) VALUES(   643,     11,   1518,      9, 'ПР-КТ', 'им. газ. Красноярский рабочий');
INSERT INTO StreetSynonym(WCRCCode,LocalityID,StreetID,SynonymID,StreetTypeAcrm,StreetSynonymName) VALUES(   643,     11,   1518,     10, 'УЛ', 'Красноярский Рабочий');
INSERT INTO StreetSynonym(WCRCCode,LocalityID,StreetID,SynonymID,StreetTypeAcrm,StreetSynonymName) VALUES(   643,     11,   1518,     11, 'ПР-КТ', 'Красноярский Рабочий');
INSERT INTO StreetSynonym(WCRCCode,LocalityID,StreetID,SynonymID,StreetTypeAcrm,StreetSynonymName) VALUES(   643,     11,   1518,     12, 'ПР-КТ', 'им. газеты Красноярский Рабочий');
INSERT INTO StreetSynonym(WCRCCode,LocalityID,StreetID,SynonymID,StreetTypeAcrm,StreetSynonymName) VALUES(   643,     11,   1518,     13, 'ПР-КТ', 'им.газеты Красноярский рабочий');
INSERT INTO StreetSynonym(WCRCCode,LocalityID,StreetID,SynonymID,StreetTypeAcrm,StreetSynonymName) VALUES(   643,     11,   1518,     14, 'ПР-КТ', 'Красраб');
INSERT INTO StreetSynonym(WCRCCode,LocalityID,StreetID,SynonymID,StreetTypeAcrm,StreetSynonymName) VALUES(   643,     11,   1518,     15, 'УЛ', 'Красраб');
INSERT INTO StreetSynonym(WCRCCode,LocalityID,StreetID,SynonymID,StreetTypeAcrm,StreetSynonymName) VALUES(   643,     11,   1518,     16, 'ПР-КТ', 'Крас.Раб');
INSERT INTO StreetSynonym(WCRCCode,LocalityID,StreetID,SynonymID,StreetTypeAcrm,StreetSynonymName) VALUES(   643,     11,   1518,     17, 'УЛ', 'Крас.Раб');
INSERT INTO StreetSynonym(WCRCCode,LocalityID,StreetID,SynonymID,StreetTypeAcrm,StreetSynonymName) VALUES(   643,     11,   1518,     18, 'ПР-КТ', 'Крас.Раб.');
INSERT INTO StreetSynonym(WCRCCode,LocalityID,StreetID,SynonymID,StreetTypeAcrm,StreetSynonymName) VALUES(   643,     11,   1518,     19, 'УЛ', 'Крас.Раб.');
INSERT INTO StreetSynonym(WCRCCode,LocalityID,StreetID,SynonymID,StreetTypeAcrm,StreetSynonymName) VALUES(   643,     11,   1518,     20, 'ПР-КТ', 'Крас. Раб');
INSERT INTO StreetSynonym(WCRCCode,LocalityID,StreetID,SynonymID,StreetTypeAcrm,StreetSynonymName) VALUES(   643,     11,   1518,     21, 'УЛ', 'Крас. Раб');
INSERT INTO StreetSynonym(WCRCCode,LocalityID,StreetID,SynonymID,StreetTypeAcrm,StreetSynonymName) VALUES(   643,     11,   1518,     22, 'ПР-КТ', 'Крас. Раб.');
INSERT INTO StreetSynonym(WCRCCode,LocalityID,StreetID,SynonymID,StreetTypeAcrm,StreetSynonymName) VALUES(   643,     11,   1518,     23, 'УЛ', 'Крас. Раб.');
INSERT INTO StreetSynonym(WCRCCode,LocalityID,StreetID,SynonymID,StreetTypeAcrm,StreetSynonymName) VALUES(   643,     11,   1518,     24, 'ПР-КТ', 'им. газеты «Красноярский рабочий»');
INSERT INTO StreetSynonym(WCRCCode,LocalityID,StreetID,SynonymID,StreetTypeAcrm,StreetSynonymName) VALUES(   643,     11,   1518,     25, 'ПР-КТ', 'им. газ.«Красноярский рабочий»');
INSERT INTO StreetSynonym(WCRCCode,LocalityID,StreetID,SynonymID,StreetTypeAcrm,StreetSynonymName) VALUES(   643,     11,   1518,     26, 'ПР-КТ', 'им. газ. «Красноярский рабочий»');
INSERT INTO StreetSynonym(WCRCCode,LocalityID,StreetID,SynonymID,StreetTypeAcrm,StreetSynonymName) VALUES(   643,     11,   1518,     27, 'ПР-КТ', 'Крас Раб');
INSERT INTO StreetSynonym(WCRCCode,LocalityID,StreetID,SynonymID,StreetTypeAcrm,StreetSynonymName) VALUES(   643,     11,   1518,     28, 'УЛ', 'Крас Раб');
INSERT INTO StreetSynonym(WCRCCode,LocalityID,StreetID,SynonymID,StreetTypeAcrm,StreetSynonymName) VALUES(   643,     11,   1518,     29, 'ПР-КТ', 'КРАСН.РАБОЧИЙ');
INSERT INTO StreetSynonym(WCRCCode,LocalityID,StreetID,SynonymID,StreetTypeAcrm,StreetSynonymName) VALUES(   643,     11,   1518,     30, 'ПР-КТ', 'КРАСН. РАБОЧИЙ');
INSERT INTO StreetSynonym(WCRCCode,LocalityID,StreetID,SynonymID,StreetTypeAcrm,StreetSynonymName) VALUES(   643,     11,   1518,     31, 'УЛ', 'КРАСН.РАБОЧИЙ');
INSERT INTO StreetSynonym(WCRCCode,LocalityID,StreetID,SynonymID,StreetTypeAcrm,StreetSynonymName) VALUES(   643,     11,   1518,     32, 'УЛ', 'КРАСН. РАБОЧИЙ');
INSERT INTO StreetSynonym(WCRCCode,LocalityID,StreetID,SynonymID,StreetTypeAcrm,StreetSynonymName) VALUES(   643,     11,   1518,     33, 'ПР-КТ', 'КРАСН РАБОЧИЙ');
INSERT INTO StreetSynonym(WCRCCode,LocalityID,StreetID,SynonymID,StreetTypeAcrm,StreetSynonymName) VALUES(   643,     11,   1518,     34, 'УЛ', 'КРАСН РАБОЧИЙ');
INSERT INTO StreetSynonym(WCRCCode,LocalityID,StreetID,SynonymID,StreetTypeAcrm,StreetSynonymName) VALUES(   643,     11,   1518,     35, 'ПР-КТ', 'КРАСН.РАБ.');
INSERT INTO StreetSynonym(WCRCCode,LocalityID,StreetID,SynonymID,StreetTypeAcrm,StreetSynonymName) VALUES(   643,     11,   1518,     36, 'ПР-КТ', 'КРАСН. РАБ.');
INSERT INTO StreetSynonym(WCRCCode,LocalityID,StreetID,SynonymID,StreetTypeAcrm,StreetSynonymName) VALUES(   643,     11,   1518,     37, 'УЛ', 'КРАСН.РАБ.');
INSERT INTO StreetSynonym(WCRCCode,LocalityID,StreetID,SynonymID,StreetTypeAcrm,StreetSynonymName) VALUES(   643,     11,   1518,     38, 'УЛ', 'КРАСН. РАБ.');
INSERT INTO StreetSynonym(WCRCCode,LocalityID,StreetID,SynonymID,StreetTypeAcrm,StreetSynonymName) VALUES(   643,     11,   1518,     39, 'ПР-КТ', 'КРАСН РАБ');
INSERT INTO StreetSynonym(WCRCCode,LocalityID,StreetID,SynonymID,StreetTypeAcrm,StreetSynonymName) VALUES(   643,     11,   1518,     40, 'УЛ', 'КРАСН РАБ');
INSERT INTO StreetSynonym(WCRCCode,LocalityID,StreetID,SynonymID,StreetTypeAcrm,StreetSynonymName) VALUES(   643,     11,   1518,     41, 'ПР-КТ', 'КРАСН РАБ.');
INSERT INTO StreetSynonym(WCRCCode,LocalityID,StreetID,SynonymID,StreetTypeAcrm,StreetSynonymName) VALUES(   643,     11,   1518,     42, 'УЛ', 'КРАСН РАБ.');
INSERT INTO StreetSynonym(WCRCCode,LocalityID,StreetID,SynonymID,StreetTypeAcrm,StreetSynonymName) VALUES(   643,     11,   1518,     43, 'ПР-КТ', 'им газеты Красноярский Рабочий');
INSERT INTO StreetSynonym(WCRCCode,LocalityID,StreetID,SynonymID,StreetTypeAcrm,StreetSynonymName) VALUES(   643,     11,   1518,     44, 'ПР-КТ', 'Кр.Раб.');
INSERT INTO StreetSynonym(WCRCCode,LocalityID,StreetID,SynonymID,StreetTypeAcrm,StreetSynonymName) VALUES(   643,     11,   1518,     45, 'ПР-КТ', 'Кр.Раб');
INSERT INTO StreetSynonym(WCRCCode,LocalityID,StreetID,SynonymID,StreetTypeAcrm,StreetSynonymName) VALUES(   643,     11,   1518,     46, 'ПР-КТ', 'Кр. Раб.');
INSERT INTO StreetSynonym(WCRCCode,LocalityID,StreetID,SynonymID,StreetTypeAcrm,StreetSynonymName) VALUES(   643,     11,   1518,     47, 'ПР-КТ', 'КрРаб');
INSERT INTO StreetSynonym(WCRCCode,LocalityID,StreetID,SynonymID,StreetTypeAcrm,StreetSynonymName) VALUES(   643,     11,   1518,     48, 'ПР-КТ', 'Краб');
INSERT INTO StreetSynonym(WCRCCode,LocalityID,StreetID,SynonymID,StreetTypeAcrm,StreetSynonymName) VALUES(   643,     11,   1518,     49, 'УЛ', 'Кр.Раб.');
INSERT INTO StreetSynonym(WCRCCode,LocalityID,StreetID,SynonymID,StreetTypeAcrm,StreetSynonymName) VALUES(   643,     11,   1518,     50, 'УЛ', 'Кр.Раб');
INSERT INTO StreetSynonym(WCRCCode,LocalityID,StreetID,SynonymID,StreetTypeAcrm,StreetSynonymName) VALUES(   643,     11,   1518,     51, 'УЛ', 'Кр. Раб.');
INSERT INTO StreetSynonym(WCRCCode,LocalityID,StreetID,SynonymID,StreetTypeAcrm,StreetSynonymName) VALUES(   643,     11,   1518,     52, 'УЛ', 'КрРаб');
INSERT INTO StreetSynonym(WCRCCode,LocalityID,StreetID,SynonymID,StreetTypeAcrm,StreetSynonymName) VALUES(   643,     11,   1518,     53, 'УЛ', 'Краб');

UPDATE StreetSynonym SET StreetTypeAcrm='Б-Р '
		WHERE StreetTypeAcrm='БУЛВ';
UPDATE StreetSynonym SET StreetTypeAcrm='ПРОЕЗД'
		WHERE StreetTypeAcrm='ПР-Д';
UPDATE StreetSynonym SET StreetTypeAcrm='ПР-КТ'
		WHERE StreetTypeAcrm='ПР-Т';
UPDATE StreetSynonym SET StreetTypeAcrm='ТРАКТ'
		WHERE StreetTypeAcrm='ТРКТ';
UPDATE StreetSynonym SET StreetTypeAcrm='ТУП'
		WHERE StreetTypeAcrm='ТУПК';

UPDATE Street s SET StreetTSVector=setweight(to_tsvector(StreetTypeAcrm),'A')||setweight(to_tsvector(StreetName),'A')||setweight(to_tsvector((SELECT StreetTypeName FROM StreetType st WHERE UPPER(TRIM(st.StreetTypeAcrm))=UPPER(TRIM(s.StreetTypeAcrm)))),'A')||
											                            setweight(cnfn_Street_AllSynonymTsVector(WCRCCode,LocalityID,StreetID),'D'),
                StreetTSLiteVector=setweight(to_tsvector(StreetTypeAcrm),'A')||setweight(to_tsvector(StreetName),'A')||setweight(to_tsvector((SELECT StreetTypeName FROM StreetType st WHERE UPPER(TRIM(st.StreetTypeAcrm))=UPPER(TRIM(s.StreetTypeAcrm)))),'A');


ALTER TABLE Street   ADD  CONSTRAINT fk_Street_StreetType FOREIGN KEY(StreetTypeAcrm) REFERENCES StreetType (StreetTypeAcrm) MATCH FULL;
ALTER TABLE Street   ADD  CONSTRAINT ck_Street_StreetTypeAcrm CHECK(StreetTypeAcrm !~* E'[a-z]');
ALTER TABLE StreetSynonym   ADD  CONSTRAINT fk_StreetSynonym_Street FOREIGN KEY(WCRCCode, LocalityID, StreetID) REFERENCES Street (WCRCCode, LocalityID, StreetID) MATCH FULL;
ALTER TABLE StreetSynonym   ADD  CONSTRAINT fk_StreetSynonym_StreetType FOREIGN KEY(StreetTypeAcrm) REFERENCES StreetType (StreetTypeAcrm) MATCH FULL;
ALTER TABLE StreetTypeSynonym ADD  CONSTRAINT fk_StreetTypeSynonym_StreetType FOREIGN KEY(StreetTypeAcrm) REFERENCES StreetType(StreetTypeAcrm) MATCH FULL;