Простые SQL-запросы из таблиц Oracle

SQL - запросы

Выборка информации из одной таблицы:

describe tab;

select * from tab;

select  col1, col2, col3  from tab;

select  ROWID, col1 from tab;
                                  
select * from tab  where tab_col_id = 15;

select  12 * 15  from dual;

select  to_date('28-APR-1971') + 12  from dual;

select  to_date('28-APR-1971') - 15  from dual;

select  to_date('28-APR-1971') - to_date('28-JAN-1971')  from dual;

select  col1, col2, col3 + 45  from tab;

select  12 * (25/5 - 1)  from dual;

select  col1, col1 * 2  DOUBLE_COL1  from tab;

select  col1, col1 * 2  "Double Col1"  from tab;

select  12 * (25/5 - 1)  AS  "Result"  from dual;

select  col1 || ' ' || col2  AS "Concatenation"  from tab;

select col1, col2  from tab  where  tab_col2 is null;

select col1, col2  from tab  where  tab_col2 is not null;

select col1, nvl(col2, 'Uncnown col2') AS COL_2 from tab;

select  DISTINCT col1  from tab;


Сравнение значений:


select col1, col2, col3  from tab where col1 <> 12;

select col1, col2, col3  from tab where col2 > 10;

select col1, col2, col3  from tab where col3 <= 100;

select col1, col2, col3  from tab where ROWNUM <= 15;

select col1, col2, col3  from tab where col1 > ANY( 12, 18, 25 );
(истина, когда col1 больше одного любого из перечисленных чисел, фактически если >12)

select col1, col2, col3  from tab where col1 > SOME( 12, 18, 25 );
(истина, когда col1 больше одного любого из перечисленных чисел, фактически если >12)

select col1, col2, col3  from tab where col1 > ALL( 12, 18, 25 );
(истина, когда col1 одновременно больше всех из перечисленных чисел, это эквивалентно >25)

select col1, col2 from tab where col1 LIKE '_z%';
(истина, если вторая буква в строке z)

select col1, col2 from tab where col1 NOT LIKE '_z%';
(истина, если вторая буква в строке не z)

select col1, col2 from tab where col1 LIKE '%\%%'  ESCAPE '\';
(истина, если в строке содержится символ %)

select col1, col2 from tab where col1 IN ( 12, 18, 25 );

select col1, col2 from tab where col1 NOT IN ( 12, 18, 25, null );
(если в списке NOT IN встретится null, то выражение вернет false)

select col1, col2 from tab where col1  BETWEEN ( 10 and 20 );

select col1, col2 from tab where col1  NOT BETWEEN ( 10 and 20 );

select col1, col2, col3  from tab where col1 > '28-JAN-1971' and col2 > 10;

select col1, col2, col3  from tab where col1 > '28-JAN-1971' or col2 > 10;

select col1, col2, col3  from tab where col1 > '28-JAN-1971' or ( col2 > 10 and col3 LIKE '_z%');
(у AND больший приоритет чем у OR)

select col1, col2, col3  from tab order by col1;

select col1, col2, col3  from tab order by 1;

select col1, col2, col3  from tab order by col1 ASC, col2 DESC;



Выборка строк из двух таблиц:

select tab1.col,  tab2.col
from   tab1, tab2
where  tab1.col_tab2_id = tab2.col_tab2_id
  and  tab1.col_tab1_id = 100;


(используя псевдонимы)

select t1.col,  t2.col
from   tab1 t1, tab2 t2
where  t1.col_tab2_id = t2.col_tab2_id
  and  t1.col_tab1_id = 100;


(Декартово произведение)

select t1.col,  t2.col
from   tab1 t1, tab2 t2


Выборка строк из более чем двух таблиц:

select t1.col,  t2.col AS COL_T2, t3.col AS COL_T3
from   tab1 t1, tab2 t2, tab3 t3, tab4 t4
where  t1.col_tab1_id = t2.col_tab1_id
  and  t3.col_tab3_id = t2.col_tab3_id
  and  t3.col_tab4_id = t4.col_tab4_id
order by t3.col;


Типы соединений

 В предыдущих примерах в условиях соединения использовался знак равенства (=),
поэтому такие соединения называют соединениями по эквивалентности equijoins.

Соединения по эквивалентности:
используется знак =

Соединения по неэквивалентности:
используются операторы <, >, between и т.д.

Кроме того есть

Внутренние соединения:
в столбцах условия соединения содержатся значения удовлетворяющие условию,
т.е. нет пустых значений.

Внешние соединения:
когда один из столбцов соединения может сожержать значения NULL.

Самосоединения:
возвращают соединенные строки одной и той же таблицы


Примеры:

(соединение по неэквивалентности)

select t1.col1, t2.col1, t2.col2, t2.col3
from   tab1 t1, tab2 t2
where  t1.col1 BETWEEN t2.col1 and t2.col2
order  by t2.col3;


(внешнее соединение)

select t1.col,  t2.col
from   tab1 t1, tab2 t2
where  t1.col_tab2_id = t2.col_tab2_id(+)
order by t1.col;

где (+), там могут быть пустые значения
(в нашем случае в таблице tab2)


Левое и правое внешние соединения

Левое соединение:
оператор внешнего соединения (+) появляется справа от знака =
where  t1.col_tab2_id = t2.col_tab2_id(+)

Правое соединение:
оператор внешнего соединения (+) стоит слева от знака =
where  t1.col_tab2_id(+) = t2.col_tab2_id

Ограничения внешних соединений

оператор  (+) можно поместить только с одной стороны от знака =

нельзя использовать (+) с IN
where  t1.col_tab2_id(+) IN ( 1, 2, 3 )

нельзя использовать (+) с OR
where .... (+) = .... OR .... = 10




(Левое внешнее соединение)

select t1.col,  t2.col
from   tab1 t1, tab2 t2
where  t1.col_tab2_id = t2.col_tab2_id(+)
order by t1.col;

(Правое внешнее соединение)

select t1.col,  t2.col
from   tab1 t1, tab2 t2
where  t1.col_tab2_id(+) = t2.col_tab2_id
order by t1.col;


(Полное внешнее соединение)

Двунаправленное внешнее соединение не разрешено:

where  t1.col_tab2_id(+) = t2.col_tab2_id(+)
получим ошибку ORA-01468

Остается один выход, объединить два запроса:

select t1.col,  t2.col
from   tab1 t1, tab2 t2
where  t1.col_tab2_id(+) = t2.col_tab2_id
UNION
select t1.col,  t2.col
from   tab1 t1, tab2 t2
where  t1.col_tab2_id = t2.col_tab2_id(+);


Самосоединения selfjoin
получается в результате соединения таблицы с самой собой.

select t1.col,  t2.col
from   tab t1, tab t2
where  t1.col1_id = t2.col2_id;
order by t1.col;

Можно выполнить внешнее соединение в сочетании с самосоединением:

select t1.col,  t2.col
from   tab t1, tab t2
where  t1.col1_id(+) = t2.col2_id;
order by t1.col;


Новый синтаксис соединений SQL/92
(появился в версии 9i)

До этого мы пользовались стандартом SQL/86

Примеры:

SQL/86:

select t1.col,  t2.col
from   tab1 t1, tab2 t2
where  t1.col_tab2_id = t2.col_tab2_id
order by t1.col;

SQL/92:

select t1.col,  t2.col
from   tab1 t1
       INNER JOIN tab2 t2
ON     t1.col_tab2_id = t2.col_tab2_id
order by t1.col;


Во фразе ON можно использовать операторы неэквивалентности:

ON t1.col1 BETWEEN t2.col1 and t2.col2


Если в запросе используется соединение по эквивалентности
и столбцы, по которым выполняется соединение, имеют одинаковые имена
то можно воспользоваться сокращенным синтаксисом:

select t1.col,  t2.col
from   tab1 t1
       INNER JOIN tab2 t2
ON     t1.col_tab2_id = t2.col_tab2_id
order by t1.col;

этот запрос можно переписать так:

select t1.col,  t2.col
from   tab1 t1
       INNER JOIN tab2 t2
USING( col_tab2_id )
order by t1.col;


ON     t1.col_tab2_id = t2.col_tab2_id
мы заменили на
USING( col_tab2_id )

Имя столбца соединения во фразе USING должно использоваться без псевдонимов
и теперь везде этот столбец нужно использовать без псевдонимов
в том числе и во фразе SELECT:

select t1.col,  t2.col, col_tab2_id
from   tab1 t1
       INNER JOIN tab2 t2
USING( col_tab2_id )
order by t1.col;

Внутренние соединения более двух таблиц:

select t1.col,  t2.col AS COL_T2, t3.col AS COL_T3
from   tab1 t1, tab2 t2, tab3 t3, tab4 t4
where  t1.col_tab1_id = t2.col_tab1_id
  and  t3.col_tab3_id = t2.col_tab3_id
  and  t3.col_tab4_id = t4.col_tab4_id
order by t3.col;

В нотации SQL/92 этот запрос можно переписать так:

select t1.col,  t2.col AS COL_T2, t3.col AS COL_T3
from   tab1 t1
       INNER JOIN tab2 t2 
       ON t1.col_tab1_id = t2.col_tab1_id
       INNER JOIN tab3 t3 
       ON t3.col_tab3_id = t2.col_tab3_id
       INNER JOIN tab3 t4 
       ON t3.col_tab4_id = t4.col_tab4_id
order by t3.col;

или даже так:

select t1.col,  t2.col AS COL_T2, t3.col AS COL_T3
from   tab1 t1
       INNER JOIN tab2 t2 
       USING(col_tab1_id)
       INNER JOIN tab3 t3 
       USING(col_tab3_id)
       INNER JOIN tab3 t4 
       USING(col_tab4_id)
