oracle - scielo - distonía ocupacional

¿Puedes SELECCIONAR todo, pero 1 o 2 campos, sin calambre del escritor?

Question

¿Es posible, en PLSQL, seleccionar todos los campos en una tabla a excepción de 1 o 2, sin tener que especificar los campos que desea?

Ejemplo, la tabla de empleados tiene los campos:

• carné de identidad
• nombre de pila
• apellido
• aficiones

¿Todavía es posible escribir una consulta similar a

select * from employee

mientras dejas los hobbies del campo sin tener que escribir algo como esto?

select id, firstname, lastname from employee

Answer 1

¿Estás corriendo en Oracle 12c?

De ser así, considere si esto satisface sus necesidades:

alter table mytable modify column undesired_col_name INVISIBLE;

En ese caso, la columna undesired_col_name será completamente utilizable, pero se excluirá de cualquier SELECT * y similares (por ejemplo, %ROWTYPE ) como si no existiera.

Answer 2

Aquí hay otra opción para obtener una lista de los campos que le permiten especificar el delimitador:

select listagg(column_name, '', '') WITHIN GROUP (ORDER BY rownum)
from all_tab_columns
where table_name=''table''

Answer 3

Lo que el OP estaba buscando era algo así como:

SELECT * MINUS hobbies from...

Lo mejor que puede hacer para evitar escribir mucho (y obtener todos los nombres de las columnas correctos) es abrir la descripción de la tabla y cortar y pegar todos los nombres de las columnas y eliminar las que no desea, separe las restantes y ponlos en una o dos líneas.

Es fácil, rápido, preciso y no confundirá a la siguiente persona que tenga que trabajar en su código.

Answer 4

No, o bien obtienes todos los campos ( * ) O especificas los campos que deseas .

Answer 5

Si desea evitar el calambre del escritor, puede usar SQL Developer y hacer que genere la lista de columnas para usted:

select column_name||'',''
from all_tab_columns
where table_name = ''YourTableName''

Y luego solo saca la una o dos columnas que no quieres.

También puedes usar

SELECT WM_CONCAT(column_name)
FROM all_tab_columns
WHERE table_name = ''table_name''
GROUP BY table_name;

Answer 6

Un hilo viejo pero, sí ... hay una forma de hacerlo en Oracle:

with
employee(id, firstname, lastname, hobbies) as
(
select 1, ''a'', ''b'', ''1'' from dual union
select 2, ''a'', ''b'', ''2'' from dual union
select 3, ''a'', ''b'', ''3'' from dual union
select 4, ''c'', ''d'', ''3'' from dual union
select 5, ''e'', ''f'', ''2'' from dual
)
select *
from employee
pivot
(
max(1) -- fake
for (hobbies) -- put the undesired columns here
IN () -- no values here...
)
where 1=1 -- and your filters here...
order by id

Para entender cómo funciona PIVOT y por qué soluciona la pregunta, tomemos un mejor ejemplo para nuestra tabla de muestra de employee :

select *
from employee
pivot
(
max(id) foo,
max(1) bar
for (hobbies)
IN (''2'' as two, ''3'' as three)
)

El resultado aquí es:

FIRSTNAME | LASTNAME | TWO_FOO | TWO_BAR | THREE_FOO | THREE_BAR c d null null 4 1 e f 5 1 null null a b 2 1 3 1

El mismo resultado exacto se puede lograr usando esta consulta más fácil de entender:

select
firstname,
lastname,
max(case when hobbies = ''2'' then id end) two_foo,
max(case when hobbies = ''2'' then 1 end) two_bar,
max(case when hobbies = ''3'' then id end) three_foo,
max(case when hobbies = ''3'' then 1 end) three_bar
from employee
group by
firstname,
lastname

Por lo tanto, los hobbies columna nunca se seleccionan, al igual que la columna id , ambos especificados dentro de la cláusula PIVOT . Todas las otras columnas están agrupadas y seleccionadas.

