Dato---- información sin significado.

BD---información datos ya relacionada

Campo---area de almacenamiento que guarda datos de un tipo específico
Registro---colección de datos iguales o de diferentes tipos relacionados
Archivo---colección de registros relacionados

Si tenemos dos o más archivos relacionados entonces tengo BD

Modelo de base de datos---Conjunto de ideas lógicas utilizadas
para representar la estructura de las bd's. Sirve para visualizar
la estructura la bd de manera global.

Modelo relacional--Visualizar la estructura y las relaciones entre

datos

Diagrama entidad relación--- herramienta para modelar bd y analizarla

Elementos diagrama entidad relación extendido EER:

-Entidad:Objeto concreto que figura en nuestra bd(alumno,cliente,empresa)

-Relación: relación entre entidades

-Atributo: Característica de una entidad como nombre,edad,fecha. Cada

entidad tiene que tener atributos generales es decir todas las entidades
las tienen

-Atributo principal o clave primario: único y toda entidad tiene que

tener la suya. Ejemplo id de un producto (código de barras). Con ese
atributo es posible identificar al producto en específico sin
ambiguedad

-Atributo foráneo o clave secundario: identificar entidad externa

en otra

Reglas del negocio: reglas que te imponen a tu bd

Cardinalidad o mapeo: tipo de relación entre entidades.

4 tipos de mapeo:1 a 1, uno-muchos,muchos-uno, muchos-muchos

Clave foranea usada en relacion uno-muchos

Si tengo Relación muchos-muchos-se crea tabla intermedia con claves
foraneas de las dos entidades relacionadas

SQL-- Lenguaje estructurado de consulta, permite crear y manipular

bd. Se divide en dos:DDL y DML

DDL:Lenguaje de definición de datos--Permite dar estructura a una

base de datos. Create,drop

DML:Lenguaje de manipulación de datos-- Permite manipular los datos

Insert, select

SQL usa el modelo relacional pero usa diferentes nombres.

entidad---tabla
atributo---campo
registro---tuplas
cardinalidad---relaciones

Tipos de datos sql

-varchar(x): cadena de longitud variable

Nom Varchar(7). Almacena tantos caracteres como llenos haya.
Optimiza el espacio de memoria

-Nom char(x): cadena de longitud fija

int
smallint
bigint
floar

tipo fecha y hora

datetime: puede almacenar valores desde 1 enero 1753 hasta 31 de
diciembre 9999

smalldatetime:1/1/1900 hasta 6/06/2079

Almacenan dia,año,hora,minutos,segundos

Hay que indicar que formato usar mdy,myd,dmy

Create database escuela

use escuela