order by t3.col;


Если в соединении используется более одного столбца из двух таблиц,
можно во фразе ON использовать оператор AND:

select t1.col, t2.col
from   tab1 t1
       INNER JOIN tab2 t2
       ON  t1.col1 = t2.col1
       AND t1.col2 = t2.col2;

а если имена столбцов одинаковы и используются эквисоединение,
то запись можно упростить:

select t1.col, t2.col
from   tab1 t1
       INNER JOIN tab2 t2
       USING(col1, col2);

Внешние соединения в нотации SQL/92

Существует три вида внешних соединений

LEFT  OUTER JOIN
RIGHT OUTER JOIN
FULL  OUTER JOIN


Левое внешнее соединение:

select t1.col,  t2.col
from   tab1 t1, tab2 t2
where  t1.col_tab2_id = t2.col_tab2_id(+)
order by t1.col;

в нотации SQL/92 будет выглядеть так:

select t1.col,  t2.col
from   tab1 t1
       LEFT OUTER JOIN  tab2 t2
       ON  t1.col_tab2_id = t2.col_tab2_id
order by t1.col;

или

select t1.col,  t2.col
from   tab1 t1
       LEFT OUTER JOIN  tab2 t2
       USING(col_tab2_id)
order by t1.col;


Правое внешнее соединение

select t1.col,  t2.col
from   tab1 t1, tab2 t2
where  t1.col_tab2_id(+) = t2.col_tab2_id
order by t1.col;

в нотации SQL/92 будет выглядеть так:

select t1.col,  t2.col
from   tab1 t1
       RIGHT OUTER JOIN  tab2 t2
       ON  t1.col_tab2_id = t2.col_tab2_id
order by t1.col;

или

select t1.col,  t2.col
from   tab1 t1
       RIGHT OUTER JOIN  tab2 t2
       USING(col_tab2_id)
order by t1.col;



Полное внешнее соединение

select t1.col,  t2.col
from   tab1 t1, tab2 t2
where  t1.col_tab2_id(+) = t2.col_tab2_id
UNION
select t1.col,  t2.col
from   tab1 t1, tab2 t2
where  t1.col_tab2_id = t2.col_tab2_id(+);

в нотации SQL/92 будет выглядеть так:

select t1.col,  t2.col
from   tab1 t1
       FULL OUTER JOIN  tab2 t2
       ON  t1.col_tab2_id = t2.col_tab2_id
order by t1.col;

или

select t1.col,  t2.col
from   tab1 t1
       FULL OUTER JOIN  tab2 t2
       USING(col_tab2_id)
order by t1.col;



Самосоединения selfjoin
когда таблица соединяется сама собой.

select t1.col,  t2.col
from   tab t1, tab t2
where  t1.col1_id = t2.col2_id;
order by t1.col;

в нотации SQL/92 будет выглядеть так:

select t1.col,  t2.col
from   tab t1
       INNER JOIN tab t2
       ON  t1.col1_id = t2.col2_id;


Декартово произведение в нотации SQL/92 создается так:

select t1.col,  t2.col
from   tab1 t1
       CROSS JOIN tab2 t2;


Еще примеры:

drop table t;
create table t(id, type, text)
as
select object_id, object_type, object_name
from all_objects
order by 1;

drop table t1;
create table t1(id, type, text)
as
select id, type, text
from t
where rownum <= 5;


drop table t2;
create table t2
as
select id,  type , text
from t
where rownum <= 10;



select id, type, text from t1;

2    CLUSTER    C_OBJ#
3    INDEX    I_OBJ#
4    TABLE    TAB$
5    TABLE    CLU$
6    CLUSTER    C_TS#


select id, type, text from t2;
2    CLUSTER    C_OBJ#
3    INDEX    I_OBJ#
4    TABLE    TAB$
5    TABLE    CLU$
6    CLUSTER    C_TS#
7    INDEX    I_TS#
8    CLUSTER    C_FILE#_BLOCK#
9    INDEX    I_FILE#_BLOCK#
10    CLUSTER    C_USER#
11    INDEX    I_USER#

Работа с множествами:

select id, type, text from t1
UNION ALL
select id, type, text from t2;

2    CLUSTER    C_OBJ#
3    INDEX    I_OBJ#
4    TABLE    TAB$
5    TABLE    CLU$
6    CLUSTER    C_TS#
2    CLUSTER    C_OBJ#
3    INDEX    I_OBJ#
4    TABLE    TAB$
5    TABLE    CLU$
6    CLUSTER    C_TS#
7    INDEX    I_TS#
8    CLUSTER    C_FILE#_BLOCK#
9    INDEX    I_FILE#_BLOCK#
10    CLUSTER    C_USER#
11    INDEX    I_USER#



select id, type, text from t1
UNION ALL
select id, type, text from t2
order by 1;

2    CLUSTER    C_OBJ#
2    CLUSTER    C_OBJ#
3    INDEX    I_OBJ#
3    INDEX    I_OBJ#
4    TABLE    TAB$
4    TABLE    TAB$
5    TABLE    CLU$
5    TABLE    CLU$
6    CLUSTER    C_TS#
6    CLUSTER    C_TS#
7    INDEX    I_TS#
8    CLUSTER    C_FILE#_BLOCK#
9    INDEX    I_FILE#_BLOCK#
10    CLUSTER    C_USER#
11    INDEX    I_USER#


select id, type, text from t1
UNION
select id, type, text from t2;

2    CLUSTER    C_OBJ#
3    INDEX    I_OBJ#
4    TABLE    TAB$
5    TABLE    CLU$
6    CLUSTER    C_TS#
7    INDEX    I_TS#
8    CLUSTER    C_FILE#_BLOCK#
9    INDEX    I_FILE#_BLOCK#
10    CLUSTER    C_USER#
11    INDEX    I_USER#


select id, type, text from t1
INTERSECT
select id, type, text from t2;


2    CLUSTER    C_OBJ#
3    INDEX    I_OBJ#
4    TABLE    TAB$
5    TABLE    CLU$
6    CLUSTER    C_TS#



select id, type, text from t1
MINUS
select id, type, text from t2;

ничего не возвратит


select id, type, text from t2
MINUS
select id, type, text from t1;


7    INDEX    I_TS#
8    CLUSTER    C_FILE#_BLOCK#
9    INDEX    I_FILE#_BLOCK#
10    CLUSTER    C_USER#
11    INDEX    I_USER#


(select id, type, text from t1
UNION ALL
select id, type, text from t2)
MINUS
select id, type, text from t1;

7    INDEX    I_TS#
8    CLUSTER    C_FILE#_BLOCK#
9    INDEX    I_FILE#_BLOCK#
10    CLUSTER    C_USER#
11    INDEX    I_USER#


Функция TRANSLATE()

select TRANSLATE('TOM KYTE', 'ABCDEFGH', 'АБЦДЕФГХ') from dual;

TOM KYTЕ


select TRANSLATE('SCOTT URMAN', 'ABCDEFGH', 'АБЦДЕФГХ') from dual

SЦOTT URMАN

select id, type, TRANSLATE(text, 'ABCDEFGH', 'АБЦДЕФГХ') from t1

2    CLUSTER    Ц_OБJ#
3    INDEX    I_OБJ#
4    TABLE    TАБ$
5    TABLE    ЦLU$
6    CLUSTER    Ц_TS#


Функция DECODE:

SELECT
id,
DECODE (id,
    2, 'Кластер',
    3, 'Индекс',
    4, 'Таблица',
    5, 'Таблица',
    6, 'Кластер',
   'Тип неопределен') type ,
text
FROM t1;


2    Кластер    C_OBJ#
3    Индекс    I_OBJ#
4    Таблица    TAB$
5    Таблица    CLU$
6    Кластер    C_TS#


Функция CASE:

SELECT id,
       CASE id
       WHEN  2 THEN  'Кластер'
       WHEN  3 THEN 'Индекс'
       WHEN  4 THEN 'Таблица'
       WHEN  5 THEN 'Таблица'
       WHEN  6 THEN 'Кластер'
       ELSE   'Тип неопределен'
       END type,
       text
FROM t1;   

2    Кластер    C_OBJ#
3    Индекс    I_OBJ#
4    Таблица    TAB$
5    Таблица    CLU$
6    Кластер    C_TS#

или так

SELECT id,
       CASE
       WHEN id = 2 THEN  'Кластер'
       WHEN id = 3 THEN 'Индекс'
       WHEN id = 4 THEN 'Таблица'
       WHEN id = 5 THEN 'Таблица'
       WHEN id = 6 THEN 'Кластер'
       ELSE   'Тип неопределен'
       END type,
       text
FROM t1;   

2    Кластер    C_OBJ#
3    Индекс    I_OBJ#
4    Таблица    TAB$
5    Таблица    CLU$
6    Кластер    C_TS#


Фраза WITH и вынесенные подзапросы:

Общий вид такой:


WITH
   a AS (select ....from t)
  ,b AS (select ....from a)
  ,c AS (select ....from a, b)
select ... from a, b, c;


Например:

drop table t
create table t as

