SQL> col FILE_NAME form A40;
SQL> select FILE_NAME, TABLESPACE_NAME from dba_data_files UNION select FILE_NAME, TABLESPACE_NAME from dba_temp_files;

FILE_NAME				 TABLESPACE_NAME
---------------------------------------- ------------------------------
/opt/oracle/oradata/orcl/sysaux01.dbf	 SYSAUX
/opt/oracle/oradata/orcl/system01.dbf	 SYSTEM
/opt/oracle/oradata/orcl/temp01.dbf	 TEMP
/opt/oracle/oradata/orcl/undotbs01.dbf	 UNDOTBS1
/opt/oracle/oradata/orcl/users01.dbf	 USERS

select max(CHECKPOINT_TIME) from v$datafile;

MAX(CHEC
--------
24/01/20

SQL> create tablespace ts1
  2  datafile 'ts1.dbf'
  3  size 2M
  4  autoextend on;

Tablespace creado.

select distinct bytes/blocks from user_segments;

BYTES/BLOCKS
------------
	8192

ALTER SYSTEM SET DB_16k_CACHE_SIZE=100M;

shutdown inmediate;
startup
create tablespace prueba datafile '/home/oracle/test.img' size 1M blocksize 16K;

SQL> select tablespace_name, block_size from dba_tablespaces where tablespace_name='PRUEBA';

TABLESPACE_NAME 	       BLOCK_SIZE
------------------------------ ----------
PRUEBA				    16384

create or replace procedure MostrarObjetosdeUsuarioenTS(p_tsname VARCHAR2,
							p_user VARCHAR2)
is

	cursor c_userobjectsTS
	is
	select segment_name object, bytes
	from dba_segments
	where tablespace_name=p_tsname
	and owner=p_user;

begin
	dbms_output.put_line('OBJETOS USUARIO '||p_user||chr(9)||'TAMAÑO (BYTES)');
	for i in c_userobjectsTS loop
		dbms_output.put_line(i.object||chr(9)||chr(9)||i.bytes);
	end loop;
end;
/

SQL> exec MostrarObjetosdeUsuarioenTS('USERS','LUIS');
OBJETOS USUARIO LUIS	TAMAÑO (BYTES)
OPERACIONES		65536
CLINICAS		65536
CLIENTES		65536
ANIMALES		65536
VACUNAS			65536
VIRUS			65536
VETERINARIOS		65536
VACUNACIONES		65536
SALAS			65536
QUIROFANOS		65536
CITASPOSIBLES		65536
CITASPREVIAS		65536
PK_OPERACION		65536
PK_CLINICA		65536
PK_DNI			65536
PK_ANIMAL		65536
PK_VACUNA		65536
PK_VIRUS		65536
PK_VETERINARIO		65536
PK_VACUNAS		65536
PK_SALA_CLINICA		65536
PK_QUIROFANO		65536
PK_CITA			65536
PK_CITAS		65536
SYS_C007423		65536

Procedimiento PL/SQL terminado correctamente.

create or replace procedure MostrarUsrsCuotaIlimitada
is
	cursor c_UsuarioSinCuota
	is
	select username nombre
	from DBA_TS_QUOTAS
	where max_blocks = -1
	and max_bytes = -1
	and tablespace_name in (select tablespace_name
				  from DBA_DATA_FILES
				  where substr(file_name,1,12) = '/home/oracle')
	group by username
	having count(tablespace_name) > 1
	UNION
	select grantee nombre
	from DBA_SYS_PRIVS
	where privilege = 'UNLIMITED TABLESPACE';

begin
	dbms_output.put_line('Usuarios con cuota ilimitada');
	for usuario in c_UsuarioSinCuota loop
		dbms_output.put_line(usuario.nombre);
	end loop;
end;
/

CREATE [TEMPORARY|UNDO] TABLESPACE nombrets
[DATAFILE|TEMPFILE] ruta_absoluta_fichero [SIZE nº [K|M]][REUSE][AUTOEXTEND ON [MAXSIZE n M]]
… (podemos añadir más ficheros separando con comas)...
[LOGGING|NOLOGGING]
[PERMANENT|TEMPORARY]
[DEFAULT STORAGE
(clausulas de almacenamiento)]
[OFFLINE];

CREATE TABLESPACE tablespace_name
    [ OWNER { new_owner | CURRENT_USER | SESSION_USER } ]
    LOCATION 'directory'
    [ WITH ( tablespace_option = value [, ... ] ) ]

MariaDB [(none)]> help create table
...

table_options:
    table_option [[,] table_option] ...

table_option:
    ENGINE [=] engine_name
  | AUTO_INCREMENT [=] value
  | AVG_ROW_LENGTH [=] value
  | [DEFAULT] CHARACTER SET [=] charset_name
  | CHECKSUM [=] {0 | 1}
  | [DEFAULT] COLLATE [=] collation_name
  | COMMENT [=] 'string'
  | CONNECTION [=] 'connect_string'
  | DATA DIRECTORY [=] 'absolute path to directory'
  | DELAY_KEY_WRITE [=] {0 | 1}
  | INDEX DIRECTORY [=] 'absolute path to directory'
  | INSERT_METHOD [=] { NO | FIRST | LAST }
  | KEY_BLOCK_SIZE [=] value
  | MAX_ROWS [=] value
  | MIN_ROWS [=] value
  | PACK_KEYS [=] {0 | 1 | DEFAULT}
  | PASSWORD [=] 'string'
  | ROW_FORMAT [=] {DEFAULT|DYNAMIC|FIXED|COMPRESSED|REDUNDANT|COMPACT}
  | TABLESPACE tablespace_name [STORAGE {DISK|MEMORY|DEFAULT}]
  | UNION [=] (tbl_name[,tbl_name]...)

partition_options:
    PARTITION BY
        { [LINEAR] HASH(expr)
        | [LINEAR] KEY(column_list)
        | RANGE{(expr) | COLUMNS(column_list)}
        | LIST{(expr) | COLUMNS(column_list)} }
    [PARTITIONS num]
    [SUBPARTITION BY
        { [LINEAR] HASH(expr)
        | [LINEAR] KEY(column_list) }
      [SUBPARTITIONS num]
    ]
    [(partition_definition [, partition_definition] ...)]

partition_definition:
    PARTITION partition_name
        [VALUES 
            {LESS THAN {(expr | value_list) | MAXVALUE} 
            | 
            IN (value_list)}]
        [[STORAGE] ENGINE [=] engine_name]
        [COMMENT [=] 'comment_text' ]
        [DATA DIRECTORY [=] 'data_dir']
        [INDEX DIRECTORY [=] 'index_dir']
        [MAX_ROWS [=] max_number_of_rows]
        [MIN_ROWS [=] min_number_of_rows]
        [TABLESPACE [=] tablespace_name]
        [NODEGROUP [=] node_group_id]
        [(subpartition_definition [, subpartition_definition] ...)]

subpartition_definition:
    SUBPARTITION logical_name
        [[STORAGE] ENGINE [=] engine_name]
        [COMMENT [=] 'comment_text' ]
        [DATA DIRECTORY [=] 'data_dir']
        [INDEX DIRECTORY [=] 'index_dir']
        [MAX_ROWS [=] max_number_of_rows]
        [MIN_ROWS [=] min_number_of_rows]
        [TABLESPACE [=] tablespace_name]
        [NODEGROUP [=] node_group_id]
...

CREATE TABLESPACE tablespace_name

  InnoDB and NDB:
    ADD DATAFILE 'file_name'

  InnoDB only:
    [FILE_BLOCK_SIZE = value]

  NDB only:
    USE LOGFILE GROUP logfile_group
    [EXTENT_SIZE [=] extent_size]
    [INITIAL_SIZE [=] initial_size]
    [AUTOEXTEND_SIZE [=] autoextend_size]
    [MAX_SIZE [=] max_size]
    [NODEGROUP [=] nodegroup_id]
    [WAIT]
    [COMMENT [=] 'string']

  InnoDB and NDB:
    [ENGINE [=] engine_name]

db.alumnos.createIndex( { "nombre" : 1 } )

db.alumnos.createIndex( { "nombre" : 1, "nota": -1 } ) 

# Búsqueda del campo libro en orden ascendente y el
# autor en orden descendente

db.alumnos.createIndex( { "nota" : 1 }, {"unique":true} )

db.eventlog.createIndex( { "lastModifiedDate": 1 }, { expireAfterSeconds: 3600 } )

- Modificandolo

![](https://i.imgur.com/KZdmFWG.png)


- Creando de nuevo el tablespace

![](https://i.imgur.com/XY3c9kg.png)
  
**2. Crea dos tablas en el tablespace recién creado e inserta un registro en cada una de ellas. Comprueba el espacio libre existente en el tablespace. Borra una de las tablas y comprueba si ha aumentado el espacio disponible en el tablespace. Explica la razón.**

- Tablas que insertaré

![](https://i.imgur.com/kOVynIc.png)

- Comprobar el espacio libre

 BYTES ----------
786432 ```

SQL> DROP TABLE Categorias;

Tabla borrada.

SQL> ALTER TABLESPACE TS1 READ ONLY;

Tablespace modificado.

SQL> insert into Medicamentos(Codigo,NombreComercial,Laboratorio,FinanciadoSS,Ne
cesitaReceta)
  2  values ('EX4','NEXAVAR','BAYER AG','NO','SI');
insert into Medicamentos(Codigo,NombreComercial,Laboratorio,FinanciadoSS,Necesit
aReceta)
            *
ERROR en lÝnea 1:
ORA-00372: el archivo 8 no se puede modificar en este momento
ORA-01110: archivo de datos 8:
'C:\APP\ORACLE\PRODUCT\11.2.0\DBHOME_1\DATABASE\TS1.DBF'

SQL> DROP TABLE Medicamentos;

Tabla borrada.

- Insertar registros

- Llenar tablespace

![](https://i.imgur.com/0enmmHu.png)

> Nos da el error de que el tablespace esta lleno y al haber creado el tablespace sin autoextendido nos dice que no se ha podido ampliar

[Tabla insertada](https://www.tutorialesprogramacionya.com/oracleya/simulador/simulador.php?inicio=0&cod=173&punto=15)

**5. Hacer un procedimiento llamado MostrarUsuariosporTablespace que muestre por pantalla un listado de los tablespaces existentes con la lista de usuarios que tienen asignado cada uno de ellos por defecto y el número de los mismos, así:**

   Tablespace xxxx:

	Usr1
	Usr2
	...

   Total Usuarios Tablespace xxxx: n1
 
   Tablespace yyyy:

	Usr1
	Usr2
	...

   Total Usuarios Tablespace yyyy: n2
   ....
   Total Usuarios BD: nn

   No olvides incluir los tablespaces temporales y de undo.

**6. Realiza un procedimiento llamado MostrarDetallesIndices que reciba el nombre de una tabla y muestre los detalles sobre los índices que hay definidos sobre las columnas de la misma.**

       
## PostgreSQL
         
**7. Averigua si existe el concepto de segmento y el de extensión en Postgres, en qué consiste y las diferencias con los conceptos correspondientes de ORACLE.**

- En postgresql, un segmento es el archivo/s que se crean al crear un tablespace, con diferencia en Oracle es un grupo de bloques de disco.
       
## MySQL

**8. Averigua si existe el concepto de espacio de tablas en MySQL y las diferencias con los tablespaces de ORACLE.**

Mysql utiliza el sistema de almacenamiento mediante tablespaces. Motores de almacenamiento: InnoDB y NDB. Estos respecto a Oracle tienen más limitaciones en cuanto a la gestión de almacenamiento.

Vamos a ver la sintaxis a la hora de crear un tablespace, ya que tiene gran similitud a Oracle.

    - InnoDB:

- NDB:

Primero debemos crear un logfile, ya que es necesario para crear el tablespace.

`CREATE LOGFILE GROUP logfile_group;`


Ya podemos crear el tablespace. (Entre corchetes vamos a poner los parámetros opcionales)

La principal diferencia con Oracle se puede encontrar a la hora de asignarle una cuota de almacenamiento ya que con el motor InnoDB, no es posible.

Tampoco contamos con todas las cláusulas de almacenamiento, que si tenemos en Oracle.

> Esta información tambien se encuentra en nuestra grupal

## MongoDB

**9. Averigua si existe la posibilidad en MongoDB de decidir en qué archivo se almacena una colección.**

> No he encontrado ninguna documentación.

# Alumno 3 (Adrián Jaramillo Rodríguez):

## ORACLE

**0. Creación del tablespace TS2 hecho por el alumno 2**

* Creamos el tablespace TS2

![](https://i.imgur.com/lBmkylT.png)


* Crear la tabla donde insertaremos registros

* Los insertamos

> He repetido el añadido de registros tal y como hizo el alumno 2, hasta que se llenó el tablespace por completo (cosa que se requería hacer)




**1. Muestra los objetos a los que pertenecen las extensiones del tablespace TS2 (creado por Alumno 2) y el tamaño de cada una de ellas.**

**2. Borra la tabla que está llenando TS2 consiguiendo que vuelvan a existir extensiones libres. Añade después otro fichero de datos a TS2.**

Con `truncate table` se borra una tabla, y además se libera el espacio en disco

Añadir datafile a tablespace

**3. Crea el tablespace TS3 gestionado localmente con un tamaño de extensión uniforme de 128K y un fichero de datos asociado. Cambia la ubicación del fichero de datos y modifica la base de datos para que pueda acceder al mismo. Crea en TS3 dos tablas e inserta registros en las mismas. Comprueba que segmentos tiene TS3, qué extensiones tiene cada uno de ellos y en qué ficheros se encuentran.**

Crear tablespace

Mostrar los segmentos de un tablespace

Mostrar los extents que componen un segmento, junto con el fichero donde se encuentran

**4. Redimensiona los ficheros asociados a los tres tablespaces que has creado de forma que ocupen el mínimo espacio posible para alojar sus objetos.**

Para redimensionar un datafile:

Ejemplo:

**5. Realiza un procedimiento llamado InformeRestricciones que reciba el nombre de una tabla y muestre los nombres de las restricciones que tiene, a qué columna o columnas afectan y en qué consisten exactamente.**

**6. Realiza un procedimiento llamado MostrarAlmacenamientoUsuario que reciba el nombre de un usuario y devuelva el espacio que ocupan sus objetos agrupando por dispositivos y archivos:**

			Usuario: NombreUsuario

				Dispositivo:xxxx

					Archivo: xxxxxxx.xxx

							Tabla1......nnn K
							…
							TablaN......nnn K
							Indice1.....nnn K
							…
							IndiceN.....nnn K

					Total Espacio en Archivo xxxxxxx.xxx: nnnnn K

					Archivo:...
					…

			
				
				Total Espacio en Dispositivo xxxx: nnnnnn K

				Dispositivo: yyyy
				…

			Total Espacio Usuario en la BD: nnnnnnn K ```

CREATE UNDO TABLESPACE TS1 DATAFILE 'tablespace1.dbf' SIZE 100M AUTOEXTEND ON;
ALTER USER ERNESTO QUOTA UNLIMITED ON TS1

SQL> CREATE UNDO TABLESPACE TS1 DATAFILE 'tablespace1.dbf' SIZE 100M AUTOEXTEND ON;

Tablespace creado.

SQL> ALTER USER ERNESTO QUOTA UNLIMITED ON TS1;
ALTER USER ERNESTO QUOTA UNLIMITED ON TS1
*
ERROR en línea 1:
ORA-30041: No se puede otorgar cuota al tablespace

SQL> CREATE table tablaprueba
  2  (nombre varchar2(20))
  3  tablespace TS1;
CREATE table tablaprueba
*
ERROR en línea 1:
ORA-30022: No se pueden crear segmentos en un tablespace de deshacer

SQL> alter table clientes move tablespace TS1;
alter table clientes move tablespace TS1
            *
ERROR en línea 1:
ORA-30022: No se pueden crear segmentos en un tablespace de deshacer

CREATE TEMPORARY TABLESPACE TEMP2 TEMPFILE  'temp2.dbf' SIZE 100M;

SELECT 'ALTER USER ' || USERNAME || ' TEMPORARY TABLESPACE TEMP2;'
FROM DBA_USERS WHERE DEFAULT_TABLESPACE = 'USERS';

26-01-2020 14:14:54 SYS@XE SQL> CREATE TEMPORARY TABLESPACE TEMP2 TEMPFILE  'temp2.dbf' SIZE 100M;

Tablespace created.

26-01-2020 14:27:44 SYS@XE SQL> SELECT 'ALTER USER ' || USERNAME || ' TEMPORARY TABLESPACE TEMP2;'
  2  FROM DBA_USERS WHERE DEFAULT_TABLESPACE = 'USERS';

'ALTERUSER'||USERNAME||'TEMPORARYTABLESPACETEMP2;'
---------------------------------------------------------------------
ALTER USER HR TEMPORARY TABLESPACE TEMP2;
ALTER USER SCOTT TEMPORARY TABLESPACE TEMP2;

DROP TABLESPACE TS1 INCLUDING CONTENTS AND DATAFILES;
DROP TABLESPACE TEMP2 INCLUDING CONTENTS AND DATAFILES;

26-01-2020 14:27:48 SYS@XE SQL> DROP TABLESPACE TS1 INCLUDING CONTENTS AND DATAFILES;

Tablespace dropped.

26-01-2020 14:36:23 SYS@XE SQL> DROP TABLESPACE TEMP2 INCLUDING CONTENTS AND DATAFILES;

Tablespace dropped.

26-01-2020 14:36:27 SYS@XE SQL> SELECT SEGMENT_NAME,INITIAL_EXTENT FROM DBA_ROLLBACK_SEGS;

SEGMENT_NAME           INITIAL_EXTENT
------------------------------ --------------
SYSTEM                         114688
_SYSSMU1_3789641169$           131072
_SYSSMU2_1827203912$           131072
_SYSSMU3_3346129149$           131072
_SYSSMU4_655887589$            131072
_SYSSMU5_3703078872$           131072
_SYSSMU6_725569783$            131072
_SYSSMU7_3583332791$           131072
_SYSSMU8_4175076471$           131072
_SYSSMU9_1317495879$           131072
_SYSSMU10_2569484742$          131072

11 rows selected.

CREATE OR REPLACE PROCEDURE MostrarUsuariosAccesoTS(v_tablespace VARCHAR2)
is
  cursor c_acceso
  is
  SELECT table_name
  FROM dba_tables
  WHERE tablespace_name=v_tablespace;
BEGIN
  for i IN c_acceso loop
    objetos(i.table_name);
  END loop;
END;
/

CREATE OR REPLACE PROCEDURE objetos(v_nombretablas VARCHAR2)
is
  cursor c_objetos
  is
  SELECT DISTINCT grantee
  FROM dba_tab_privs
  WHERE table_name=v_nombretablas
  AND PRIVILEGE='SELECT' OR PRIVILEGE='INSERT' OR PRIVILEGE='DROP';
BEGIN
  for i IN c_objetos LOOP
    DBMS_OUTPUT.PUT_LINE('Avisa al usuario: '||i.grantee);
  END loop;
END;
/

CREATE OR REPLACE PROCEDURE MostrarPropietario(p_nombretabla VARCHAR2,
                                               p_Propietario VARCHAR2)
IS
BEGIN
    dbms_output.put_line('Propietario: '||p_Propietario);
END;
/

CREATE OR REPLACE PROCEDURE Mostrarusuarioslectura(p_nombretabla VARCHAR2,
                                                   p_Propietario VARCHAR2)
IS
    cursor c_usuarios is
    SELECT USERNAME
    FROM DBA_USERS 
    WHERE USERNAME IN (SELECT DISTINCT GRANTEE
                       FROM DBA_TAB_PRIVS
                       WHERE TABLE_NAME IN (SELECT TABLE_NAME
                                            FROM DBA_TABLES
                                            WHERE TABLE_NAME=p_nombretabla
                       						AND PRIVILEGE='SELECT'
                       						AND OWNER=p_Propietario));
BEGIN
    DBMS_OUTPUT.PUT_LINE(chr(9));
    DBMS_OUTPUT.PUT_LINE('Usuarios que pueden leer sus datos: ');
    for v_usuarios IN c_usuarios loop
		DBMS_OUTPUT.PUT_LINE(v_usuarios.USERNAME);
    END loop;
END;
/


CREATE OR REPLACE PROCEDURE MostartUsuariocambio(p_nombretabla VARCHAR2,
                                                 p_Propietario VARCHAR2)
IS
    cursor c_usuarios is
    SELECT USERNAME
    FROM DBA_USERS 
    WHERE USERNAME IN (SELECT DISTINCT GRANTEE
                       FROM DBA_TAB_PRIVS
                       WHERE TABLE_NAME IN (SELECT TABLE_NAME
                                            FROM DBA_TABLES
                                            WHERE TABLE_NAME=p_nombretabla
                        					AND (PRIVILEGE='INSERT' OR PRIVILEGE='UPDATE' OR PRIVILEGE='DELETE')
                        					AND OWNER=p_Propietario));
BEGIN
    DBMS_OUTPUT.PUT_LINE(chr(9));
    DBMS_OUTPUT.PUT_LINE('Usuarios que pueden cambiar (insertar, modificar o eliminar) sus datos: ');
    for v_usuarios IN c_usuarios loop
        DBMS_OUTPUT.PUT_LINE(v_usuarios.USERNAME);
    END loop;
END;
/


CREATE OR REPLACE PROCEDURE MostrarUsuariomodificar(p_nombretabla VARCHAR2,
                                                    p_Propietario VARCHAR2)
IS
    cursor c_usuarios is
    SELECT USERNAME
    FROM DBA_USERS 
    WHERE USERNAME IN (SELECT DISTINCT GRANTEE
                       FROM DBA_TAB_PRIVS
                       WHERE TABLE_NAME IN (SELECT TABLE_NAME
                                            FROM DBA_TABLES
                                            WHERE TABLE_NAME=p_nombretabla
                       						AND PRIVILEGE='ALTER'
                       						AND OWNER=p_Propietario));
BEGIN
    DBMS_OUTPUT.PUT_LINE(chr(9));
    DBMS_OUTPUT.PUT_LINE('Usuarios que pueden modificar su estructura: ');
    for v_usuarios IN c_usuarios loop
        DBMS_OUTPUT.PUT_LINE(v_usuarios.USERNAME);
    END loop;
END;
/

CREATE OR REPLACE PROCEDURE MostrarUsuarioeliminar(p_nombretabla VARCHAR2,
                                     	             p_Propietario VARCHAR2)
IS
    cursor c_usuarios is
    SELECT USERNAME
    FROM DBA_USERS 
    WHERE USERNAME IN (SELECT DISTINCT GRANTEE
                       FROM DBA_TAB_PRIVS
                       WHERE TABLE_NAME IN (SELECT TABLE_NAME
                                            FROM DBA_TABLES
                                            WHERE TABLE_NAME=p_nombretabla
                       						AND PRIVILEGE='DROP'
                       						AND OWNER=p_Propietario));
BEGIN
    DBMS_OUTPUT.PUT_LINE(chr(9));
    DBMS_OUTPUT.PUT_LINE('Usuarios que pueden eliminarla: ');
    for v_usuarios IN c_usuarios loop
        DBMS_OUTPUT.PUT_LINE(v_usuarios.USERNAME);
    END loop;
END;
/

CREATE OR REPLACE PROCEDURE MostrarListaExtension(p_nombretabla VARCHAR2,
                                                  p_Propietario VARCHAR2)
IS
    v_fichero VARCHAR2(50);
    cursor c_extensiones is
    SELECT seg.EXTENTS, ex.FILE_ID
    FROM DBA_SEGMENTS seg, DBA_EXTENTS ex
    WHERE seg.SEGMENT_NAME = ex.SEGMENT_NAME
    AND seg.SEGMENT_NAME=p_nombretabla
    AND seg.OWNER=p_Propietario;
BEGIN
    for v_Extension in c_extensiones loop
        v_fichero:=MostrarFichero(v_Extension.FILE_ID);
        DBMS_OUTPUT.PUT_LINE('Número extensión: ' || v_Extension.EXTENTS);
        DBMS_OUTPUT.PUT_LINE('Fichero: ' || v_fichero);
        DBMS_OUTPUT.PUT_LINE(chr(9));
    end loop;
END;
/

CREATE OR REPLACE FUNCTION MostrarFichero(p_FileID VARCHAR2)
RETURN VARCHAR2
IS
    v_nombrefichero VARCHAR2(40);
BEGIN
    SELECT FILE_NAME into v_nombrefichero
    FROM DBA_DATA_FILES 
    WHERE FILE_ID=p_FileID;
    return v_nombrefichero;
END;
/

CREATE OR REPLACE PROCEDURE MostrarInfoTabla(p_nombretabla VARCHAR2)
IS
   cursor c_Propietarios is
   SELECT DISTINCT OWNER
   FROM DBA_TABLES
   WHERE TABLE_NAME=p_nombretabla;
   v_propietario VARCHAR2(50);
BEGIN
   for v_propietario IN c_Propietarios loop
       MostrarPropietario(p_nombretabla, v_propietario.OWNER);
       Mostrarusuarioslectura(p_nombretabla, v_propietario.OWNER);
       MostartUsuariocambio(p_nombretabla, v_propietario.OWNER);
       MostrarUsuariomodificar(p_nombretabla, v_propietario.OWNER);
       MostrarUsuarioeliminar(p_nombretabla, v_propietario.OWNER);
       MostrarListaExtension(p_nombretabla, v_propietario.OWNER);
   END loop;
END;
/

ernesto=> select pg_relation_size('clientes');
 pg_relation_size 
------------------
             8192
(1 row)

ernesto=> SELECT
ernesto->     pg_size_pretty (
ernesto(>         pg_total_relation_size ('clientes')
ernesto(>     );
 pg_size_pretty 
----------------
 24 kB
(1 row)


vagrant@postgres:~$ sudo su - postgres
postgres@postgres:~$ psql
psql (11.5 (Debian 11.5-1+deb10u1))
Type "help" for help.

postgres=# CREATE VIEW user_disk_usage AS SELECT r.rolname, SUM(pg_total_relation_size(c.oid)) AS total_disk_usage 
postgres-# FROM pg_class c, pg_roles r 
postgres-# WHERE c.relkind = 'r' 
postgres-# AND c.relowner = r.oid 
postgres-# GROUP BY c.relowner, r.rolname;
CREATE VIEW

postgres=# select * from user_disk_usage;
 rolname  | total_disk_usage 
----------+------------------
 postgres |          8290304
(1 row)

mkdir /opt/oracle/oradata/orcl/solido
chown oracle: /opt/oracle/oradata/orcl/solido
chmod 700 /opt/oracle/oradata/orcl/solido

[Unit]
Description= SSD for Oracle indexes storaging purposes

[Mount]
What=/dev/disk/by-uuid/0be6966e-b527-43ef-b53d-38670b1499b4
Where=/opt/oracle/oradata/orcl/solido
Type=ext4
Options=defaults

[Install]
WantedBy=multi-user.target

systemctl daemon-reload
systemctl start opt-oracle-oradata-orcl-solido.mount
systemctl enable opt-oracle-oradata-orcl-solido.mount

create tablespace indices
datafile 'tsi1.dbf'
size 10M
autoextend on;

CREATE INDEX nombres_empleados ON emp(ename)
      TABLESPACE indices;

select index_name, column_name,table_name, table_owner
from dba_ind_columns
where table_owner='SCOTT';

select FILE_NAME, TABLESPACE_NAME 
from dba_data_files
where tablespace_name=(select distinct tablespace_name 
                    from DBA_SEGMENTS 
                    where segment_type='INDEX'
                    and owner='SCOTT');

create sequence RellenarDeptNo
  start with 50
  increment by 10
  maxvalue 200
  nocycle;

SELECT * FROM DBA_DB_LINKS;

OWNER
------------------------------
DB_LINK
--------------------------------------------------------------------------------
USERNAME
------------------------------
HOST
--------------------------------------------------------------------------------
CREATED
-------------------
SYSTEM
ENLACE1
SCOTT

OWNER
------------------------------
DB_LINK
--------------------------------------------------------------------------------
USERNAME
------------------------------
HOST
--------------------------------------------------------------------------------
CREATED
-------------------
tns1
2020/01/15 19:50:03

sed -i '/nombreentrada /,/^ *$/d' tnsnames.ora

CREATE TABLESPACE CLUSTERNAME DATAFILE '/opt/oracle/oradata/orcl/name.dbf' SIZE 10M AUTOEXTEND ON;

CREATE CLUSTER tablasempdept
(DEPTNO NUMBER(2))
TABLESPACE CLUSTERNAME;

CREATE INDEX INDEXNAME ON CLUSTER tablasempdept;

CREATE TABLE SCOTT.DEPT1
(
 DEPTNO NUMBER(2),
 DNAME VARCHAR2(14),
 LOC VARCHAR2(13),
 CONSTRAINT PK_DEPT1 PRIMARY KEY (DEPTNO))
 CLUSTER tablasempdept (DEPTNO);

CREATE TABLE SCOTT.EMP1
(
 EMPNO NUMBER(4),
 ENAME VARCHAR2(10),
 JOB VARCHAR2(9),
 MGR NUMBER(4),
 HIREDATE DATE,
 SAL NUMBER(7, 2),
 COMM NUMBER(7, 2),
 DEPTNO NUMBER(2),
 CONSTRAINT FK_DEPTNO1 FOREIGN KEY (DEPTNO) REFERENCES SCOTT.DEPT1 (DEPTNO),
 CONSTRAINT PK_EMP1 PRIMARY KEY (EMPNO)
)
 CLUSTER tablasempdept (DEPTNO);

SELECT CLUSTER_NAME FROM [USER_CLUSTERS/ALL_CLUSTERS/DBA_CLUSTERS];

select distinct u.username, u.temporary_tablespace
from dba_users u, v$TEMP_SPACE_HEADER t
where u.account_status = 'OPEN'
and u.temporary_tablespace = t.tablespace_name;

CREATE TEMPORARY TABLESPACE temp1
TEMPFILE 'temp1'
SIZE 30M
AUTOEXTEND ON;

CREATE or REPLACE PROCEDURE AsignarUsuarioTS (p_usuario dba_users.username%type,
                                              p_tablespace dba_tablespaces.tablespace_name%type)
is
begin
    execute immediate 'alter user ' || p_usuario || ' temporary tablespace ' || p_tablespace;
end AsignarUsuarioTS;
/

CREATE or REPLACE PROCEDURE BalancearCargaTablespaces
is
	cursor c_users
	is
	select distinct u.username
    from dba_users u, v$TEMP_SPACE_HEADER t
    where u.account_status = 'OPEN'
    and u.temporary_tablespace = t.tablespace_name;
    cursor c_tmts
    is
    SELECT tablespace_name
    FROM dba_tablespaces
    WHERE contents = 'TEMPORARY'
    and lower(status) = 'online';
    v_usuarios c_users%rowtype;
BEGIN
    open c_users;
    for v_tablespace in c_tmts loop
        fetch c_users into v_usuarios;
        AsignarUsuarioTS (v_usuarios.username, v_tablespace.tablespace_name);
        if c_tmts%NOTFOUND then
            close c_users;
            open c_users;
        end if;
    end loop;
end BalancearCargaTablespaces;
/

CREATE or REPLACE PROCEDURE BalancearCargaUsuarios
is
	cursor c_users is
	select distinct u.username
    from dba_users u, v$TEMP_SPACE_HEADER t
    where u.account_status = 'OPEN'
    and u.temporary_tablespace = t.tablespace_name;
    cursor c_tmts
    is
    SELECT tablespace_name
    FROM dba_tablespaces
    WHERE contents = 'TEMPORARY'
    and lower(status) = 'online';
    v_tablespace c_tmts%rowtype;
BEGIN
    open c_tmts;
    for v_usuarios in c_users loop
        fetch c_tmts into v_tablespace;
        AsignarUsuarioTS (v_usuarios.username, v_tablespace.tablespace_name);
        if c_tmts%NOTFOUND then
            close c_tmts;
            open c_tmts;
        end if;
    end loop;
end BalancearCargaUsuarios;
/

CREATE or REPLACE FUNCTION ContarUsuarios
return number
is
    v_numusers     number;
begin
    select count(u.username) into v_numusers
    from dba_users u, v$TEMP_SPACE_HEADER t
    where u.account_status = 'OPEN'
    and u.temporary_tablespace = t.tablespace_name;
    return v_numusers;
end ContarUsuarios;
/

CREATE or REPLACE FUNCTION ContarTablespaces
return number
is
    v_numts     number;
begin
    SELECT count(tablespace_name) into v_numts
    FROM dba_tablespaces
    WHERE contents = 'TEMPORARY'
    and lower(status) = 'online';
    return v_numts;
end ContarTablespaces;
/

CREATE or REPLACE PROCEDURE BalanceoCargaTemp
is
begin
    if ContarTablespaces > ContarUsuarios then
        
        BalancearCargaTablespaces;
    else
        BalancearCargaUsuarios;
    end if;
end BalanceoCargaTemp;
/

SQL> select distinct u.username, u.temporary_tablespace
  2  from dba_users u, v$TEMP_SPACE_HEADER t
  3  where u.account_status = 'OPEN'
  4  and u.temporary_tablespace = t.tablespace_name;

USERNAME                       TEMPORARY_TABLESPACE
------------------------------ ------------------------------
DBSNMP                         TEMP2
JUAN                           TEMP1
BECARIO                        TEMP1
AYUDANTE                       TEMP
JUANDI                         TEMP1
SYS                            TEMP
SCOTT                          TEMP
PRUEBA                         TEMP2
SYSTEM                         TEMP2
SYSMAN                         TEMP2

10 filas seleccionadas.

create user Pepe identified by Pepe;
grant dba to Pepe;

create user Juan identified by Juan;
create user Clara identified by Clara;
grant resource to Juan;
grant resource to Clara;

create user Ana identified by Ana;
create user Eva identified by Eva;
grant select on Ana.Ventas to Eva;
grant insert on Ana.Ventas to Eva;
grant update on Ana.Ventas to Eva;
grant delete on Ana.Ventas to Eva;
grant select on Ana.Productos to Eva;
grant insert on Ana.Productos to Eva;
grant update on Ana.Productos to Eva;
grant delete on Ana.Productos to Eva;

create user Jaime identified by Jaime;
create user Lidia identified by Lidia;
grant select on Ana.Ventas to Jaime;
grant select on Ana.Ventas to Lidia;
grant select on Ana.Productos to Jaime;
grant select on Ana.Productos to Lidia;

CREATE ROLE Produccion;
GRANT select on Ana.Ventas to Produccion;
GRANT select on Ana.Productos to Produccion;

GRANT Produccion to Lidia;
GRANT Produccion to Jaime;

CREATE ROLE Ventas;
GRANT select, insert, update, delete on Ana.Ventas to Ventas;
GRANT select, insert, update, delete on Ana.Productos to Ventas;
GRANT Ventas to Eva;

CREATE TABLESPACE ts_produccion
DATAFILE 'prod1.dbf' SIZE 100M, 
'prod2.dbf' SIZE 100M AUTOEXTEND ON;

CREATE TABLESPACE ts_venta 
DATAFILE 'vent.dbf' 
SIZE 100M AUTOEXTEND ON;

ALTER USER ANA QUOTA 30M ON ts_venta;
ALTER USER EVA QUOTA 30M ON ts_venta;
ALTER USER JAIME QUOTA 100K ON ts_produccion;
ALTER USER LIDIA QUOTA 100K ON ts_produccion;

ALTER USER Pepe DEFAULT TABLESPACE SYSTEM;
GRANT UNLIMITED TABLESPACE TO Pepe;

GRANT UNLIMITED TABLESPACE TO JUAN;
GRANT UNLIMITED TABLESPACE TO CLARA;
ALTER USER JUAN QUOTA 0 ON SYSTEM;
ALTER USER CLARA QUOTA 0 ON SYSTEM;

CREATE TABLE PEPE.PRUEBA (
Codigo    VARCHAR2(5),
Nombre    VARCHAR2(30),
CONSTRAINT pk_codigo PRIMARY KEY(Codigo),
TABLESPACE Ventas,
STORAGE ( INITIAL 256K)
);

GRANT SELECT ON PEPE.PRUEBA TO Juan WITH GRANT OPTION;
GRANT SELECT ON PEPE.PRUEBA TO Clara WITH GRANT OPTION;
GRANT CONNECT TO Clara WITH ADMIN OPTION;
GRANT CONNECT TO Juan WITH ADMIN OPTION;

DROP USER LIDIA cascade;
DROP USER JAIME cascade;

drop tablespace ts_produccion including contents and datafiles;