--Tabla carrera
create table carrera(
clave_c int,
nom_c varchar(50),
durac_c float,
constraint pk_cc primary key(clave_c) esto indica clave primaria

--Tabla materia
create table materia(
clave_m int,
nom_m varchar(50),
cred_m float,
constraint pk_cm primary key(clave_m) esto indica clave primaria
)

--Tabla profesor
create table profesor(
clave_p int,
nom_p varchar(50),
dir_p float,
tel_p bigint,
hor_p datetime,
constraint pk_cp primary key(clave_p) esto indica clave primaria
)

--Tabla alumno
--Con clave foranea

create table alumno(

mat_alu int,
nom_alu varchar(150),
edad_alu int
sem_alu int
gen_alu varchar(10)
clave_c1 int,
constraint pk_cp primary key(clave_p), esto indica clave primaria
constraint fk_fc1 foreign key(clave_c1) references carrera(clave_c)
)

--Alumno profesor
create table alu_pro(
mat_alu1 int,
clave_p1 int,

constraint fk_falu1 foreign key(mat_alu1) references alumno(mat_alu),

constraint fk_fp1 foreign key(clave_p1) references profesor(clave_p)
)
--Alumno materia
create table mat_alu(
mat_alu2 int,
clave_m1 int,

constraint fk_falu2 foreign key(mat_alu2) references alumno(mat_alu),

constraint fk_fm1 foreign key(clave_m1) references materia(clave_m)
)
-- materia profesor
create table mat_pro(
clave_m2 int,
clave_p2 int,

constraint fk_fm2 foreign key(clave_m2) references materia(clave_m),

constraint fk_fp2 foreign key(clave_p2) references profesor(clave_p)
)

Primera toca crear tablas y las primeras deben ser las que son
independientes es decir las que no tienen claves foraneas

Una tabla es cualquier cosa que tenga atributos. Con sql server
se puede ver el diagrama

Ahora toca el lenguaje dml

Ejemplo como insertar tipo de datos
Insert Into tabla values()

Visualizar todo el contenido de la tabla--select *from table

Si quieres ver campos específicos--select Campo(s) from tabla

Hay que poner en uso la base de datos recordarlo antes de empezar!

Create database escuela

use escuela

--Tabla carrera
create table carrera(
clave_c int,
nom_c varchar(50),
durac_c float,
constraint pk_cc primary key(clave_c) esto indica clave primaria

insert into carrera values(1,'Derecho',3)

insert into carrera values(2,'ingenieria',4)

select *from carrera ----con esto se muestra toda la tabla

--Tabla materia
create table materia(
clave_m int,
nom_m varchar(50),
cred_m float,
constraint pk_cm primary key(clave_m) esto indica clave primaria
)

insert into materia values(1,'Matemáticas',25)

insert into materia values(2,'Español',15)

select clave_m,nom_m from materia ---solo me muestra campos especificos

--Tabla profesor
create table profesor(
clave_p int,
nom_p varchar(50),
dir_p float,
tel_p bigint,
hor_p datetime,
constraint pk_cp primary key(clave_p) esto indica clave primaria
)

insert into profesor values(1,'Laura Rosas','Calle Azul',56787,'7:00')

insert into profesor values(2,'Roberto Díaz','Calle Rosa',56787,'9:00')
--Tabla alumno
--Con clave foranea

create table alumno(

mat_alu int,
nom_alu varchar(150),
edad_alu int
sem_alu int
gen_alu varchar(10)
clave_c1 int,
constraint pk_cp primary key(clave_p), esto indica clave primaria
constraint fk_fc1 foreign key(clave_c1) references carrera(clave_c)
)

insert into alumno values(1,'Ana',18,6,'Mujer',1)

--Alumno profesor
create table alu_pro(
mat_alu1 int,
clave_p1 int,

constraint fk_falu1 foreign key(mat_alu1) references alumno(mat_alu),

constraint fk_fp1 foreign key(clave_p1) references profesor(clave_p)
)

insert into alu_pro values(1,2) A Ana(1) le imparte clase el profe 2

--Alumno materia
create table mat_alu(
mat_alu2 int,
clave_m1 int,

constraint fk_falu2 foreign key(mat_alu2) references alumno(mat_alu),

constraint fk_fm1 foreign key(clave_m1) references materia(clave_m)
)

insert into mat_alu values(1,1)

-- materia profesor
create table mat_pro(
clave_m2 int,
clave_p2 int,

constraint fk_fm2 foreign key(clave_m2) references materia(clave_m),

constraint fk_fp2 foreign key(clave_p2) references profesor(clave_p)
)

insert into mat_pro values(2,2)

-------------------------------------
Visualizar con inner join, where
select nom_alu,edad_alu,sem_alu,nom_c
from alumno inner join carera on alumno.clave_c1=carrera.clave_c

tienes que relacionar claves primarias y foraneas

con where se pone condiciones

Update 'nombre de la tabla'

set campo= nuevo valor

update cliente
set nom_clie='laura' si ejecuto así se actualizarán TODOS los
registros

Para evitar esto usamos where para poner condiciones

where clave_clie=2 de esta manera solo cambio el registro de clave
2

update nota
set subtot=cant*precio

from nota inner join producto on producto.clave_prod=nota.clave_prod1

Delete--elimina registros de una tabla

Drop---elimina estructuras como tablas o bd junto con sus datos

Truncate-- elimina todos los registros de una tabla

Delete from, delete from where, drop table, drop database,truncate

table

delete from nombretabla

esto elimina todos los registros de la tabla pero no la tabla en si

delete from producto where clave_prod=3 and precio=7

elimino un registro en particular con condiciones

drop table nombretabla

hay que eliminar de manera ordenada las tablas no relacionadas

con otras.

ahora vamos a eliminar bd

use master
drop database modificar

truncate table nombretabla es lo mismo que delete pero es + rápido

Normalización

Existen niveles para normalizar base de datos

Primera Forma Normal

Segunda Forma Normal
Tercera Forma Normal
Forma Normal Boyce Codd
Cuarta Forma Normal
Quinta Forma Normal

Primera forma normal: identifica si hay un grupo de repetición

sobre el mismo registro. Se divide la tabla inicial en dos pero sin
perder la información.

Segunda Forma Normal: dos tipos de dependencias, la funcional y

la transitiva.
La funcional se trata de una dependencia donde hay una clave primaria
y otros atributos que dependen directamente del inicial. A,B,C.
Si no existe A entonces de manera directa no existe B ni C

A es la clave primaria.

La dependencia transitiva es lo mismo pero de manera indirecta.

Tabla fuerte= una tabla que tiene clave primaria y atributos

Tercera forma normal

Diagrama normalizado -------------------------------------------

Create database normalizado

use escuela

--Tabla carrera
create table carrera(
nocarrera char(3),
Carrera varchar(50),
constraint pk_cnc primary key(nocarrera) esto indica clave primaria

--Tabla materia
create table materia(
nummateria int,
materia varchar(50),
constraint pk_cnm primary key(nummateria) esto indica clave primaria
)

--Tabla tipo tel

create table Tipo_tel(
id_tipotel int,
tipotel varchar(50),
constraint pk_cit primary key(id_tipotel) esto indica clave primaria
)

--Tabla delegacion
create table Delegacion(
id_delegacion int,
delegacion varchar(50),
constraint pk_cd primary key(id_delegacion) esto indica clave primaria
)

--Tabla alumno
--Con clave foranea

create table alumno(

matricula_alu int,
nombre_alu varchar(150),
app_alu varchar(150),
apm_alu varchar(150),
id_delegacion1 int,
id_colonia1 int,
id_calle1 int,
num_int int,1
num_ext int,
cp int ,
nocarrera1 int,

constraint pk_calu primary key(matricula_alu), esto indica clave primaria,

constraint fk_fdel foreign key(id_delegacion1) references
delegacion(id_delegacion),
constraint fk_fcol foreign key(id_colonia1) references colonia(id_colonia),
constraint fk_fcall foreign key(id_calle1) references calle(id_calle)
constraint fk_fncar foreign key(nocarrera1) references carrera(nocarrera)
)

create table colonia(

id_colonia int,
colonia varchar(150),
id_delegacion2 int,

constraint pk_ccol primary key(id_colonia), esto indica clave primaria,

constraint fk_fdel2 foreign key(id_delegacion2) references
delegacion(id_delegacion)
)

create table calle(

id_calle int,
calle varchar(150),
id_colonia2 int,
constraint pk_ccalle primary key(id_calle), esto indica clave primaria,
constraint fk_fcol2 foreign key(id_colonia2) references colonia(id_colonia)
)

--Alumno tipotel
create table alu_tel(
telefono int,
matricula_alu2 int,
id_tipotel1 int,

constraint pk_ctelef primary key(telefono),

constraint fk_fmalu2 foreign key(matricula_alu2) references alumno(matricula_alu),
constraint fk_ftipot foreign key(id_tipotel1) references tipo_tel(id_tipotel)
)

--alumno materia
create table mat_alu(
matricula_alu1 int,
nummateria1 int,

constraint fk_fmatalu2 foreign key(matricula_alu1) references

alumno(matricula_alu),
constraint fk_fmat1 foreign key(nummateria1) references materia(nummateria)
)

-- materia alumno
create table mat_pro(
clave_m2 int,
clave_p2 int,

constraint fk_f foreign key(clave_m2) references materia(clave_m),

constraint fk_fp2 foreign key(clave_p2) references profesor(clave_p)
)

DDL data definition language

DML data manipulation language
DCL data control language

NOT ONLY SQL Es un modelo no relacional, no necesitas hacer el modelo

NOSQL Para empresas que necesitan mucho rendimiento. Ejemplo casos

dynamodb de amazon

Las bases de datos no relacionales priorizan el acceso rápido sobre

la normalización
En un abase de datos relacional no puede haber redundancia por eso
mismo se normalizan para evitar estos temas.
Curso SQL Pildoras informáticas---------------------------------------

DDL--data definition language

create,alter,drop,truncate

DML--data manipulation language

select,insert,update,delete

DCL--data control language--proporciona seguridad

grant, revoke

TCL--transaction control language--gestión cambios en los datos

commit, rollback, savepoint

Cláusulas--

from,where, group by, having, order by,

Instruccion sql= comando+clausulas+operadores+funciones

php my admin es como una consola de administración desde donde es
sencillo manejar base de datos mysql