WITH X AS
(
    SELECT  1 ID, NULL PARENT_ID, 'Игорь'      F_NAME,   'Директор'               TITLE, 800000 SALARY FROM dual UNION ALL
    SELECT  2 ID,    1 PARENT_ID, 'Сергей'     F_NAME,   'Менеджер по продажам'   TITLE, 600000 SALARY FROM dual UNION ALL
    SELECT  3 ID,    2 PARENT_ID, 'Андрей'     F_NAME,   'Продавец'               TITLE, 200000 SALARY FROM dual UNION ALL
    SELECT  4 ID,    1 PARENT_ID, 'Виталий'    F_NAME,   'Менеджер'               TITLE, 500000 SALARY FROM dual UNION ALL
    SELECT  5 ID,    2 PARENT_ID, 'Александр'  F_NAME,   'Продавец'               TITLE,  40000 SALARY FROM dual UNION ALL
    SELECT  6 ID,    4 PARENT_ID, 'Владимир'   F_NAME,   'Персонал по поддержке'  TITLE,  45000 SALARY FROM dual UNION ALL
    SELECT  7 ID,    4 PARENT_ID, 'Николай'    F_NAME,   'Менеджер по поддержке'  TITLE,  30000 SALARY FROM dual UNION ALL
    SELECT  8 ID,    7 PARENT_ID, 'Ольга'      F_NAME,   'Персонал по поддержке'  TITLE,  29000 SALARY FROM dual UNION ALL
    SELECT  9 ID,    6 PARENT_ID, 'Марина'     F_NAME,   'Персонал по поддержке'  TITLE,  30000 SALARY FROM dual UNION ALL
    SELECT 10 ID,    1 PARENT_ID, 'Елена'      F_NAME,   'Операционный  менеджер' TITLE, 100000 SALARY FROM dual UNION ALL
    SELECT 11 ID,   10 PARENT_ID, 'Надежда'    F_NAME,   'Операционистка'         TITLE,  50000 SALARY FROM dual UNION ALL
    SELECT 12 ID,   10 PARENT_ID, 'Анна'       F_NAME,   'Операционистка'         TITLE,  45000 SALARY FROM dual UNION ALL
    SELECT 13 ID,   10 PARENT_ID, 'Татьяна'    F_NAME,   'Операционистка'         TITLE,  47000 SALARY FROM dual
)
select * from x;


1        Игорь    Директор    800000
2    1    Сергей    Менеджер по продажам    600000
3    2    Андрей    Продавец    200000
4    1    Виталий    Менеджер    500000
5    2    Александр    Продавец    40000
6    4    Владимир    Персонал по поддержке    45000
7    4    Николай    Менеджер по поддержке    30000
8    7    Ольга    Персонал по поддержке    29000
9    6    Марина    Персонал по поддержке    30000
10    1    Елена    Операционный  менеджер    100000
11    10    Надежда    Операционистка    50000
12    10    Анна    Операционистка    45000
13    10    Татьяна    Операционистка    47000


Иерархические запросы

Для выполнения иерархических запросов можно использовать фразы:
CONNECT BY  и START WITH  оператора SELECT


SELECT [LEVEL], столбец, ...
FROM таблица
[WHERE ...]
[ [START WITH стартовое условие]  [CONNECT BY PRIOR условие_prior] ]


LEVEL  - уровень вложенности узлов
1 - корневой узел

Стартовое условие  - с какого места начинать иерархический запрос
например ID = 1

Условие prior определяет отношение между родительскими и подчиненными строками
у нас это условие такое  ID = PARENT_ID



select * from t
start with id =1
connect by prior id = parent_id;

1        Игорь    Директор    800000
2    1    Сергей    Менеджер по продажам    600000
3    2    Андрей    Продавец    200000
5    2    Александр    Продавец    40000
4    1    Виталий    Менеджер    500000
6    4    Владимир    Персонал по поддержке    45000
9    6    Марина    Персонал по поддержке    30000
7    4    Николай    Менеджер по поддержке    30000
8    7    Ольга    Персонал по поддержке    29000
10    1    Елена    Операционный  менеджер    100000
11    10    Надежда    Операционистка    50000
12    10    Анна    Операционистка    45000
13    10    Татьяна    Операционистка    47000



Для удобства используем псевдостолбец LEVEL


select level,  t.* from t
start with id =1
connect by prior id = parent_id;


level   id
1    1        Игорь    Директор    800000
2    2    1    Сергей    Менеджер по продажам    600000
3    3    2    Андрей    Продавец    200000
3    5    2    Александр    Продавец    40000
2    4    1    Виталий    Менеджер    500000
3    6    4    Владимир    Персонал по поддержке    45000
4    9    6    Марина    Персонал по поддержке    30000
3    7    4    Николай    Менеджер по поддержке    30000
4    8    7    Ольга    Персонал по поддержке    29000
2    10    1    Елена    Операционный  менеджер    100000
3    11    10    Надежда    Операционистка    50000
3    12    10    Анна    Операционистка    45000
3    13    10    Татьяна    Операционистка    47000




Сколько уровней в дереве:

select count(distinct level) from t
start with id =1
connect by prior id = parent_id;

4


Форматирование результатов иерархического запроса

используем функцию LPAD()
она слева дополняет значение заданными символами
LPAD('    ',  2*LEVEL-1 )  - вставляет  2*LEVEL-1  пробелов


select level,
lpad(' ', 4*level-1) || F_NAME
from t
start with id =1
connect by prior id = parent_id;


1       Игорь
2           Сергей
3               Андрей
3               Александр
2           Виталий
3               Владимир
4                   Марина
3               Николай
4                   Ольга
2           Елена
3               Надежда
3               Анна
3               Татьяна


Можно начать не с корневого узла
например так:

select level,
lpad(' ', 4*level-1) || F_NAME
from t
start with f_name = 'Елена'
connect by prior id = parent_id;


1       Елена
2           Надежда
2           Анна
2           Татьяна


или так:


select level,
lpad(' ', 4*level-1) || F_NAME
from t
start with id = 4
connect by prior id = parent_id;


1       Виталий
2           Владимир
3               Марина
2           Николай
3               Ольга


Во фразе START WITH можно использовать и подзапросы.


select level,
lpad(' ', 4*level-1) || F_NAME
from t
start with id = (select id from t where f_name = 'Елена')
connect by prior id = parent_id;


1       Елена
2           Надежда
2           Анна
2           Татьяна


Восходящий обход дерева

Можно вести обход дерева снизу вверх
для этого поменяем  местами в условии CONNECT BY PRIOR столбцы:

connect by prior id = parent_id
на
connect by prior parent_id = id;

и в start with указать с какого места начинать.


select level,
lpad(' ', 4*level-1) || F_NAME
from t
start with id = (select id from t where f_name = 'Ольга')
connect by prior parent_id = id;


1       Ольга
2           Николай
3               Виталий
4                   Игорь



Исключение из иерархического запроса узлов и ветвей

Исключим из результатов данные о служащем Сергее.


select level,
lpad(' ', 4*level-1) || F_NAME
from t
where f_name != 'Сергей'
start with id =1
connect by prior id = parent_id;

1       Игорь
3               Андрей
3               Александр
2           Виталий
3               Владимир
4                   Марина
3               Николай
4                   Ольга
2           Елена
3               Надежда
3               Анна
3               Татьяна


Сергей исключен, но его подчиненные Андрей и Александр остались.

Чтобы исключить всю ветвь, нужно добавить во фразу
CONNECT BY PRIOR  фоазу AND:

select level,
lpad(' ', 4*level-1) || F_NAME
from t
start with id =1
connect by prior id = parent_id
and  f_name != 'Сергей';

1       Игорь
2           Виталий
3               Владимир
4                   Марина
3               Николай
4                   Ольга
2           Елена
3               Надежда
3               Анна
3               Татьяна



Включение в иерархический запрос других условий:
например вывести только тех служащих, зарплата которых не превышает 50000

select level,
lpad(' ', 4*level-1) || F_NAME,
salary
from t
where salary <= 50000
start with id =1
connect by prior id = parent_id;


3               Александр    40000
3               Владимир    45000
4                   Марина    30000
3               Николай    30000
4                   Ольга    29000
3               Надежда    50000
3               Анна    45000
3               Татьяна    47000



Группировка  результатов:


drop table t;

create table t
as
select object_id id, owner own, object_type type, object_name text
from all_objects
where object_type in
('SEQUENCE',
'PROCEDURE',
'PACKAGE',
'TRIGGER',
'TABLE',
'INDEX',
'SYNONYM',
'VIEW',
'FUNCTION')
and owner in ('SYS','SYSTEM');



select type, count(text) from t
group by  type
order by  type;

FUNCTION    117
INDEX    1460
PACKAGE    721
PROCEDURE    151
SEQUENCE    180
SYNONYM    27
TABLE    1443
TRIGGER    13
VIEW    5742


select type, count(text) from t
group by rollup(type)
order by  type;

FUNCTION    117
INDEX    1460
PACKAGE    721
PROCEDURE    151
SEQUENCE    180
SYNONYM    27
TABLE    1443
TRIGGER    13
VIEW    5742
    9854


Передача в ROLLUP нескольких столбцов

select own, type, count(text) from t
group by rollup(own, type)
order by  own, type;

SYS    FUNCTION    113
SYS    INDEX    1224
SYS    PACKAGE    720
SYS    PROCEDURE    150
SYS    SEQUENCE    158
SYS    SYNONYM    19
SYS    TABLE    1265
SYS    TRIGGER    11
SYS    VIEW    5728
SYS        9388
SYSTEM    FUNCTION    4
SYSTEM    INDEX    236
SYSTEM    PACKAGE    1
SYSTEM    PROCEDURE    1
SYSTEM    SEQUENCE    22
SYSTEM    SYNONYM    8
SYSTEM    TABLE    178
SYSTEM    TRIGGER    2
SYSTEM    VIEW    14
SYSTEM        466
        9854


Изменим порядок столбцов в rollup:

select own, type, count(text) from t
group by rollup(type, own)
order by  type, own ;