Bueno, volviendo a la primera consulta, funciona por dos razones:
1- No perderá ninguna fila en el proceso de agrupación porque la columna de identificación es única y no se han especificado columnas para las agregaciones;
2- como el pivote genera N * M nuevas columnas, donde N = número de valores de la cláusula IN y M = número de agregaciones especificadas, por lo que al no tener filtros y esa única agregación inocua producirá 0 * 1 = 0 columnas nuevas y elimine los especificados en la cláusula PIVOT , que son solo los pasatiempos .

RESPUESTA AL COMENTARIO 1

La primera línea de esta pregunta dice: "... sin tener que especificar los campos que desea" . En todas las otras respuestas, las consultas propuestas especifican los campos deseados en la cláusula SELECT , excepto en la mía, en realidad.

Además, en el título de la pregunta dice "... sin calambre de escritor" . Bueno, ¿cuál es la medida correcta para identificar el calambre de un escritor? Mi mejor esfuerzo sería prever un buen estándar SQL para este problema y compararlo con mi respuesta. En realidad, creo que este "estándar" podría ser algo como SELECT * NOT IN ([col1], [col2], ...) .

Ahora puedo ver en ambas consultas:

• una lista de columnas no deseadas;
• una cláusula IN ;
• una cláusula de tres caracteres: FOR y NOT ;

Significa que necesitas escribir un poco más en mi enfoque ya que necesitas una agregación falsa y la cláusula PIVOT ... pero son realmente pocos los personajes más ...

Answer 7

aquí están las soluciones ... Necesito todas las columnas excepto la contraseña

(seleccione column_name || '','' from user_tab_columns donde table_name = ''USUARIOS'' y column_name <> ''PASSWORD'')

Answer 8

para crear vista: -

create view view_name como select id, first_name, last_name del empleado donde id in ('''', '''', '''')

Nota: - Esto es como una tabla virtual en su base de datos, pero puede afectar los valores en la tabla actual.

Answer 9

query_generator es una función PL / SQL que devuelve una cadena de selección para una tabla (primer parámetro) pero excluyendo algunas columnas (segundo parámetro).

stringlist y putil.join son de PL / SQL Commons .

stringlist es una lista simple de cadenas: create type StringList as table of varchar2(32767); y putil.join es solo una función de unión normal.

create or replace function quote_list(p_list in stringlist)
return stringlist as
v_list stringlist := stringlist();
begin
v_list.extend(p_list.last);
for i in p_list.first .. p_list.last loop
v_list(i) := '''''''' || p_list(i) || '''''''';
end loop;
return v_list;
end;
/
show errors
create or replace function query_generator(
p_table in varchar2,
p_exclude in stringlist
) return varchar2 as
v_table constant varchar2(31) := upper(p_table);
v_exclude constant varchar2(32676) :=
upper(putil.join(quote_list(p_exclude), '',''));
v_stmt_str constant varchar2(32676) :=
''select column_name from all_tab_columns where table_name = '''''' ||
v_table || '''''' and column_name not in ('' || v_exclude ||
'') order by column_id'';
type stmt_cur_t is ref cursor;
v_stmt_cur stmt_cur_t;
v_column_name varchar2(31);
v_query varchar2(32676) := ''select '';
begin
open v_stmt_cur for v_stmt_str;
loop
fetch v_stmt_cur into v_column_name;
exit when v_stmt_cur%notfound;
v_query := v_query || lower(v_column_name) || '', '';
end loop;
close v_stmt_cur;
select rtrim(v_query, '', '') into v_query from dual;
v_query := v_query || '' from '' || p_table || '';'';
return v_query;
end;
/
show errors

Ejemplo de uso:

exec dbms_output.put_line(query_generator(''all_tables'', stringlist(''segment_created'', ''result_cache'')))

Answer 10

WITH O AS
(
SELECT ''SELECT '' || rtrim(''NULL AS "Dummy",'' || LISTAGG(''"''||column_name || ''"'', '','' ) within group (ORDER BY COLUMN_NAME),'','')|| '' FROM "''||TABLE_NAME||''"'' AS SQL, TABLE_NAME FROM USER_TAB_COLUMNS GROUP BY (TABLE_NAME)
)
SELECT DBMS_XMLGEN.GETXMLTYPE ((SELECT REPLACE(SQL,'',COLUMNNAME'','''') FROM O WHERE TABLE_NAME = ''TABLENAME'')) FROM DUAL