Este documento describe el diseño y desarrollo de la interfaz web de un sistema de información como evidencia de aprendizaje. Incluye los pasos a seguir para diseñar la interfaz usando HTML y CSS, y para generar los archivos necesarios como páginas principales y de formularios. La evidencia será evaluada con base en criterios como el diseño de acuerdo a los requerimientos y la aplicación de estándares y protocolos de seguridad.
La metodología Mobile-D es una metodología ágil para el desarrollo de aplicaciones móviles que consta de 5 fases: 1) Exploración, 2) Inicialización, 3) Fase de Producto, 4) Fase de Estabilización y 5) Fase de Pruebas. La Fase de Producto se repite iterativamente hasta implementar todas las funcionalidades mediante el desarrollo dirigido por pruebas. Cada iteración incluye una jornada de planificación, una jornada de trabajo y una jornada de lanzamiento.
PostgreSQL es un sistema de gestión de bases de datos objeto-relacional libre y de código abierto muy avanzado. Tiene una larga historia de desarrollo desde 1977 y actualmente tiene un gran equipo de desarrolladores. Ofrece características potentes como transacciones ACID, tipos de datos extendidos, y alta escalabilidad, siendo utilizado por empresas como Sony, Cisco y universidades.
Este documento compara diferentes sistemas de gestión de bases de datos (SGBD), incluyendo sus ventajas y desventajas. Describe las características de Oracle, PostgreSQL, MySQL, SQL Server, Access y Base, así como sus usos comunes y limitaciones.
Este documento presenta el contenido didáctico del curso 301402 Sistemas Operativos de la Universidad Nacional Abierta y a Distancia. Describe la estructura del curso organizado en tres unidades que cubren la teoría, administración de recursos y principales sistemas operativos. Explica que el contenido fue desarrollado y actualizado por instructores de la universidad con el objetivo de brindar conocimientos sobre sistemas operativos de manera integral.
Este documento describe varios modelos de procesos para la ingeniería de software, incluyendo modelos lineales, evolutivos e híbridos. Todos los modelos buscan resolver problemas a través de etapas iterativas de definición de problemas, desarrollo técnico e integración de soluciones. El modelo a elegir depende del proyecto, aplicación, métodos y herramientas disponibles.
La segunda forma normal (2NF) es una regla de normalización que establece que todos los atributos no clave de una tabla deben depender funcionalmente de toda la clave primaria. Normalizar una base de datos en 2NF elimina anomalías como la duplicación de datos y problemas de actualización. Para que una tabla esté en 2NF, debe primero estar en primera forma normal y todos sus atributos no clave deben depender completamente de la clave primaria.
Este documento describe el diseño y desarrollo de la interfaz web de un sistema de información como evidencia de aprendizaje. Incluye los pasos a seguir para diseñar la interfaz usando HTML y CSS, y para generar los archivos necesarios como páginas principales y de formularios. La evidencia será evaluada con base en criterios como el diseño de acuerdo a los requerimientos y la aplicación de estándares y protocolos de seguridad.
La metodología Mobile-D es una metodología ágil para el desarrollo de aplicaciones móviles que consta de 5 fases: 1) Exploración, 2) Inicialización, 3) Fase de Producto, 4) Fase de Estabilización y 5) Fase de Pruebas. La Fase de Producto se repite iterativamente hasta implementar todas las funcionalidades mediante el desarrollo dirigido por pruebas. Cada iteración incluye una jornada de planificación, una jornada de trabajo y una jornada de lanzamiento.
PostgreSQL es un sistema de gestión de bases de datos objeto-relacional libre y de código abierto muy avanzado. Tiene una larga historia de desarrollo desde 1977 y actualmente tiene un gran equipo de desarrolladores. Ofrece características potentes como transacciones ACID, tipos de datos extendidos, y alta escalabilidad, siendo utilizado por empresas como Sony, Cisco y universidades.
Este documento compara diferentes sistemas de gestión de bases de datos (SGBD), incluyendo sus ventajas y desventajas. Describe las características de Oracle, PostgreSQL, MySQL, SQL Server, Access y Base, así como sus usos comunes y limitaciones.
Este documento presenta el contenido didáctico del curso 301402 Sistemas Operativos de la Universidad Nacional Abierta y a Distancia. Describe la estructura del curso organizado en tres unidades que cubren la teoría, administración de recursos y principales sistemas operativos. Explica que el contenido fue desarrollado y actualizado por instructores de la universidad con el objetivo de brindar conocimientos sobre sistemas operativos de manera integral.
Este documento describe varios modelos de procesos para la ingeniería de software, incluyendo modelos lineales, evolutivos e híbridos. Todos los modelos buscan resolver problemas a través de etapas iterativas de definición de problemas, desarrollo técnico e integración de soluciones. El modelo a elegir depende del proyecto, aplicación, métodos y herramientas disponibles.
La segunda forma normal (2NF) es una regla de normalización que establece que todos los atributos no clave de una tabla deben depender funcionalmente de toda la clave primaria. Normalizar una base de datos en 2NF elimina anomalías como la duplicación de datos y problemas de actualización. Para que una tabla esté en 2NF, debe primero estar en primera forma normal y todos sus atributos no clave deben depender completamente de la clave primaria.
Este documento presenta varias técnicas para generar casos de prueba para probar un programa, incluyendo la cobertura de sentencias, decisiones, condiciones y caminos, la partición en clases de equivalencia, y el cálculo de la complejidad ciclomática. El objetivo principal es escribir casos de prueba que ejecuten todas las posibles ramas de código y detecten errores.
Este documento proporciona una plantilla para la especificación de requisitos de software de un proyecto. Incluye secciones para la introducción, descripción general, requisitos específicos y apéndices. Proporciona instrucciones para completar cada sección con la información relevante sobre el alcance, funcionalidad, usuarios, restricciones y requisitos del software.
Este documento describe el desarrollo de una base de datos para una compañía de transporte provincial. Explica el uso de tablas, diagramas de entidad-relación y diferentes etapas de normalización para organizar de manera eficiente los datos de pasajeros, choferes, medios de transporte y otros. También revisa herramientas como DbDesigner y Microsoft Access que pueden usarse para crear y administrar la base de datos. El objetivo final es contar con un sistema que permita un registro más efectivo de la información de la empresa.
Este documento presenta una introducción a la planificación de pruebas de software y estrategias de prueba para software convencional. Explica conceptos clave como verificación y validación, y tipos de pruebas como pruebas unitarias, de integración, funcionales y de rendimiento. También discute la importancia de las pruebas de software para la calidad y los costos asociados con defectos de software.
El documento describe los requerimientos para un sistema de torneos de fútbol. El sistema permitirá 1) registrar equipos y jugadores, 2) planificar partidos de forma aleatoria o manual, y 3) generar tablas de posición automáticamente. Además, el sistema 4) identificará al mejor goleador y 5) publicará información del torneo en la web. El sistema tendrá una interfaz intuitiva y solo el organizador podrá realizar actualizaciones.
Este documento trata sobre transacciones en bases de datos. Explica que una transacción es un conjunto de acciones que acceden o cambian datos en la base de datos. Las transacciones deben cumplir con las propiedades ACID de atomicidad, consistencia, aislamiento y durabilidad. También describe los conceptos de commit, que hace permanentes los cambios, y rollback, que descarta los cambios.
Este documento presenta conceptos básicos sobre ingeniería de software. Explica que el software es el producto que construyen los ingenieros de software y puede aplicarse en cualquier situación donde se hayan definido previamente los pasos procedimentales. Además, describe las diferentes actividades del proceso de software como planificación, análisis, diseño, implementación, pruebas, instalación y mantenimiento. Finalmente, introduce conceptos como ciclo de vida del software, calidad de software y diferentes modelos de ciclo de vida.
El administrador de bases de datos (DBA) se encarga de mantener la recuperabilidad, disponibilidad, integridad y seguridad de los datos almacenados, así como optimizar el rendimiento. Algunas de sus funciones principales incluyen garantizar que los datos puedan recuperarse ante errores, que los usuarios tengan acceso a los datos cuando lo necesiten, que se cumplan las reglas del negocio y que los usuarios solo puedan acceder a la información autorizada. El DBA también se encarga de realizar pruebas y hacer cambios para mejorar el
Rational Rose es una herramienta de diseño orientada a objetos, que da soporte al modelado visual, es decir, que permite representar gráficamente el sistema, permitiendo hacer énfasis en los detalles más importantes, centrándose en los casos de uso y enfocándose hacia un software de mayor calidad, empleando un lenguaje estándar común que facilita la comunicación.
La bitácora registra todas las transacciones realizadas en una base de datos, como inserciones, eliminaciones y modificaciones. Esto permite auditar y analizar dichas transacciones posteriormente. Se crea una tabla bitácora y se definen triggers para cada tabla de la base de datos que registren las operaciones realizadas, el usuario, fecha y otros detalles cada vez que haya una inserción, eliminación o modificación. La implementación de una bitácora no requiere cambios en los sistemas de producción y permite hacer seguimiento de todos los cambios
Este documento describe el modelo SPICE (Software Process Improvement and Capability Determination) para la evaluación de procesos de desarrollo de software. SPICE es un estándar internacional desarrollado por la ISO para ayudar a las organizaciones a mejorar la capacidad de sus procesos de software. El documento explica los elementos clave de SPICE, incluidos los niveles de capacidad del proceso, los atributos del proceso, las dimensiones del proceso y los perfiles del proceso. El objetivo final es proporcionar una visión general de SPICE y describir sus principales
Este minitutorial tiene como objetivo captar todos los conceptos dictados en cada sesión en el curso de Base de Datos Avanzado II, así como brindar apoyo a los alumnos de la carrera técnica de Computación e Informática, que por algún motivo no hayan asistido a clases.
UNIDAD 1. Introducción a una BD ORACLE
Logro de la Unidad de Aprendizaje
Al término de la unidad, el alumno detalla la arquitectura de la base de datos Oracle y configura la conexión de un cliente remoto a través del archivo tnsnames.ora. Asimismo manipula la información mediante la herramienta SQL*PLUS y gestiona una instancia de base de datos.
Temario
1.1 Tema 1: INTRODUCCIÓN AL SGBD ORACLE
1.1.1 Introducción a una DB relacional y a la arquitectura Oracle
1.1.2 Interactuando con la base de datos: Conexión y SQL*PLUS
1.1.3 Componentes de la Arquitectura de una BD Oracle
1.2 Tema 2: GESTIÓN DE UNA INSTANCIA ORACLE
1.2.1 Inicio de la instancia
1.2.2 Apertura de la Base de Datos
1.2.3 Cierre de la Base de Datos
1.2.4 Configuración de un cliente Oracle
1) El documento presenta el diseño de un sistema experto para un entrenador deportivo que ayude a recopilar información médica de aspirantes y recomendar rutinas de ejercicios. 2) El sistema experto minimizará el tiempo que el entrenador dedica a analizar documentación médica, permitiéndole concentrarse en otros atletas. 3) El documento describe el problema a resolver, objetivos, justificación, alcances, limitaciones y metodología para el desarrollo del sistema experto.
Este documento describe los servicios del sistema operativo Windows, incluyendo que son servicios, cómo ver y modificar los servicios instalados, y los diferentes estados que pueden tener los servicios (iniciado, detenido, automático, manual, deshabilitado).
Las empresas dependen de la información almacenada en bases de datos, pero estas pueden dañarse y causar la pérdida de datos. Los administradores de bases de datos pueden recuperar la información mediante copias de seguridad y herramientas que permiten restaurar la base de datos a un estado consistente anterior al daño. Existen diferentes métodos y escenarios de recuperación para diversos tipos de bases de datos y daños.
Este documento describe los lenguajes de bases de datos, incluyendo lenguajes de definición de datos para especificar el esquema y lenguajes de manipulación de datos para consultas y modificaciones. Explica que SQL incluye ambos lenguajes. También describe lenguajes declarativos como SQL frente a lenguajes procedimentales, y cómo las consultas pueden involucrar múltiples tablas.
Este documento describe el modelo COCOMO II para la estimación de proyectos de software. El modelo COCOMO II incluye tres submodelos: el modelo ACM para aplicaciones, el modelo EDM para diseño inicial y el modelo PAM para post-arquitectura. El modelo ACM se utiliza principalmente en las primeras etapas y se basa en puntos de objeto para estimar el esfuerzo requerido para aplicaciones diversificadas mediante el uso de prototipos. El documento proporciona un ejemplo de cómo aplicar el modelo ACM para estimar el esfuerzo en persona-
Este documento presenta 10 ejercicios propuestos para practicar estructuras de control repetitivas while y do-while en los lenguajes de programación Pseint y Java. Los ejercicios incluyen contar números de 1 a N, sumar valores ingresados, calcular promedios, y analizar datos dentro de ciertos rangos. El documento provee la lógica de cada ejercicio implementada en ambos lenguajes para que el lector pueda comparar y practicar.
El documento proporciona una introducción al Proceso Racional Unificado (RUP), incluyendo su definición, historia, principios, ciclo de vida y etapas. RUP es una metodología para el desarrollo de software que se centra en la calidad, adaptación y colaboración. Se compone de cuatro fases iterativas: inicio, elaboración, construcción y transición. Cada fase tiene objetivos específicos como establecer requisitos, desarrollar la arquitectura y poner el producto final en manos de los usuarios.
El documento habla sobre los triggers o disparadores SQL. Explica que los triggers son objetos de la base de datos que ejecutan acciones cuando ocurren ciertos eventos como inserciones, modificaciones o borrados. A continuación, muestra un ejemplo de un trigger DML que actualiza el campo "stateChangedDate" con la fecha y hora cuando cambia el estado de un expediente y también inserta un registro en otra tabla con el historial de cambios.
Este documento presenta varias técnicas para generar casos de prueba para probar un programa, incluyendo la cobertura de sentencias, decisiones, condiciones y caminos, la partición en clases de equivalencia, y el cálculo de la complejidad ciclomática. El objetivo principal es escribir casos de prueba que ejecuten todas las posibles ramas de código y detecten errores.
Este documento proporciona una plantilla para la especificación de requisitos de software de un proyecto. Incluye secciones para la introducción, descripción general, requisitos específicos y apéndices. Proporciona instrucciones para completar cada sección con la información relevante sobre el alcance, funcionalidad, usuarios, restricciones y requisitos del software.
Este documento describe el desarrollo de una base de datos para una compañía de transporte provincial. Explica el uso de tablas, diagramas de entidad-relación y diferentes etapas de normalización para organizar de manera eficiente los datos de pasajeros, choferes, medios de transporte y otros. También revisa herramientas como DbDesigner y Microsoft Access que pueden usarse para crear y administrar la base de datos. El objetivo final es contar con un sistema que permita un registro más efectivo de la información de la empresa.
Este documento presenta una introducción a la planificación de pruebas de software y estrategias de prueba para software convencional. Explica conceptos clave como verificación y validación, y tipos de pruebas como pruebas unitarias, de integración, funcionales y de rendimiento. También discute la importancia de las pruebas de software para la calidad y los costos asociados con defectos de software.
El documento describe los requerimientos para un sistema de torneos de fútbol. El sistema permitirá 1) registrar equipos y jugadores, 2) planificar partidos de forma aleatoria o manual, y 3) generar tablas de posición automáticamente. Además, el sistema 4) identificará al mejor goleador y 5) publicará información del torneo en la web. El sistema tendrá una interfaz intuitiva y solo el organizador podrá realizar actualizaciones.
Este documento trata sobre transacciones en bases de datos. Explica que una transacción es un conjunto de acciones que acceden o cambian datos en la base de datos. Las transacciones deben cumplir con las propiedades ACID de atomicidad, consistencia, aislamiento y durabilidad. También describe los conceptos de commit, que hace permanentes los cambios, y rollback, que descarta los cambios.
Este documento presenta conceptos básicos sobre ingeniería de software. Explica que el software es el producto que construyen los ingenieros de software y puede aplicarse en cualquier situación donde se hayan definido previamente los pasos procedimentales. Además, describe las diferentes actividades del proceso de software como planificación, análisis, diseño, implementación, pruebas, instalación y mantenimiento. Finalmente, introduce conceptos como ciclo de vida del software, calidad de software y diferentes modelos de ciclo de vida.
El administrador de bases de datos (DBA) se encarga de mantener la recuperabilidad, disponibilidad, integridad y seguridad de los datos almacenados, así como optimizar el rendimiento. Algunas de sus funciones principales incluyen garantizar que los datos puedan recuperarse ante errores, que los usuarios tengan acceso a los datos cuando lo necesiten, que se cumplan las reglas del negocio y que los usuarios solo puedan acceder a la información autorizada. El DBA también se encarga de realizar pruebas y hacer cambios para mejorar el
Rational Rose es una herramienta de diseño orientada a objetos, que da soporte al modelado visual, es decir, que permite representar gráficamente el sistema, permitiendo hacer énfasis en los detalles más importantes, centrándose en los casos de uso y enfocándose hacia un software de mayor calidad, empleando un lenguaje estándar común que facilita la comunicación.
La bitácora registra todas las transacciones realizadas en una base de datos, como inserciones, eliminaciones y modificaciones. Esto permite auditar y analizar dichas transacciones posteriormente. Se crea una tabla bitácora y se definen triggers para cada tabla de la base de datos que registren las operaciones realizadas, el usuario, fecha y otros detalles cada vez que haya una inserción, eliminación o modificación. La implementación de una bitácora no requiere cambios en los sistemas de producción y permite hacer seguimiento de todos los cambios
Este documento describe el modelo SPICE (Software Process Improvement and Capability Determination) para la evaluación de procesos de desarrollo de software. SPICE es un estándar internacional desarrollado por la ISO para ayudar a las organizaciones a mejorar la capacidad de sus procesos de software. El documento explica los elementos clave de SPICE, incluidos los niveles de capacidad del proceso, los atributos del proceso, las dimensiones del proceso y los perfiles del proceso. El objetivo final es proporcionar una visión general de SPICE y describir sus principales
Este minitutorial tiene como objetivo captar todos los conceptos dictados en cada sesión en el curso de Base de Datos Avanzado II, así como brindar apoyo a los alumnos de la carrera técnica de Computación e Informática, que por algún motivo no hayan asistido a clases.
UNIDAD 1. Introducción a una BD ORACLE
Logro de la Unidad de Aprendizaje
Al término de la unidad, el alumno detalla la arquitectura de la base de datos Oracle y configura la conexión de un cliente remoto a través del archivo tnsnames.ora. Asimismo manipula la información mediante la herramienta SQL*PLUS y gestiona una instancia de base de datos.
Temario
1.1 Tema 1: INTRODUCCIÓN AL SGBD ORACLE
1.1.1 Introducción a una DB relacional y a la arquitectura Oracle
1.1.2 Interactuando con la base de datos: Conexión y SQL*PLUS
1.1.3 Componentes de la Arquitectura de una BD Oracle
1.2 Tema 2: GESTIÓN DE UNA INSTANCIA ORACLE
1.2.1 Inicio de la instancia
1.2.2 Apertura de la Base de Datos
1.2.3 Cierre de la Base de Datos
1.2.4 Configuración de un cliente Oracle
1) El documento presenta el diseño de un sistema experto para un entrenador deportivo que ayude a recopilar información médica de aspirantes y recomendar rutinas de ejercicios. 2) El sistema experto minimizará el tiempo que el entrenador dedica a analizar documentación médica, permitiéndole concentrarse en otros atletas. 3) El documento describe el problema a resolver, objetivos, justificación, alcances, limitaciones y metodología para el desarrollo del sistema experto.
Este documento describe los servicios del sistema operativo Windows, incluyendo que son servicios, cómo ver y modificar los servicios instalados, y los diferentes estados que pueden tener los servicios (iniciado, detenido, automático, manual, deshabilitado).
Las empresas dependen de la información almacenada en bases de datos, pero estas pueden dañarse y causar la pérdida de datos. Los administradores de bases de datos pueden recuperar la información mediante copias de seguridad y herramientas que permiten restaurar la base de datos a un estado consistente anterior al daño. Existen diferentes métodos y escenarios de recuperación para diversos tipos de bases de datos y daños.
Este documento describe los lenguajes de bases de datos, incluyendo lenguajes de definición de datos para especificar el esquema y lenguajes de manipulación de datos para consultas y modificaciones. Explica que SQL incluye ambos lenguajes. También describe lenguajes declarativos como SQL frente a lenguajes procedimentales, y cómo las consultas pueden involucrar múltiples tablas.
Este documento describe el modelo COCOMO II para la estimación de proyectos de software. El modelo COCOMO II incluye tres submodelos: el modelo ACM para aplicaciones, el modelo EDM para diseño inicial y el modelo PAM para post-arquitectura. El modelo ACM se utiliza principalmente en las primeras etapas y se basa en puntos de objeto para estimar el esfuerzo requerido para aplicaciones diversificadas mediante el uso de prototipos. El documento proporciona un ejemplo de cómo aplicar el modelo ACM para estimar el esfuerzo en persona-
Este documento presenta 10 ejercicios propuestos para practicar estructuras de control repetitivas while y do-while en los lenguajes de programación Pseint y Java. Los ejercicios incluyen contar números de 1 a N, sumar valores ingresados, calcular promedios, y analizar datos dentro de ciertos rangos. El documento provee la lógica de cada ejercicio implementada en ambos lenguajes para que el lector pueda comparar y practicar.
El documento proporciona una introducción al Proceso Racional Unificado (RUP), incluyendo su definición, historia, principios, ciclo de vida y etapas. RUP es una metodología para el desarrollo de software que se centra en la calidad, adaptación y colaboración. Se compone de cuatro fases iterativas: inicio, elaboración, construcción y transición. Cada fase tiene objetivos específicos como establecer requisitos, desarrollar la arquitectura y poner el producto final en manos de los usuarios.
El documento habla sobre los triggers o disparadores SQL. Explica que los triggers son objetos de la base de datos que ejecutan acciones cuando ocurren ciertos eventos como inserciones, modificaciones o borrados. A continuación, muestra un ejemplo de un trigger DML que actualiza el campo "stateChangedDate" con la fecha y hora cuando cambia el estado de un expediente y también inserta un registro en otra tabla con el historial de cambios.
El documento describe la creación de una base de datos para una inmobiliaria utilizando MySQL Workbench. Se crean tablas como Inmueble, Propietario, Cliente y otras utilizando sentencias SQL que definen los campos y claves primarias de cada tabla. Las tablas se relacionan entre sí a través de claves externas para almacenar información sobre propiedades inmobiliarias.
El documento describe la creación de una base de datos para una inmobiliaria utilizando MySQL Workbench. Se crean tablas como Inmueble, Propietario, Cliente y otras utilizando sentencias SQL que definen los campos y claves primarias de cada tabla. Las tablas se relacionan entre sí a través de claves externas para almacenar información sobre propiedades inmobiliarias.
Aplicaciones para sistemas distribuidos slidemarieuri
Esta sencilla presentación contiene la parte inicial para un proyecto de base de datos en mysql ejecutándose a través de una Aplicación Java haciendo uso de NetBeans.
Representa sólo una parte 15% de un proyecto final que se irá adjuntando.
La Materia es Aplicaciones para Ambientes Distribuidos de la Carrera de Licenciatura en Informática del Instituto Tecnológico de Tepic.
Este documento describe las vistas en SQL. Una vista es una tabla virtual derivada de otras tablas reales que permite consultar y en algunos casos actualizar la información de las tablas subyacentes de forma segura y eficiente. Las vistas se definen mediante la instrucción CREATE VIEW y se comportan como tablas normales excepto que no tienen almacenamiento físico.
Este documento presenta un taller sobre el manejo básico de SQL para manipular datos de acuerdo a un modelo entidad-relación. El objetivo es generar el código DLL para crear las tablas del modelo, realizar 10 inserciones en cada tabla, borrar todas las tablas con DROP TABLE y volver a crearlas y cargar los datos, y leer el capítulo sobre manejo de tablas.
Este documento describe la creación de datos para una base de datos sobre una nave espacial. Incluye la creación de tablas, restricciones y la introducción de datos. Se crean tablas para dependencias, cámaras, tripulación, servicios, planetas, razas y más. Luego se añaden restricciones de clave primaria y clave foránea. Finalmente, se introducen datos de ejemplo en las tablas.
Este proyecto describe el desarrollo de una base de datos para almacenar información de matrículas de estudiantes. Se identificó la necesidad de eliminar datos redundantes al almacenar información de hermanos y personas que viven en la misma dirección. Se realizó el modelado entidad-relación y la normalización de tablas, y luego se implementó la base de datos en MySQL Workbench. Finalmente, se desarrolló una interfaz en Java usando JDBC para interactuar con la base de datos.
Este documento proporciona una introducción a Oracle SQL*Plus. Explica qué es SQL*Plus, sus características y cómo se puede usar para conectarse a una base de datos Oracle, ejecutar comandos SQL e interactuar con tablas y datos. También cubre temas como la revisión de objetos creados, la manipulación de cadenas y los diferentes tipos de comandos disponibles en SQL*Plus.
Este documento describe un script AGI para enrutar llamadas entrantes a agentes apropiados basados en si el número de llamada es nuevo o existente en la base de datos CDR. La sección A1 lee los parámetros AGI. La sección A2 consulta la base de datos para verificar si el número ya existe. La sección A3 envía la llamada al grupo de extensiones correspondiente para clientes nuevos o existentes dependiendo del resultado de la consulta.
El documento describe la creación de una base de datos llamada BD_agropecuario. Se definen varias tablas y reglas para almacenar datos de personas, estudiantes, padres, teléfonos, instituciones educativas y más. También se crean procedimientos para insertar registros en las tablas de personas, familiares y teléfonos, con el fin de normalizar y relacionar la información almacenada.
Este documento presenta una guía de prácticas para enseñar el lenguaje SQL a estudiantes. Explica cómo crear y utilizar una base de datos sencilla en MySQL y phpMyAdmin. Luego describe actividades como crear tablas, insertar datos y ejecutar consultas SQL. Finalmente, presenta tablas relacionadas como ventas y detalles de ventas y ejemplos de consultas entre tablas.
El documento describe varios comandos mysqladmin para administrar una base de datos MySQL, incluyendo establecer un password de root, verificar el estado del servidor, ver la versión de MySQL, crear y eliminar bases de datos, y refrescar privilegios y tablas. También cubre cómo conectarse a un servidor remoto y ejecutar comandos en él, así como iniciar y detener la replicación.
Este documento describe cómo realizar la fragmentación vertical de datos entre dos máquinas virtuales usando MySQL. Primero, se configura el archivo my.ini en el servidor remoto para habilitar la federación. Luego, se crea un usuario con permisos y una tabla federada en el cliente que apunta a la tabla completa en el servidor. Esto permite que los datos se fragmenten verticalmente con algunas columnas en cada máquina.
El documento proporciona instrucciones SQL para realizar transacciones en una base de datos MySQL. Se crea una base de datos llamada CLIENTES y una tabla CUSTOMER dentro de ella. Luego se muestran ejemplos de cómo iniciar y confirmar transacciones para insertar y modificar registros, así como cancelar una transacción mediante ROLLBACK. Finalmente, se piden ejercicios adicionales para practicar transacciones.
Este documento proporciona instrucciones para instalar y configurar MySQL por primera vez en sistemas Linux y Windows. Describe los pasos para activar MySQL, crear bases de datos y tablas, administrar usuarios y permisos, y realizar operaciones básicas como consultas, inserciones y actualizaciones de datos. También explica los diferentes tipos de datos soportados y cómo modificar la estructura de las tablas.
Este documento proporciona instrucciones para instalar y configurar MySQL por primera vez en sistemas Linux y Windows. Describe los pasos para activar MySQL, crear bases de datos y tablas, administrar usuarios y permisos, y realizar operaciones básicas como consultas, inserciones y actualizaciones de datos. También explica los diferentes tipos de datos soportados y cómo modificar la estructura de tablas.
El documento describe la vulnerabilidad de inyección SQL y cómo puede explotarse para mapear una base de datos, modificar datos y ejecutar comandos en el sistema subyacente. Se presenta un escenario de una compañía móvil cuya aplicación web contiene vulnerabilidades SQL que permiten a un atacante consultar tablas de la base de datos, actualizar datos de clientes y ejecutar comandos del sistema mediante la inyección de consultas SQL maliciosas.
Similar a toaz.info-lenguaje-estructurado-de-consultas-sql-pr_bc053c6a01315177312c034660a01e6e.pdf (19)
Son etiquetas de advertencia que están pegadas en las maquinarias pesadas, Caterpillar, Komatsu, Volvo etc., para evitar accidentes durante la operación y mantenimiento en la operación de equipos pesados por los operadores y mecánicos.
Las etiquetas de advertencia fueron primeramente pura letras y en Ingles ,luego letras y una imagen , y ahora solo es Imagen que el operador tiene que describir el riesgo y evitar los accidentes de acuerdo a la imagen que esta en los equipos pesados.
algo sucedio_letra y acordes de guitarra.pdfAni Ann
Puedes encontrar el video y el archivo para descargar en mi blog:
https://labitacoradeann.blogspot.com/2021/07/algo-sucedio-me-cambio-cover-con-letra.html
Catálogo General Ideal Standard 2024 Amado Salvador Distribuidor Oficial Vale...AMADO SALVADOR
Amado Salvador, como distribuidor oficial, te ofrece el catálogo completo de productos de Ideal Standard, líder indiscutible en soluciones para baños. Descubre el último catálogo de Ideal Standard y conoce la amplia gama de productos de calidad insuperable, como cerámica sanitaria, grifería y accesorios, bañeras e hidromasaje, platos de ducha y mobiliario de baño.
Ideal Standard es reconocido mundialmente por su diseño excepcional, calidad incomparable y una tradición de excelencia que perdura en el sector. Como distribuidor oficial de Ideal Standard, Amado Salvador te ofrece acceso a una variedad de productos diseñados para satisfacer las necesidades más exigentes en cuanto a estilo, funcionalidad y durabilidad.
Desde elegantes lavabos hasta innovadoras soluciones de grifería, cada producto de Ideal Standard refleja el compromiso de la marca con la excelencia y la innovación. Amado Salvador, como distribuidor oficial de Ideal Standard, brinda acceso directo a sus productos que combinan estilo, confort y rendimiento.
Explora el último catálogo de Ideal standard y descubre por qué es la elección preferida de profesionales y clientes exigentes en todo el mundo. Confía en Amado Salvador como tu distribuidor oficial para obtener los productos de calidad de Ideal Standard que transformarán tu baño en un espacio de lujo y comodidad.
2. AP06-AA7-EV02. Lenguaje Estructurado de Consultas SQL.
Modelo Entidad Relación
-- MySQL Workbench Forward Engineering
SET @OLD_UNIQUE_CHECKS=@@UNIQUE_CHECKS, UNIQUE_CHECKS=0;
SET @OLD_FOREIGN_KEY_CHECKS=@@FOREIGN_KEY_CHECKS, FOREIGN_KEY_CHECKS=0;
SET @OLD_SQL_MODE=@@SQL_MODE,
SQL_MODE='ONLY_FULL_GROUP_BY,STRICT_TRANS_TABLES,NO_ZERO_IN_DATE,NO_ZERO_DATE
,ERROR_FOR_DIVISION_BY_ZERO,NO_ENGINE_SUBSTITUTION';
-- -----------------------------------------------------
-- Schema Solicitud
-- -----------------------------------------------------
DROP SCHEMA IF EXISTS `Solicitud` ;
-- -----------------------------------------------------
3. -- Schema Solicitud
-- -----------------------------------------------------
CREATE SCHEMA IF NOT EXISTS `Solicitud` DEFAULT CHARACTER SET utf8 ;
-- -----------------------------------------------------
-- Schema Proyecto_Solicitud_Servicio
-- -----------------------------------------------------
DROP SCHEMA IF EXISTS `Proyecto_Solicitud_Servicio` ;
-- -----------------------------------------------------
-- Schema Proyecto_Solicitud_Servicio
-- -----------------------------------------------------
CREATE SCHEMA IF NOT EXISTS `Proyecto_Solicitud_Servicio` DEFAULT CHARACTER SET latin1 ;
USE `Solicitud` ;
-- -----------------------------------------------------
-- Table `Solicitud`.`categoria`
-- -----------------------------------------------------
DROP TABLE IF EXISTS `Solicitud`.`categoria` ;
CREATE TABLE IF NOT EXISTS `Solicitud`.`categoria` (
`idcategoria` INT NOT NULL,
`Nombre` VARCHAR(45) NULL,
`Servicio_idServicio` INT NOT NULL,
PRIMARY KEY (`idcategoria`),
INDEX `fk_categoria_producto1_idx` (`Servicio_idServicio` ASC) VISIBLE,
CONSTRAINT `fk_categoria_producto1`
4. FOREIGN KEY (`Servicio_idServicio`)
REFERENCES `Solicitud`.`Servicio` (`idServicio`)
ON DELETE NO ACTION
ON UPDATE NO ACTION)
ENGINE = InnoDB;
-- -----------------------------------------------------
-- Table `Solicitud`.`categoria`
-- -----------------------------------------------------
DROP TABLE IF EXISTS `Solicitud`.`categoria` ;
CREATE TABLE IF NOT EXISTS `Solicitud`.`categoria` (
`idcategoria` INT NOT NULL,
`Nombre` VARCHAR(45) NULL,
`Servicio_idServicio` INT NOT NULL,
PRIMARY KEY (`idcategoria`),
INDEX `fk_categoria_producto1_idx` (`Servicio_idServicio` ASC) VISIBLE,
CONSTRAINT `fk_categoria_producto1`
FOREIGN KEY (`Servicio_idServicio`)
REFERENCES `Solicitud`.`Servicio` (`idServicio`)
ON DELETE NO ACTION
ON UPDATE NO ACTION)
ENGINE = InnoDB;
5. -- -----------------------------------------------------
-- Table `Proyecto_Solicitud_Servicio`.`Información Del Servicio`
-- -----------------------------------------------------
DROP TABLE IF EXISTS `Proyecto_Solicitud_Servicio`.`Información Del Servicio` ;
CREATE TABLE IF NOT EXISTS `Proyecto_Solicitud_Servicio`.`Información Del Servicio` (
`idInformación Del Servicio` INT GENERATED ALWAYS AS () VIRTUAL,
`Servicio_idservicio` INT NULL,
PRIMARY KEY (`idInformación Del Servicio`))
ENGINE = InnoDB;
-- -----------------------------------------------------
-- Table `Solicitud`.`Usuario`
-- -----------------------------------------------------
DROP TABLE IF EXISTS `Solicitud`.`Usuario` ;
CREATE TABLE IF NOT EXISTS `Solicitud`.`Usuario` (
`idusuario` INT NOT NULL,
`Nombre` VARCHAR(45) NULL,
`Usuario_idusuario` INT NOT NULL,
PRIMARY KEY (`idusuario`),
INDEX `Usuario_idx` (`idusuario` ASC, `Usuario_idusuario` ASC) VISIBLE,
CONSTRAINT `Usuario`
FOREIGN KEY (`idusuario` , `Usuario_idusuario`)
6. REFERENCES `Proyecto_Solicitud_Servicio`.`Información Del Servicio` (`Servicio_idservicio` ,
`idInformación Del Servicio`)
ON DELETE NO ACTION
ON UPDATE NO ACTION)
ENGINE = InnoDB;
-- -----------------------------------------------------
-- Table `Solicitud`.`Persona`
-- -----------------------------------------------------
DROP TABLE IF EXISTS `Solicitud`.`Persona` ;
CREATE TABLE IF NOT EXISTS `Solicitud`.`Persona` (
`idpersona` INT UNSIGNED NOT NULL AUTO_INCREMENT,
`Nombre` VARCHAR(45) GENERATED ALWAYS AS () VIRTUAL,
`Apellido` VARCHAR(45) GENERATED ALWAYS AS (),
`Razon Social` VARCHAR(45) GENERATED ALWAYS AS () VIRTUAL,
`Direccion` VARCHAR(45) GENERATED ALWAYS AS (),
`Telefono` VARCHAR(45) GENERATED ALWAYS AS (),
`Nickname` VARCHAR(100) NOT NULL,
`contrasena` VARCHAR(100) NOT NULL,
`E-mail` VARCHAR(100) GENERATED ALWAYS AS () VIRTUAL,
PRIMARY KEY (`idpersona`),
CONSTRAINT `Persona`
FOREIGN KEY ()
REFERENCES `Solicitud`.`Usuario` ()
7. ON DELETE NO ACTION
ON UPDATE NO ACTION)
ENGINE = InnoDB;
-- -----------------------------------------------------
-- Table `Solicitud`.`Cliente`
-- -----------------------------------------------------
DROP TABLE IF EXISTS `Solicitud`.`Cliente` ;
CREATE TABLE IF NOT EXISTS `Solicitud`.`Cliente` (
`idcliente` INT NOT NULL,
`persona_idpersona` INT NOT NULL,
`Fecha_alta` DATE NOT NULL,
`Enable` TINYTEXT NOT NULL DEFAULT '1',
PRIMARY KEY (`idcliente`),
INDEX `fk_cliente_persona_idx` (`persona_idpersona` ASC) VISIBLE,
CONSTRAINT `fk_cliente_persona`
FOREIGN KEY (`persona_idpersona`)
REFERENCES `Solicitud`.`Persona` (`idpersona`)
ON DELETE NO ACTION
ON UPDATE NO ACTION)
ENGINE = InnoDB;
-- -----------------------------------------------------
8. -- Table `Solicitud`.`Servicio`
-- -----------------------------------------------------
DROP TABLE IF EXISTS `Solicitud`.`Servicio` ;
CREATE TABLE IF NOT EXISTS `Solicitud`.`Servicio` (
`idServicio` INT NOT NULL,
`Tipo_servicio` VARCHAR(45) NULL,
`Cantidad` INT NULL,
`PrecioUnitario` DECIMAL(5) NULL,
`PrecioFinal` DECIMAL(5) NULL,
`categoria_idcategoria` INT NOT NULL,
`Servicio_idServicioventa` INT NOT NULL,
PRIMARY KEY (`idServicio`),
INDEX `fk_producto_categoria1_idx` (`categoria_idcategoria` ASC) VISIBLE,
INDEX `fk_Servicio_Servicio1_idx` (`Servicio_idServicioventa` ASC) VISIBLE,
CONSTRAINT `fk_producto_categoria1`
FOREIGN KEY (`categoria_idcategoria`)
REFERENCES `Solicitud`.`categoria` (`idcategoria`)
ON DELETE NO ACTION
ON UPDATE NO ACTION,
CONSTRAINT `fk_Servicio_Servicio1`
FOREIGN KEY (`Servicio_idServicioventa`)
REFERENCES `Solicitud`.`Servicio` (`idServicioventa`)
ON DELETE NO ACTION
ON UPDATE NO ACTION)
ENGINE = InnoDB;
9. -- -----------------------------------------------------
-- Table `Solicitud`.`categoria`
-- -----------------------------------------------------
DROP TABLE IF EXISTS `Solicitud`.`categoria` ;
CREATE TABLE IF NOT EXISTS `Solicitud`.`categoria` (
`idcategoria` INT NOT NULL,
`Nombre` VARCHAR(45) NULL,
`Servicio_idServicio` INT NOT NULL,
PRIMARY KEY (`idcategoria`),
INDEX `fk_categoria_producto1_idx` (`Servicio_idServicio` ASC) VISIBLE,
CONSTRAINT `fk_categoria_producto1`
FOREIGN KEY (`Servicio_idServicio`)
REFERENCES `Solicitud`.`Servicio` (`idServicio`)
ON DELETE NO ACTION
ON UPDATE NO ACTION)
ENGINE = InnoDB;
-- -----------------------------------------------------
-- Table `Solicitud`.`Servicio`
-- -----------------------------------------------------
DROP TABLE IF EXISTS `Solicitud`.`Servicio` ;
10. CREATE TABLE IF NOT EXISTS `Solicitud`.`Servicio` (
`idServicio` INT NOT NULL,
`Tipo_servicio` VARCHAR(45) NULL,
`Cantidad` INT NULL,
`PrecioUnitario` DECIMAL(5) NULL,
`PrecioFinal` DECIMAL(5) NULL,
`categoria_idcategoria` INT NOT NULL,
`Servicio_idServicioventa` INT NOT NULL,
PRIMARY KEY (`idServicio`),
INDEX `fk_producto_categoria1_idx` (`categoria_idcategoria` ASC) VISIBLE,
INDEX `fk_Servicio_Servicio1_idx` (`Servicio_idServicioventa` ASC) VISIBLE,
CONSTRAINT `fk_producto_categoria1`
FOREIGN KEY (`categoria_idcategoria`)
REFERENCES `Solicitud`.`categoria` (`idcategoria`)
ON DELETE NO ACTION
ON UPDATE NO ACTION,
CONSTRAINT `fk_Servicio_Servicio1`
FOREIGN KEY (`Servicio_idServicioventa`)
REFERENCES `Solicitud`.`Servicio` (`idServicioventa`)
ON DELETE NO ACTION
ON UPDATE NO ACTION)
ENGINE = InnoDB;
USE `Proyecto_Solicitud_Servicio` ;
-- -----------------------------------------------------
11. -- Table `Proyecto_Solicitud_Servicio`.`persona`
-- -----------------------------------------------------
DROP TABLE IF EXISTS `Proyecto_Solicitud_Servicio`.`persona` ;
CREATE TABLE IF NOT EXISTS `Proyecto_Solicitud_Servicio`.`persona` (
`idpersona` INT(20) NOT NULL,
`Nombre` TEXT NOT NULL,
`Apellido` TEXT NOT NULL,
`Genero` TEXT NOT NULL,
`Direccion` TEXT NOT NULL,
`E-mail` TEXT NOT NULL,
`Telefono` INT(20) NOT NULL,
`FechaNacimiento` DATE NOT NULL,
`Fecha-Hora-Ingreso` DATETIME NOT NULL,
`Contrasena` FLOAT NOT NULL,
PRIMARY KEY (`idpersona`))
ENGINE = InnoDB
DEFAULT CHARACTER SET = latin1;
-- -----------------------------------------------------
-- Table `Proyecto_Solicitud_Servicio`.`Cliente`
-- -----------------------------------------------------
DROP TABLE IF EXISTS `Proyecto_Solicitud_Servicio`.`Cliente` ;
CREATE TABLE IF NOT EXISTS `Proyecto_Solicitud_Servicio`.`Cliente` (
12. `idcliente` INT(20) NOT NULL,
`persona_id persona` INT(20) NOT NULL,
PRIMARY KEY (`idcliente`),
INDEX `fk_cliente_persona1_idx` (`persona_id persona` ASC) VISIBLE,
CONSTRAINT `fk_cliente_persona1`
FOREIGN KEY (`persona_id persona`)
REFERENCES `Proyecto_Solicitud_Servicio`.`persona` (`idpersona`)
ON DELETE NO ACTION
ON UPDATE NO ACTION)
ENGINE = InnoDB
DEFAULT CHARACTER SET = latin1;
-- -----------------------------------------------------
-- Table `Proyecto_Solicitud_Servicio`.`Usuario`
-- -----------------------------------------------------
DROP TABLE IF EXISTS `Proyecto_Solicitud_Servicio`.`Usuario` ;
CREATE TABLE IF NOT EXISTS `Proyecto_Solicitud_Servicio`.`Usuario` (
`idusuario` INT(20) NOT NULL,
`persona_id persona` INT(20) NOT NULL,
PRIMARY KEY (`idusuario`),
INDEX `fk_usuario_persona1_idx` (`persona_id persona` ASC) VISIBLE,
CONSTRAINT `fk_usuario_persona1`
FOREIGN KEY (`persona_id persona`)
REFERENCES `Proyecto_Solicitud_Servicio`.`persona` (`idpersona`)
13. ON DELETE NO ACTION
ON UPDATE NO ACTION)
ENGINE = InnoDB
DEFAULT CHARACTER SET = latin1;
-- -----------------------------------------------------
-- Table `Proyecto_Solicitud_Servicio`.`Informacion_Servicio`
-- -----------------------------------------------------
DROP TABLE IF EXISTS `Proyecto_Solicitud_Servicio`.`Informacion_Servicio` ;
CREATE TABLE IF NOT EXISTS `Proyecto_Solicitud_Servicio`.`Informacion_Servicio` (
`idCliente` INT(20) NOT NULL AUTO_INCREMENT,
`idServicio` DECIMAL(10,0) NOT NULL,
`usuario_id usuario` INT(20) NOT NULL,
PRIMARY KEY (`idCliente`, `idServicio`),
INDEX `fk_compras_usuario1_idx` (`usuario_id usuario` ASC) VISIBLE,
CONSTRAINT `fk_compras_usuario1`
FOREIGN KEY (`usuario_id usuario`)
REFERENCES `Proyecto_Solicitud_Servicio`.`Usuario` (`idusuario`)
ON DELETE NO ACTION
ON UPDATE NO ACTION)
ENGINE = InnoDB
DEFAULT CHARACTER SET = latin1;
14. -- -----------------------------------------------------
-- Table `Proyecto_Solicitud_Servicio`.`producto`
-- -----------------------------------------------------
DROP TABLE IF EXISTS `Proyecto_Solicitud_Servicio`.`producto` ;
CREATE TABLE IF NOT EXISTS `Proyecto_Solicitud_Servicio`.`producto` (
`idproducto` INT(20) NOT NULL,
`nombre` TEXT NOT NULL,
`cantidad` INT(10) NOT NULL,
`valor_inicial` DECIMAL(10,0) NOT NULL,
`valor_final` DECIMAL(10,0) NOT NULL,
`categoria_idcategoria` INT NOT NULL,
PRIMARY KEY (`idproducto`),
INDEX `fk_producto_categoria1_idx` (`categoria_idcategoria` ASC) VISIBLE,
CONSTRAINT `fk_producto_categoria1`
FOREIGN KEY (`categoria_idcategoria`)
REFERENCES `Solicitud`.`categoria` (`idcategoria`)
ON DELETE NO ACTION
ON UPDATE NO ACTION)
ENGINE = InnoDB
DEFAULT CHARACTER SET = latin1;
-- -----------------------------------------------------
-- Table `Proyecto_Solicitud_Servicio`.`Detalle Servicio`
-- -----------------------------------------------------
15. DROP TABLE IF EXISTS `Proyecto_Solicitud_Servicio`.`Detalle Servicio` ;
CREATE TABLE IF NOT EXISTS `Proyecto_Solicitud_Servicio`.`Detalle Servicio` (
`iddetalle Servicio` INT(20) NOT NULL,
`Servicio_id Servicio` INT(20) NOT NULL,
PRIMARY KEY (`iddetalle Servicio`),
INDEX `fk_detalle compras_producto1_idx` (`Servicio_id Servicio` ASC) VISIBLE,
CONSTRAINT `fk_detalle compras_producto1`
FOREIGN KEY (`Servicio_id Servicio`)
REFERENCES `Proyecto_Solicitud_Servicio`.`producto` (`idproducto`)
ON DELETE NO ACTION
ON UPDATE NO ACTION)
ENGINE = InnoDB
DEFAULT CHARACTER SET = latin1;
-- -----------------------------------------------------
-- Table `Proyecto_Solicitud_Servicio`.`Solicitud`
-- -----------------------------------------------------
DROP TABLE IF EXISTS `Proyecto_Solicitud_Servicio`.`Solicitud` ;
CREATE TABLE IF NOT EXISTS `Proyecto_Solicitud_Servicio`.`Solicitud` (
`idSolicitud` INT(20) NOT NULL,
`valor_total` DECIMAL(10,0) NOT NULL,
`cliente_id cliente` INT(20) NOT NULL,
`usuario_id usuario` INT(20) NOT NULL,
16. PRIMARY KEY (`idSolicitud`),
INDEX `fk_ventas_cliente1_idx` (`cliente_id cliente` ASC) VISIBLE,
INDEX `fk_ventas_usuario1_idx` (`usuario_id usuario` ASC) VISIBLE,
CONSTRAINT `fk_ventas_cliente1`
FOREIGN KEY (`cliente_id cliente`)
REFERENCES `Proyecto_Solicitud_Servicio`.`Cliente` (`idcliente`)
ON DELETE NO ACTION
ON UPDATE NO ACTION,
CONSTRAINT `fk_ventas_usuario1`
FOREIGN KEY (`usuario_id usuario`)
REFERENCES `Proyecto_Solicitud_Servicio`.`Usuario` (`idusuario`)
ON DELETE NO ACTION
ON UPDATE NO ACTION)
ENGINE = InnoDB
DEFAULT CHARACTER SET = latin1;
-- -----------------------------------------------------
-- Table `Proyecto_Solicitud_Servicio`.`detalle`
-- -----------------------------------------------------
DROP TABLE IF EXISTS `Proyecto_Solicitud_Servicio`.`detalle` ;
CREATE TABLE IF NOT EXISTS `Proyecto_Solicitud_Servicio`.`detalle` (
`iddetalle` INT(20) NOT NULL,
`ventas_id venta` INT(20) NOT NULL,
`Servicio_id Servicio` INT(20) NOT NULL,
17. PRIMARY KEY (`iddetalle`),
INDEX `fk_detalle venta_ventas1_idx` (`ventas_id venta` ASC) VISIBLE,
INDEX `fk_detalle venta_producto1_idx` (`Servicio_id Servicio` ASC) VISIBLE,
CONSTRAINT `fk_detalle venta_ventas1`
FOREIGN KEY (`ventas_id venta`)
REFERENCES `Proyecto_Solicitud_Servicio`.`Solicitud` (`idSolicitud`)
ON DELETE NO ACTION
ON UPDATE NO ACTION,
CONSTRAINT `fk_detalle venta_producto1`
FOREIGN KEY (`Servicio_id Servicio`)
REFERENCES `Proyecto_Solicitud_Servicio`.`producto` (`idproducto`)
ON DELETE NO ACTION
ON UPDATE NO ACTION)
ENGINE = InnoDB
DEFAULT CHARACTER SET = latin1;
-- -----------------------------------------------------
-- Table `Proyecto_Solicitud_Servicio`.`Consultoria`
-- -----------------------------------------------------
DROP TABLE IF EXISTS `Proyecto_Solicitud_Servicio`.`Consultoria` ;
CREATE TABLE IF NOT EXISTS `Proyecto_Solicitud_Servicio`.`Consultoria` (
`idConsultoria` INT(20) NOT NULL,
`Consultoria_id Consultoria` INT(20) NOT NULL,
PRIMARY KEY (`idConsultoria`),
18. INDEX `fk_proveedor_persona_idx` (`Consultoria_id Consultoria` ASC) VISIBLE,
CONSTRAINT `fk_proveedor_persona`
FOREIGN KEY (`Consultoria_id Consultoria`)
REFERENCES `Proyecto_Solicitud_Servicio`.`persona` (`idpersona`)
ON DELETE NO ACTION
ON UPDATE NO ACTION)
ENGINE = InnoDB
DEFAULT CHARACTER SET = latin1;
SET SQL_MODE=@OLD_SQL_MODE;
SET FOREIGN_KEY_CHECKS=@OLD_FOREIGN_KEY_CHECKS;
SET UNIQUE_CHECKS=@OLD_UNIQUE_CHECKS;