SYS    FUNCTION    113
SYSTEM    FUNCTION    4
    FUNCTION    117
SYS    INDEX    1224
SYSTEM    INDEX    236
    INDEX    1460
SYS    PACKAGE    720
SYSTEM    PACKAGE    1
    PACKAGE    721
SYS    PROCEDURE    150
SYSTEM    PROCEDURE    1
    PROCEDURE    151
SYS    SEQUENCE    158
SYSTEM    SEQUENCE    22
    SEQUENCE    180
SYS    SYNONYM    19
SYSTEM    SYNONYM    8
    SYNONYM    27
SYS    TABLE    1265
SYSTEM    TABLE    178
    TABLE    1443
SYS    TRIGGER    11
SYSTEM    TRIGGER    2
    TRIGGER    13
SYS    VIEW    5728
SYSTEM    VIEW    14
    VIEW    5742
        9854


Фраза CUBE расширяет GROUP BY в том плане, что она возвращает строки,
содержащие предварительные итоги для всех комбинаций столбцов,
включенных во фразу CUBE, а в конце возвращается строка с итогом.

select own, type, count(text) from t
group by cube(own, type)
order by  own, type;

SYS    FUNCTION    113
SYS    INDEX    1224
SYS    PACKAGE    720
SYS    PROCEDURE    150
SYS    SEQUENCE    158
SYS    SYNONYM    19
SYS    TABLE    1265
SYS    TRIGGER    11
SYS    VIEW    5728
SYS        9388
SYSTEM    FUNCTION    4
SYSTEM    INDEX    236
SYSTEM    PACKAGE    1
SYSTEM    PROCEDURE    1
SYSTEM    SEQUENCE    22
SYSTEM    SYNONYM    8
SYSTEM    TABLE    178
SYSTEM    TRIGGER    2
SYSTEM    VIEW    14
SYSTEM        466
    FUNCTION    117
    INDEX    1460
    PACKAGE    721
    PROCEDURE    151
    SEQUENCE    180
    SYNONYM    27
    TABLE    1443
    TRIGGER    13
    VIEW    5742
        9854


Изменим порядок столбцов в cube()

select own, type, count(text) from t
group by cube(type, own)
order by  type, own;

SYS    FUNCTION    113
SYSTEM    FUNCTION    4
    FUNCTION    117
SYS    INDEX    1224
SYSTEM    INDEX    236
    INDEX    1460
SYS    PACKAGE    720
SYSTEM    PACKAGE    1
    PACKAGE    721
SYS    PROCEDURE    150
SYSTEM    PROCEDURE    1
    PROCEDURE    151
SYS    SEQUENCE    158
SYSTEM    SEQUENCE    22
    SEQUENCE    180
SYS    SYNONYM    19
SYSTEM    SYNONYM    8
    SYNONYM    27
SYS    TABLE    1265
SYSTEM    TABLE    178
    TABLE    1443
SYS    TRIGGER    11
SYSTEM    TRIGGER    2
    TRIGGER    13
SYS    VIEW    5728
SYSTEM    VIEW    14
    VIEW    5742
SYS        9388
SYSTEM        466
        9854



Функция GROUPING() принимает столбец, а возвращает 0 или 1
Если значение столбца null, то возвращает 1
если значение столбца не пустое, то возвращает 0

Это может пригодиться:

select  type, count(text) from t
group by cube(type)
order by  type;

FUNCTION    117
INDEX    1460
PACKAGE    721
PROCEDURE    151
SEQUENCE    180
SYNONYM    27
TABLE    1443
TRIGGER    13
VIEW    5742
    9854


select grouping(type),  type,  count(text)  from t
group by cube(type)
order by  type;

0    FUNCTION    117
0    INDEX    1460
0    PACKAGE    721
0    PROCEDURE    151
0    SEQUENCE    180
0    SYNONYM    27
0    TABLE    1443
0    TRIGGER    13
0    VIEW    5742
1        9854


select
case grouping(type)
    when 1 then 'Итог:'
    else type
end as type,
count(text)  from t
group by cube(type)
order by  type;

FUNCTION    117
INDEX    1460
PACKAGE    721
PROCEDURE    151
SEQUENCE    180
SYNONYM    27
TABLE    1443
TRIGGER    13
VIEW    5742
Итог:    9854


Конвертация значений нескольких столбцов:

select
case grouping(own)
    when 1 then 'Все own : '
    else own
end as own,
case grouping(type)
    when 1 then 'Все type : '
    else type
end as type,
count(text) from t
group by rollup(own, type)
order by  own, type;

SYS    FUNCTION    113
SYS    INDEX    1224
SYS    PACKAGE    720
SYS    PROCEDURE    150
SYS    SEQUENCE    158
SYS    SYNONYM    19
SYS    TABLE    1265
SYS    TRIGGER    11
SYS    VIEW    5728
SYS    Все type :     9388
SYSTEM    FUNCTION    4
SYSTEM    INDEX    236
SYSTEM    PACKAGE    1
SYSTEM    PROCEDURE    1
SYSTEM    SEQUENCE    22
SYSTEM    SYNONYM    8
SYSTEM    TABLE    178
SYSTEM    TRIGGER    2
SYSTEM    VIEW    14
SYSTEM    Все type :     466
Все own :     Все type :     9854


С использованием фразы cube:

select
case grouping(own)
    when 1 then 'Все own : '
    else own
end as own,
case grouping(type)
    when 1 then 'Все type : '
    else type
end as type,
count(text) from t
group by cube(own, type)
order by  own, type;

SYS    FUNCTION    113
SYS    INDEX    1224
SYS    PACKAGE    720
SYS    PROCEDURE    150
SYS    SEQUENCE    158
SYS    SYNONYM    19
SYS    TABLE    1265
SYS    TRIGGER    11
SYS    VIEW    5728
SYS    Все type :     9388
SYSTEM    FUNCTION    4
SYSTEM    INDEX    236
SYSTEM    PACKAGE    1
SYSTEM    PROCEDURE    1
SYSTEM    SEQUENCE    22
SYSTEM    SYNONYM    8
SYSTEM    TABLE    178
SYSTEM    TRIGGER    2
SYSTEM    VIEW    14
SYSTEM    Все type :     466
Все own :     FUNCTION    117
Все own :     INDEX    1460
Все own :     PACKAGE    721
Все own :     PROCEDURE    151
Все own :     SEQUENCE    180
Все own :     SYNONYM    27
Все own :     TABLE    1443
Все own :     TRIGGER    13
Все own :     VIEW    5742
Все own :     Все type :     9854



Если необходимо получить только промежуточные итоги, используйте фразу
GROUPING SETS

select own, type, count(text) from t
group by grouping sets(own, type)
order by  own, type;

SYS        9388
SYSTEM        466
    FUNCTION    117
    INDEX    1460
    PACKAGE    721
    PROCEDURE    151
    SEQUENCE    180
    SYNONYM    27
    TABLE    1443
    TRIGGER    13
    VIEW    5742


Ранее мы рассмотрели функцию grouping()
она работала так:

grouping(null)      ->  1
grouping(not null)  ->  0

Существует функция grouping_id()
она принимает два аргумента и возвращает следующие значения:

grouping_id(null, null)          ->  0
grouping_id(null, not null)      ->  1
grouping_id(not null, null)      ->  2
grouping_id(not null, not null)  ->  3


Где это может быть полезно ?


select own, type,
grouping(own) as own_grp,
grouping(type) as type_grp,
grouping_id(own, type)  as grp_id,
count(text) from t
group by cube(own, type)
order by  own, type;



SYS    FUNCTION    0    0    0    113
SYS    INDEX    0    0    0    1224
SYS    PACKAGE    0    0    0    720
SYS    PROCEDURE    0    0    0    150
SYS    SEQUENCE    0    0    0    158
SYS    SYNONYM    0    0    0    19
SYS    TABLE    0    0    0    1265
SYS    TRIGGER    0    0    0    11
SYS    VIEW    0    0    0    5728
SYS        0    1    1    9388
SYSTEM    FUNCTION    0    0    0    4
SYSTEM    INDEX    0    0    0    236
SYSTEM    PACKAGE    0    0    0    1
SYSTEM    PROCEDURE    0    0    0    1
SYSTEM    SEQUENCE    0    0    0    22
SYSTEM    SYNONYM    0    0    0    8
SYSTEM    TABLE    0    0    0    178
SYSTEM    TRIGGER    0    0    0    2
SYSTEM    VIEW    0    0    0    14
SYSTEM        0    1    1    466
    FUNCTION    1    0    2    117
    INDEX    1    0    2    1460
    PACKAGE    1    0    2    721
    PROCEDURE    1    0    2    151
    SEQUENCE    1    0    2    180
    SYNONYM    1    0    2    27
    TABLE    1    0    2    1443
    TRIGGER    1    0    2    13
    VIEW    1    0    2    5742
        1    1    3    9854




Одно из полезных применений функции grouping_id() - это фильтрация строк при помощи фразы HAVING.

select own, type,
grouping_id(own, type)  as grp_id,
count(text) from t
group by cube(own, type)
having grouping_id(own, type)  > 0
order by  own, type;

SYS        1    9388
SYSTEM        1    466
    FUNCTION    2    117
    INDEX    2    1460
    PACKAGE    2    721
    PROCEDURE    2    151
    SEQUENCE    2    180
    SYNONYM    2    27
    TABLE    2    1443
    TRIGGER    2    13
    VIEW    2    5742
        3    9854




Еще примеры:

Рассмотрим такой запрос:

select own, type, count(text) from t
group by own, rollup(own, type);

SYS    VIEW    5728
SYS    INDEX    1224
SYS    TABLE    1265
SYS    PACKAGE    720
SYS    SYNONYM    19
SYS    TRIGGER    11
SYS    FUNCTION    113
SYS    SEQUENCE    158
SYS    PROCEDURE    150
SYSTEM    VIEW    14
SYSTEM    INDEX    236
SYSTEM    TABLE    178
SYSTEM    PACKAGE    1
SYSTEM    SYNONYM    8
SYSTEM    TRIGGER    2
SYSTEM    FUNCTION    4
SYSTEM    SEQUENCE    22
SYSTEM    PROCEDURE    1
SYS        9388
SYSTEM        466
SYS        9388
SYSTEM        466


Здесь мы во фразе group by дважды сгруппировали
сначала по столбцу own, а затем по фразе rollup()

Но последние две строки выходных данных, дублируют предыдущие.

Чтобы это исправить, воспользуемся функцией group_id()

Функция group_id() не принимает никаких параметров.
Если в какой либо конкретной группировке есть n дубликатов, group_id() возвратит числа в диапазоне от 0 до n-1.

select own, type, group_id(), count(text) from t
group by own, rollup(own, type);

SYS    VIEW    0    5728
SYS    INDEX    0    1224
SYS    TABLE    0    1265
SYS    PACKAGE    0    720
SYS    SYNONYM    0    19
SYS    TRIGGER    0    11
SYS    FUNCTION    0    113
SYS    SEQUENCE    0    158
SYS    PROCEDURE    0    150
SYSTEM    VIEW    0    14
SYSTEM    INDEX    0    236
SYSTEM    TABLE    0    178
SYSTEM    PACKAGE    0    1
SYSTEM    SYNONYM    0    8
SYSTEM    TRIGGER    0    2
SYSTEM    FUNCTION    0    4
SYSTEM    SEQUENCE    0    22
SYSTEM    PROCEDURE    0    1
SYS        0    9388
SYSTEM        0    466
SYS        1    9388
SYSTEM        1    466


Теперь две последние строки можно отфильтровать во фразе having:


select own, type, group_id(), count(text) from t
group by own, rollup(own, type)
having group_id() = 0;


SYS    VIEW    0    5728
SYS    INDEX    0    1224
SYS    TABLE    0    1265
SYS    PACKAGE    0    720
SYS    SYNONYM    0    19
SYS    TRIGGER    0    11
SYS    FUNCTION    0    113
SYS    SEQUENCE    0    158
SYS    PROCEDURE    0    150
SYSTEM    VIEW    0    14
SYSTEM    INDEX    0    236
SYSTEM    TABLE    0    178
SYSTEM    PACKAGE    0    1
SYSTEM    SYNONYM    0    8
SYSTEM    TRIGGER    0    2
SYSTEM    FUNCTION    0    4
SYSTEM    SEQUENCE    0    22
SYSTEM    PROCEDURE    0    1
SYS        0    9388
SYSTEM        0    466

Кодировки в исходных текстах сценариев Python

  Для представления строк в исходных текстах сценариев Python по умолчанию  использует кодировку UTF-8, однако имеется возможность указать любую другую кодировку, включив комментарий с названием требуемой кодировки.

  Данный комментарий должен находиться в первой или во второй строке и должен иметь следующий вид:

# -*- coding: ascii -*-
import sys

.....................

Или так: 

#!/usr/bin/env python
# -*- coding: latin-1 -*-
# ==============
#   Script ...
# ==============
import sys 

.....................

Интерпретатор будет распозновать строки, представленные в указанной кодировке.

  Вы можете редактировать файл сценария в текстовом редакторе, способном принимать 

и корректно отображать национальные символы, не входящие в набор ASCII, 

а интерпретатор будет корректно декодировать их в строковые литералы.

 Когда UNIX программа запускается в консоли, она читает первые два байта.

Если это последовательность ASCII-символов #!, командная оболочка предполагает, 

что файл должен выполняться интерпретатором а первая строка определяет какой 

интерпретатор должен использоваться.

 Данная строка называется shebang (выполняется командной оболочкой).

Строка shebang обычно записывается в одной из двух форм:

#!/usr/bin/python3

или

#!/usr/bin/env python3

 В первом случае она определяет используемый интерпретатор.

 Вторая форма может потребоваться для программ на языке Python, запускаемых

веб-сервером, будет выбран первый интерпретатор python3, найденный в текущем 

окружении.

 Эта форма допускает что интерпретатор Python3 может находиться не в каталоге 

/usr/bin, а например в /usr/local/bin или $HOME)

 В ОС Windows строка shebang не требуется (хотя и не мешает).

Преобразования между кодировками в Python

 Строковые литералы определяются с помощью одинарных,  двойных или тройных кавычек.
Добавление символа b или B перед открывающей кавычкой в любой из этих форм приводит к созданию объекта типа bytes.

>>> B = b'solaris'

>>> type(B), type(S)
( < class 'bytes' >,  < class 'str' > )
>>>

>>> B
b'solaris'
 
>>> S
'oracle'
>>>

В действительности тип byte - это последовательность целых чисел.

 >>> B[0], S[0]
(115, 'o')

>>> B[1:], S[1:]
(b'olaris', 'racle')

>>> list(B), list(S)
([115, 111, 108, 97, 114, 105, 115], ['o', 'r', 'a', 'c', 'l', 'e'])
>>>

Типы byte и srt неизменяемые:

>>> B[0] = 'Z'
Traceback (most recent call last):
  File "", line 1, in
    B[0] = 'Z'
TypeError: 'bytes' object does not support item assignment
>>>
>>> S[0] = 'Z'
Traceback (most recent call last):
  File "", line 1, in
    S[0] = 'Z'
TypeError: 'str' object does not support item assignment
>>>

Кодирование строк символов ASCII:

>>> ord('o')
111

>>> chr(111)
'o'

>>> S = 'oracle'

>>> S
'oracle'

>>> len(S)
6

>>> [ord(i) for i in S]
[111, 114, 97, 99, 108, 101]

>>> S.encode('ascii')
b'oracle'

>>> S.encode('latin-1')
b'oracle'

>>> S.encode('utf-8')
b'oracle'

>>> S.encode('latin-1')[0]
111

>>> list(S.encode('latin-1'))
[111, 114, 97, 99, 108, 101]
>>>

Кодирование строк символов не ASCII:

Для представления символов можно использовать экранированные последовательности значений байтов и символов Unicode.

Шестнадцатеричные значения  0xdc  и 0xd6  представляют коды двух специальных символов, не входящих в диапазон 7-битных символов ASCII:

>>> chr(0xdc)
'Ü'

>>> chr(0xd6)
'Ö'

>>> S = '\xdc\xd6'
>>> S
'ÜÖ'

>>> S = '\u00dc\u00d6'
>>> S
'ÜÖ'

>>> S = chr(0xdc) + chr(0xd6)
>>> S
'ÜÖ'

>>> len(S)
2                              # это 2 символа (не число байтов)
>>>

Если попробовать закодировать строки символов не ASCII в последовательность простых байтов, используя кодировку ASCII, мы получим сообщение об ошибке.

Однако, если указать кодировку latin-1, ошибки не будет и каждому символу в строке будет поставлен в соответствие отдельный байт.

При использовании UTF-8 для каждого символа будет выделено по  2 - байта.

>>> S = '\u00dc\u00d6'
>>> S
'ÜÖ'

>>> len(S)
2

>>> S.encode('ascii')
Traceback (most recent call last):
  File "", line 1, in
    S.encode('ascii')
UnicodeEncodeError: 'ascii' codec can't encode characters in position 0-1: ordinal not in range(128)

>>> S.encode('latin-1')
b'\xdc\xd6'

>>> S.encode('utf-8')
b'\xc3\x9c\xc3\x96'

>>> len(S.encode('latin-1'))
2                     #  2 байта

>>> len(S.encode('utf-8'))
4                     #  4 байта
>>>

Можно пойти обратным путем - прочитать последовательность байтов из файла и декодировать их в сторону символов Unicode.

Но лучше в функции open() указать название кодировки, это поможет избежать ошибок, которые могут явиться результатом чтения неполных последовательностей символов, когда чтение выполняется блоками байтов.

>>> B = b'\xdc\xd6'
>>> B
b'\xdc\xd6'

>>> len(B)
2

>>> B.decode('latin-1')
'ÜÖ'

>>> B = b'\xc3\x9c\xc3\x96'

>>> len(B)
4

>>> B.decode('utf-8')
'ÜÖ'

>>> len(B.decode('utf-8'))
2
>>>

Другие способы кодирования строк в Unicode:

>>> S = 'A\u00dcB\U000000d6C'
>>> S
'AÜBÖC'

>>> len(S)
5                #  5 символов

>>> S.encode('latin-1')
b'A\xdcB\xd6C'

>>> len(S.encode('latin-1'))
5               #  5 байтов

>>> S.encode('utf-8')
b'A\xc3\x9cB\xc3\x96C'

>>> len(S.encode('utf-8'))
7               #  7 байтов
>>>

Некоторые кодировки могут иметь существенное различие в кодах символов.
Например кодировка cp500 (EBCDIC), даже символы ASCII кодирует не так как некоторые другие кодировки:

>>> S
'AÜBÖC'

>>> S.encode('cp500')
b'\xc1\xfc\xc2\xec\xc3'

>>> S.encode('cp850')
b'A\x9aB\x99C'

>>> S = 'oracle'

>>> S.encode('latin-1')
b'oracle'

>>> S.encode('utf-8')
b'oracle'

>>> S.encode('cp500')
b'\x96\x99\x81\x83\x93\x85'

>>> S.encode('cp850')
b'oracle'
>>>

С технической точки зрения, можно составлять строки Unicode по частям, используя функцию chr() вместо экранированных шестнадцатеричных значений, но это может оказаться утомительным в случае длинных строк:

>>> S = 'A' + chr(0xdc) + 'B' + chr(0xd6) + 'C'
>>> S
'AÜBÖC'
>>>

  В Python допускается в строках типа str кодировать специальные символы с использованием шестнадцатеричных экранированных последовательностей значений байтов и символов Unicode.
 Но в строках типа bytes могут применяться только шестнадцатеричные экранированные последовательности значений байтов.

  Экранированные последовательности значений символов Unicode в строках типа bytes будут интерпретироваться буквально, а не как экранированные последовательности.
  Фактически строки bytes должны декодироваться в строки str, чтобы корректно вывести символы, не являющиеся символами ASCII.

>>> S = 'A\xdcB\xd6C'
>>> S
'AÜBÖC'

>>> S = 'A\u00dcB\U000000d6C'
>>> S
'AÜBÖC'                        # распознает значения символов

>>> B = b'A\xdcB\xd6C'
>>> B
b'A\xdcB\xd6C'              # распознает последовательности байтов

>>> B = b'A\u00dcB\U000000d6C'
>>> B
b'A\\u00dcB\\U000000d6C'     # буквально интерпретируются
>>>


>>> B = b'A\xdcB\xd6C'
>>> B
b'A\xdcB\xd6C'

>>> print(B)
b'A\xdcB\xd6C'

>> B.decode('latin-1')
'AÜBÖC'
>>>

  При определении литералов bytes допускается использовать символы ASCII, а для байтов со значениями выше  127 - экранированные последовательности шестнадцатеричных значений.

  В литералах str допускается использовать любые символы, имеющиеся в исходной кодировке.
( в качестве которой, по умолчанию используется UTF-8, если в исходном файле явно не была объявлена другая кодировка.)

>>> S = 'AÜBÖC'
>>> S
'AÜBÖC'

>>> B = b'A\xdcB\xd6C'
>>> B
b'A\xdcB\xd6C'

>>> B.decode('latin-1')
'AÜBÖC'

>>> S.encode()
b'A\xc3\x9cB\xc3\x96C'            # системная кодировка UTF-8

>>> S.encode('UTF-8')
b'A\xc3\x9cB\xc3\x96C'

>>> B.decode()                                      # простые байты не соответствуют кодировке UTF-8
Traceback (most recent call last):
  File "", line 1, in
    B.decode()
UnicodeDecodeError: 'utf8' codec can't decode byte 0xdc in position 1: invalid continuation byte
>>>  

  Преобразования между кодировками:

>>> S = 'AÜBÖC'
>>> S
'AÜBÖC'

>>> S.encode()
b'A\xc3\x9cB\xc3\x96C'

>>> T = S.encode('cp500')
>>> T
b'\xc1\xfc\xc2\xec\xc3'

>>> U = T.decode('cp500')
>>> U
'AÜBÖC'

>>> U.encode()
b'A\xc3\x9cB\xc3\x96C'
>>>

Кодирование строк Unicode в Python

Экранированные значения байтов в шестнадцатеричном виде:

\xNN

например:
\xc4
\x84

Экранированные значения символов Unicode из четырех шестнадцатеричных цифр
( 2- байтовые 16 - битные)  коды символов:

\uNNNN

например:
\u00C4

Экранированные значения символов Unicode из восьми шестнадцатеричных цифр
( 4- байтовые 32 - битные)  коды символов:

\UNNNNNNNN

например:
\U000000E8

 Шестнадцатеричное представление ASCII - кодов символов:

O - 4F
R - 52
A - 41
C - 43
L - 4C
E - 45


>>> s = '\x4f\x52\x41\x43\x4c\x45'
>>> s
'ORACLE'
>>>

Символы UNICODE  2-х  байтовые (16- битные):

O - 004F
R - 0052
A - 0041
C - 0043
L - 004C
E - 0045

>>> s = '\u004f\u0052\u0041\u0043\u004c\u0045'
>>> s
'ORACLE'
>>>

Символы UNICODE  4-x  байтовые (32 - битные):

 >>> s = '\U0000004f\U00000052\U00000041\U00000043\U0000004c\U00000045'
>>> s
'ORACLE'
>>>


Кодирование - процесс преобразования строки символов в последовательность простых байтов в соответствии с желаемой кодировкой.

Декодирование - процесс преобразования последовательности байтов в строку символов в соответствии с желаемой кодировкой.


Пример кодирования:

Преобразуем объект типа str (последовательность символов unicode) в объект типа bytes (последовательность байтов, т.е. коротких целых чисел)

>>> s = 'Java'
>>> s.encode()
b'Java'
>>>

Фактически объекты типа bytes, возвращаемые данной операцией кодирования строки символов, в действительности являются последовательностью коротких целых чисел, которые просто выводятся как символы ASCII, когда это возможно.

Так как мы не указали желаемой кодировки, то наши символы были преобразованы в последовательность простых байтов в соответствии с кодировкой по умолчанию:

>>> import sys
>>> sys.platform
'win32'
>>>
>>> sys.getdefaultencoding()
'utf-8'
>>>

А вообще функцию str.encode() следует вызывать явно указывая кодировку:

s.encode('utf-8')


Пример декодирования:

Существует и обратная функция, которая преобразует последовательность простых байтов в строку и на основе объекта типа bytes создает объект типа str.

>>> b = b'Java'
>>> b.decode()
'Java'
>>>

Тут также, если кодировка не указана, то используется по умолчанию.


Существуют еще две функции кодирования и декодирования:

Кодирование:
Функция    bytes(s, encoding)

Декодирование:
Функция    str(b, encoding)

в этих функциях параметр encoding является обязательным.

Первая функция вообще выдаст ошибку, если не указать параметр encoding:

>>> s = 'Java'

>>> bytes(s)
Traceback (most recent call last):
  File "", line 1, in
    bytes(s)
TypeError: string argument without an encoding
>>>

А вторая сработает, но вернет вместо объекта str  строковую форму объекта bytes (это не то, что требуется):

>>> b = b'Java'
>>> str(b)
"b'Java'"
>>>

Используйте эти две функции всегда с параметром encoding:

>>> s = 'Java'
>>> bytes(s, encoding='ascii')
b'Java'
>>>


>>> b = b'Java'
>>> str(b, encoding='ascii')
'Java'
>>>


Еще примеры:

>>> s = 'ORACLE'
>>> s.encode('ascii')
b'ORACLE'
>>>

>>> s.encode('latin-1')
b'ORACLE'
>>>

>>> s.encode('utf-8')
b'ORACLE'
>>>

Объекты типа bytes, в действительности являются последовательностью коротких целых чисел, которые выводятся как символы  ASCII, когда это возможно:

>>> s = 'ORACLE'
>>> s.encode('latin-1')[0]
79
>>>

>>> list(s.encode('latin-1'))
[79, 82, 65, 67, 76, 69]
>>>


Рассмотрим еще несколько примеров:

Кодировка по умолчанию у нас utf-8

Рассмотрим строковый символ 'O'

Его ASCII представление : '\x4f'
Его unicode представление : '\u004f'   или  '\U0000004f'

Данный символ в кодировке по умолчанию (utf-8) будет иметь код в виде байта с целочисленным значением:

>>> ord('O')
79
>>> ord('\x4f')
79
>>> ord('\u004f')
79
>>> ord('\U0000004f')
79
>>>

Как видим, неважно в каком представлении мы передали строковый символ функции ord().
Его код в кодировке utf-8 имеет одно значение.

При декодировании данного байта кода, используя кодировку по умолчанию (utf-8) мы получим представление символа которому соответствует этот код:

>>> chr(79)
'O'
>>>


Еще примеры:

Возьмем любой символ ASCII

>>> s = 'G'
>>>

Его байтовое представление находим так:

>>> s = 'G'

>>> ord(s)
71

>>> hex(71)
'0x47'
>>>

Значит его можно представить:

>>> s = '\x47'
>>> s
'G'
>>> s = '\u0047'
>>> s
'G'
>>> s = '\U00000047'
>>> s
'G'
>>>
>>> s.encode('utf-8')
b'G'
>>>
>>> b = b'G'
>>>
>>> list(b)
[71]
>>>
>>> b.decode('utf-8')
'G'
>>>


Возьмем не ASCII символ:

>>> s = 'Ä'
>>>


Его байтовое представление находим так:

>>> ord(s)
196
>>> hex(196)
'0xc4'
>>>


Значит его можно представить:

>>> s = '\xc4'
>>> s
'Ä'
>>>
>>> s = '\u00c4'
>>> s
'Ä'
>>>
>>> s = '\U000000c4'
>>> s
'Ä'
>>>
>>> s.encode('utf-8')
b'\xc3\x84'
>>>
>>> b = b'\xc3\x84'
>>>
>>> list(b)
[195, 132]
>>>
>>> b.decode('utf-8')
'Ä'
>>>


Возьмем символ  '茶'  (этот символ в китае  означает слово чай)

>>> s = '茶'
>>>
>>> ord(s)
33590
>>> hex(33590)
'0x8336'
>>>

В однобайтовом виде его уже не представить

>>> s = '\u8336'
>>> s
'茶'
>>>
>>> s = '\U00008336'
>>> s
'茶'
>>>
>>> s.encode('utf-8')
b'\xe8\x8c\xb6'
>>>
>>> b = b'\xe8\x8c\xb6'
>>>
>>> list(b)
[232, 140, 182]
>>>
>>> b.decode('utf-8')
'茶'
>>>

Любая строка хранится в памяти компьютера в виде последовательности символов, однако эти символы могут представляться различными способами, в зависимости от того, какой набор символов используется.

Набор символов ASCII - это символы с кодами в диапазоне  от 0 до 127.
(Что позволяет сохранять каждый символ в одном 8-битовом байте, в котором фактически используется только 7 младших байтов)

Некоторые стандарты позволяют использовать все возможные значения 8-битных байтов от 0 до 255, чтобы обеспечить возможность представления специальных символов, отображая их в диапазоне значений от 128 до 255 (за пределами диапазона ASCII).

Один из таких стандартов, известный под названием Latin-1, широко  используется в западной европе.

В некоторых алфавитах так много символов, что нет никакой возможности представить каждый из них одним байтом.

Стандарт Unicode обеспечивает более гибкие возможности.
Каждый символ в строке Unicode может быть представлен несколькими байтами.

Чтобы хранить текст строки Unicode в памяти компьютера, его необходимо транслировать в последовательность простых байтов и обратно, используя определенную кодировку.

Для некоторых кодировок процесс преобразования тривиально прост:

в  кодировках ASCII и Latin-1, например, каждому символу соответствует единственный байт, поэтому фактически никакого преобразования не требуется.

Для других кодировок процедура отображения может оказаться намного сложнее и порождать по несколько байтов для каждого символа.

Кодировка UTF-8 позволяет представить широкий диапазон символов, используя схему с переменным числом байтов.

Символы с кодами в диапазоне от 128 до 2047  преобразуются в двухбайтовые последовательности, где каждый байт имеет значение от 128 до 255.

Символы с кодами выше 2047 преобразуются в трех или четырехбайтовые последовательности, где каждый байт имеет значение от 128 до 255.

Строки с символами ASCII остаются компактными.
Набор ASCII является подмножеством обеих кодировок, Latin-1 и UTF-8.

Все текстовые файлы, состоящие из символов ASCII, будут считаться допустимыми текстовыми файлами с точки зрения кодировки UTF-8, потому что ASCII - это подмножество 7-битных символов в кодировке UTF-8.


С точки зрения программиста на языке Python, кодировки определяются как строки, содержащие названия кодировок.

Язык Python поддерживает примерно 100 различных кодировок.
Полный список можно посмотреть так:

>>> import encodings

>>> help(encodings)

...........................................
...........................................

PACKAGE CONTENTS
    aliases
    ascii
    base64_codec
    big5
    big5hkscs
    bz2_codec
    charmap
    cp037
    cp1006
    cp1026
    cp1140
    cp1250
    cp1251
    cp1252
    cp1253
    cp1254
    cp1255
    cp1256
    cp1257
    cp1258
    cp424
    cp437
    cp500
    cp720
    cp737
    cp775
    cp850
    cp852
    cp855
    cp856
    cp857
    cp858
    cp860
    cp861
    cp862
    cp863
    cp864
    cp865
    cp866
    cp869
    cp874
    cp875
    cp932
    cp949
    cp950
    euc_jis_2004
    euc_jisx0213
    euc_jp
    euc_kr
    gb18030
    gb2312
    gbk
    hex_codec
    hp_roman8
    hz
    idna
    iso2022_jp
    iso2022_jp_1
    iso2022_jp_2
    iso2022_jp_2004
    iso2022_jp_3
    iso2022_jp_ext
    iso2022_kr
    iso8859_1
    iso8859_10
    iso8859_11
    iso8859_13
    iso8859_14
    iso8859_15
    iso8859_16
    iso8859_2
    iso8859_3
    iso8859_4
    iso8859_5
    iso8859_6
    iso8859_7
    iso8859_8
    iso8859_9
    johab
    koi8_r
    koi8_u
    latin_1
    mac_arabic
    mac_centeuro
    mac_croatian
    mac_cyrillic
    mac_farsi
    mac_greek
    mac_iceland
    mac_latin2
    mac_roman
    mac_romanian
    mac_turkish
    mbcs
    palmos
    ptcp154
    punycode
    quopri_codec
    raw_unicode_escape
    rot_13
    shift_jis
    shift_jis_2004
    shift_jisx0213
    tis_620
    undefined
    unicode_escape
    unicode_internal
    utf_16
    utf_16_be
    utf_16_le
    utf_32
    utf_32_be
    utf_32_le
    utf_7
    utf_8
    utf_8_sig
    uu_codec
    zlib_codec

Строки в Python

Строка - последовательность символов Unicode

Символ - строка, имеющая длину 1


"Строка символов"
'Еще одна строка символов !!!'
''  # Пустая строка

Доступ к элементам строки

>>> "Строка символов"
'Строка символов'

>>> "Строка символов"[5]
'а'

>>> "Строка символов"[8]
'и'

>>> "Строка символов"[0]
'С'
>>>

Индексы в Python начинаются с нуля
Символы можно только извлекать, но не изменять их.


Строку, содержащую только символы целых чисел, можно преобразовать в целое число.

>>> int("73475690")
73475690
>>>

причем начальные и конечные пробелы допускаются

>>> int("   73475690 ")
73475690
>>>

Проверим, что тип действительно int

>>> print (int("   73475690 "), type(int("   73475690 ")))
73475690 < class 'int '>
>>>

Преобразовать число в строку можно так:

>>> str(26540978)
'26540978'
>>>

Проверим, что тип действительно str

>>> print (str(26540978), type(str(26540978)))
26540978 < class 'str' >
>>>

Можно создать объект типа str в памяти и затем создать ссылку на на этот объект.
Например создадим объект типа str с текстом "python" и затем создадим на этот объект ссылку с именем a.

>>> a = "python"
>>> a
'python'
>>>

оператор "=" связывает ссылку на объект с объектом находящимся в памяти

Если ссылка на объект уже существует, ее легко можно связать с другим объектом:

>>> a = "jython"
>>> a
'jython'
>>>

Теперь ссылка с именем a ссылается на объект типа str с текстом "jython"

А на строку  "python" теперь ни одна ссылка не ссылается
и интерпретатор сможет утилизировать объект содержащий эту строку "сборщиком мусора".

Еще пример:

>>> a = "python"
>>> b = "jython"
>>> c = a
>>> print (a, b, c)
python jython python
>>> c = b
>>> print (a, b, c)
python jython jython
>>> a = c
>>> print (a, b, c)
jython jython jython
>>>

Теперь ни одна ссылка не ссылается на строку "python",
интерпретатор сможет утилизировать объект содержащий эту строку.

Как мы уже видели, в интерактивной оболочке достаточно просто ввести имя ссылки на объект,
чтобы интерпретатор вывел значение связанного с ней объекта.

>>> a, b, c
('jython', 'jython', 'jython')
>>>

Python вывел значения в круглых скобках, разделив их запятыми
Так обозначается тип данных tuple (кортеж), т.е. упорядоченная,
неизменяемая последовательность объектов.
Однако, чтобы вывести значение объекта по связанной с ним ссылке из программы или модуля
следует использовать функцию print()


В Python используется динамический контроль типов, т.е. ссылки на объекты в любой момент могут
повторно привязываться к различным объектам
(которые могут относиться к данным различных типов)

Имена ссылок - это идентификаторы
Они
- не могут совпадать с ключевыми словами.
- должны начинаться с алфавитного символа или символа подчеркивания,
  за которым следует ноль или более алфавитных символов, символов подчеркивания или цифр.
Ограничений на длину не накладывается.
Идентификаторы чувствительны к регистру.

Строки в Python - это неизменяемый тип данных str, который хранит последоватедьность символов Unicode.

Строковые объекты создаются :

- при вызове функций str() или bytes()
- при манипуляции объектом типа файл созданным вызовом функции open()
- при определении строкового литерала (в одинарных, двойных или тройных кавычках)

Для создания строковых объектов можно использовать функцию  str(),
которая без аргументов возвращает пустую строку:

>>> str()
''
>>> 

С аргументом, который является строкой - возвращается его копия :

>>> str("Oracle Java!")
'Oracle Java!'
>>>

С аргументом, который не является строкой - возвращается строковое представление аргумента :

>>> str(3.1415)
'3.1415'
>>> 

Функция str() может также использоваться как функция преобразования.
В этом случае первый аргумент должен быть объектом, который можно преобразовать в строку (например типа bytes  или bytearray)  и кроме того функции может быть передано до двух необязятельных строковых аргументов:

- один из них определяет используемую кодировку
- второй определяет порядок обработки ошибок кодирования

>>> s="Häuser Höfe Bücher"

>>> bytes(s, encoding='latin-1')
b'H\xe4user H\xf6fe B\xfccher'
 
>>> 'H\xe4user H\xf6fe B\xfccher'
'Häuser Höfe Bücher'
 
>>> str(b'H\xe4user H\xf6fe B\xfccher')
"b'H\\xe4user H\\xf6fe B\\xfccher'"
 
>>> str(b'H\xe4user H\xf6fe B\xfccher', "latin-1")
'Häuser Höfe Bücher'
 
>>> str(b'H\xe4user H\xf6fe B\xfccher', "ascii")
Traceback (most recent call last):
  File "", line 1, in
    str(b'H\xe4user H\xf6fe B\xfccher', "ascii")
UnicodeDecodeError: 'ascii' codec can't decode byte 0xe4 in position 1: ordinal not in range(128)
 
>>> str(b'H\xe4user H\xf6fe B\xfccher', "ascii", "ignore")
'Huser Hfe Bcher'
 
>>> str(b'H\xe4user H\xf6fe B\xfccher', "ascii", "replace")
'H�user H�fe B�cher'
>>>

Литералы строк создаются с использованием кавычек или апострофов, при использовании важно, чтобы с обоих концов литерала использовались кавычки одного и того же типа.

Можно использовать строки в тройных кавычках либо в тройных апострофах.
Когда используется такая форма, все строки в программном коде объединяются в одну строку, а там, где в исходном тексте выполняется переход на новую строку, вставляется символ "конец строки".  Это весьма полезно для оформления в сценариях Python крупных блоков текста:

>>> msg = """ строка текста
еще строка текста в "кавычках" и 'апострофах'
продолжение на следующей строке """
>>>
>>> msg
' строка текста\nеще строка текста в "кавычках" и \'апострофах\'\nпродолжение на следующей строке '
>>>


>>> a = "Здесь 'апострофы' можно не экранировать, а "кавычки" нужно экранировать."
SyntaxError: invalid syntax

>>> a = "Здесь 'апострофы' можно не экранировать, а \"кавычки\" нужно экранировать."

>>> a
'Здесь \'апострофы\' можно не экранировать, а "кавычки" нужно экранировать.'
>>>


>>> a = 'Здесь 'апострофы' придется экранировать, а "кавычки" можно не экранировать.'
SyntaxError: invalid syntax
 
>>> a = 'Здесь \'апострофы\' придется экранировать, а "кавычки" можно не экранировать.'
 
>>> a
'Здесь \'апострофы\' придется экранировать, а "кавычки" можно не экранировать.'
>>>


В языке Python символ перевода строки интерпретируется как завершающий символ инструкции, но
- не внутри круглых скобок  ( )
- не внутри квадратных скобок  [ ]
- не внутри фигурных скобок  { }
- не внутри тройных кавычек  """   """

В тройных кавычках символ перевода строки можно даже экранировать :

>>> s = """ aaaaaaaaaaa\
bbbbbbbbbbbbbbbbbbbbbbb
ccccccccccccc """
>>> s
' aaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbb\nccccccccccccc '
>>>

Первый перевод строки экранирован, в итоге вместо трех мы получили две строки.

Мы можем вллючать символы перевода строки в любые строковые литералы с помощью экранированной последовательности \n.

 >>> s = "Строка\nНовая строка"
 
>>> s
'Строка\nНовая строка'
 
>>> print(s)
Строка
Новая строка
>>>


В языке Python допустимы следующие экранированные последовательности:


\перевод_строки    - экранирует(т.е. игнорирует) символ перевода строки

\\    - экранирует символ обратного слэша

\'     - экранирует символ апострофа

\"     - экранирует символ кавычки

\a     - символ ascii сигнал (bell, BEL)

\b     - символ ascii  забой (backspace, BS)

\f     - символ ascii  перевод формата (formfeed, FF)

\n     - символ ascii  перевод строки (linefeed, LF)

\N{название}     - символ Unicode с заданным названием

\000     - символ с заданным восьмеричным кодом (от \000 до \377)

\r     - символ ascii возврат каретки (carriage return, CR)

\t     - символ ascii табуляция (tab, TAB)

\v     - символ ascii  вертикальная табуляция (vertical tab, VT)

\uhhhh     - символ Unicode с указанным 16-битным шестнадцатеричным значением.

\Uhhhhhhhh     - символ Unicode с указанным 32-битным шестнадцатеричным значением.

\xhh     -  символ c  указанным 8-битным шестнадцатеричным значением.



В некоторых ситуациях, например,  при записи регулярных выражений, приходится создавать строки с большим количеством символов обратного слэша.
Это может вызывать определенные неудобства, т.к. каждый такой символ придется экранировать:

>>> import re
>>> phone1 = re.compile("^((?:[(]\\d+[)])?\\s*\\d+(?:-\\d+)&)$")
>>>

Решить эту проблему можно используя "сырые" (raw) строки.
Это обычные строки в кавычках или тройных кавычках, в которые перед первой кавычкой добавлен символ r.

Внутри таких строк все символы интерпретируются как обычные символы, поэтому отпадает необходимость экранировать символы, которые в других типах строк имеют специальное значение.

>>> phone2 = re.compile(r"^((?:[(]\d+[)])?\s*\d+(?:-\d+)&)$")
>>>

Если потребуется записать длинный строковый литерал, занимающий две или более строк, но без использования тройных кавычек, то можно конкатенировать строки с экранированием символа перевода строки:

>>> m = "это длинный строковый литерал, который занимает" +\
    " вторую строку" +\
    " и даже третью"
>>> m
'это длинный строковый литерал, который занимает вторую строку и даже третью'
>>>

Но более приятный способ с использованием круглых скобок :

>>> m = ("это длинный строковый литерал, который занимает"
     " вторую строку"
     " и даже третью")
>>> m
'это длинный строковый литерал, который занимает вторую строку и даже третью'
>>>

Миграция на ASM:

$export ORACLE_SID=SID
$sqlplus / as sysdba

SQL> select name from v$controlfile;

NAME
--------------------------------------------------------------------------------
/app/oracle/oradata/SID/control1/control01.ctl
/app/oracle/oradata/SID/control2/control02.ctl


SQL> alter system set control_files='+DATA','+DATA' scope=spfile;
SQL> alter system set db_create_file_dest='+DATA' scope=spfile;

SQL> shutdown immediate;
SQL> startup nomount;
SQL> exit

$rman target /

RMAN> restore controlfile from '/app/oracle/oradata/SID/control1/control01.ctl';

RMAN> alter database mount;

RMAN> backup as copy database format '+DATA';

RMAN> switch database to copy;

RMAN> recover database;

RMAN> exit


$export ORACLE_SID=SID
$sqlplus / as sysdba

SQL> alter database open;

SQL> CREATE TEMPORARY TABLESPACE "TEMP1" TEMPFILE SIZE 61865984 AUTOEXTEND ON NEXT 655360 MAXSIZE 32767M EXTENT MANAGEMENT LOCAL UNIFORM SIZE 1048576;
SQL> ALTER DATABASE DEFAULT TEMPORARY TABLESPACE "TEMP1";

SQL> shutdown immediate;
SQL> startup;

SQL> DROP TABLESPACE TEMP;
SQL> CREATE TEMPORARY TABLESPACE "TEMP" TEMPFILE SIZE 61865984 AUTOEXTEND ON NEXT 655360 MAXSIZE 32767M EXTENT MANAGEMENT LOCAL UNIFORM SIZE 1048576;
SQL> ALTER DATABASE DEFAULT TEMPORARY TABLESPACE "TEMP";

SQL> shutdown immediate;
SQL> startup

SQL> DROP TABLESPACE TEMP1;

Или просто добавить временный файл в существующее табличное пространство:

SQL> ALTER TABLESPACE "TEMP" ADD TEMPFILE SIZE 500M AUTOEXTEND ON NEXT 655360 MAXSIZE 32767M;

Tablespace altered.
SQL>


SQL>SQL> alter system set db_create_online_log_dest_1='+REDO' scope=spfile;

SQL> shutdown immediate;
SQL> startup;

SQL> select member from v$logfile;

MEMBER
--------------------------------------------------------------------------------
/app/oracle/oradata/SID/redoa/redo06a.log
/app/oracle/oradata/SID/redoa/redo05a.log
/app/oracle/oradata/SID/redoa/redo04a.log
/app/oracle/oradata/SID/redoa/redo03a.log
/app/oracle/oradata/SID/redoa/redo02a.log
/app/oracle/oradata/SID/redoa/redo01a.log

6 rows selected.

SQL> alter database drop logfile group 1;
SQL> alter database add logfile group 1 size 52428800;

SQL> alter database drop logfile group 2;
SQL> alter database add logfile group 2 size 52428800;

SQL> alter database drop logfile group 3;
alter database drop logfile group 3
*
ERROR at line 1:
ORA-01623: log 3 is current log for instance SID (thread 1) - cannot drop
ORA-00312: online log 3 thread 1: '/app/oracle/oradata/SID/redoa/redo03a.log'


SQL> alter database drop logfile group 4;
SQL> alter database add logfile group 4 size 52428800;

SQL> alter database drop logfile group 5;
SQL> alter database add logfile group 5 size 52428800;

SQL> alter database drop logfile group 6;
SQL> alter database add logfile group 6 size 52428800;

SQL> alter system switch logfile;
SQL> alter system checkpoint;

SQL> alter database drop logfile group 3;
SQL> alter database add logfile group 3 size 52428800;

SQL> select name from v$datafile;

NAME
--------------------------------------------------------------------------------
+DATA/SID/datafile/system.270.789045335
+DATA/SID/datafile/undotbs1.269.789045319
+DATA/SID/datafile/sysaux.268.789045295
+DATA/SID/datafile/users.271.789045349

SQL> select name from v$tempfile;

NAME
--------------------------------------------------------------------------------
+DATA/SID/tempfile/temp.275.789045723

SQL> select name from v$controlfile;

NAME
--------------------------------------------------------------------------------
+DATA/SID/controlfile/current.266.789045265
+DATA/SID/controlfile/current.267.789045265

SQL> select member from v$logfile;

MEMBER
--------------------------------------------------------------------------------
+REDO/SID/onlinelog/group_1.274.789046953
+REDO/SID/onlinelog/group_2.276.789046981
+REDO/SID/onlinelog/group_4.277.789047043
+REDO/SID/onlinelog/group_5.278.789047061
+REDO/SID/onlinelog/group_3.279.789047111
+REDO/SID/onlinelog/group_6.280.789047303

6 rows selected.

SQL>