sábado, 25 de mayo de 2013

Rutinas almacenadas para la administración de mysql (TRIGGER).

Los trigger o "disparadores", son procedimientos que no usan sql dinámico, no devuelven ningún valor.

Los trigger están asociados a eventos de tablas del tipo insert, delete y update, y dependen del evento NEW y OLD.

Ejemplo de sintaxis de un trigger:

CREATE TRIGGER trigger_name trigger_time trigger_event
    ON tbl_name FOR EACH ROW trigger_body

Explicación traducida:

CREAR DISPARADOR nombre_disparador tiempo_disparador evento_disparador
    EN nombre_tabla PARA CADA FILA cuerpo_disparador
Las partes escritas en mayúsculas, deben ir así siempre al realizar la sentencia correctamente. 


Rutinas almacenadas para la administración de mysql (FUNCTION).

Las function o "funciones", son procedimientos que no usan sql dinámico, devuelven un valor de tipo dado, pero no un conjunto de estos.

Solo aceptan parámetros de entrada.

Ejemplo de sintaxis de una función:

CREATE
    [DEFINER = { user | CURRENT_USER }]
    FUNCTION sp_name ([func_parameter[,...]])
    RETURNS type
    routine_body

func_parameter:
    param_name type

type:
    Any valid MySQL data type

routine_body:
    Valid SQL routine statement
Explicación traducida:
CREAR
    [DEFINER = { usuario | USUARIO_ACTUAL }]
    FUNCIÓN nombre_sp ([parametro_función[,...]])
    DEVOLUCIONES tipo
    cuerpo_rutina

parametro_función:
  nombre tipo_parametro

tipo:
    Cualquier tipo de datos MySQL válida

cuerpo_rutina:
    Declaración de rutina de SQL válido

Las partes escritas en mayúsculas, deben ir así siempre al realizar la sentencia correctamente. 

Rutinas almacenadas para la administración de mysql (PROCEDURE).

Los procedures o procedimientos, son rutinas que tienen la ventaja de poder utilizar sql dinámico.

Los procedures, utilizan parámetros de entrada, salida o entrada-salida y devuelven uno o varios datos.

Para invocar un procedure usamos el comando call.

Ejemplo de sintaxis de un procedure:

CREATE
    PROCEDURE sp_name ([proc_parameter[,...]])
    routine_body

proc_parameter:
    [ IN | OUT | INOUT ] param_name type

type:
    Any valid MySQL data type

routine_body:
    Valid SQL routine statement

Explicación traducida:

CREAR
    PROCEDIMIENTO sp_name ([parametro_procedimiento[,...]])
    cuerpo_rutina

parámetros_procedimiento:
    [ ENTRADA | SALIDA |  ENTRADA/SALIDA] parametro_nombre tipo

tipo:
    Cualquier tipo de datos MySQL válida

cuerpo_rutina:
   Declaración de rutina de SQL válido


Las partes escritas en mayúsculas, deben ir así siempre al realizar la sentencia correctamente.

viernes, 24 de mayo de 2013



Capítulo 3
        
COMPONENTES  BÁSICOS

Un edificio inteligente está dotado de un sistema de control que pretende optimizar de forma integrada ciertas funciones inherentes a la operatividad, administración y mantenimiento del edificio. Para conseguir esta finalidad, el sistema de control necesita comunicarse con el entorno y es necesario un conjunto de sensores que le suministren información, una serie de actuadores que ejecuten sus acciones de control, así como una infraestructura de comunicaciones que los conecte entre sí, y las interfaces y acondicionadores de señal que adapten la señal entre el controlador y los sensores y actuadores. En dicho sistema de control, la elección del hardware será importante, pero también lo es el diseño adecuado del software de control.


Visualizacion de un temporizador software


/* Visualizacion de un temporizador software. */

#include<stdio.h>

#define RETAR 12800000

struct mi_hora {
      int horas;
      int minutos;
      int segundos;
};

/*************************************/
/* Prototipo de funciones ************/
/*************************************/
void mostrar(struct mi_hora *t);
void actualizar(struct mi_hora *t);
void retardo(void);
/*************************************/

int main(void)
{
      struct mi_hora hora;
     
      hora.horas = 0;
      hora.minutos = 0;
      hora.segundos = 0;
     
      for(;;)
      {
            actualizar(&hora);
            mostrar(&hora);
      }// fin de for
           
      system("PAUSE");
      return 0; // terminacion exitosa
     
}// fin de main

void actualizar(struct mi_hora *t)
{
      t-> segundos++;
      if(t-> segundos == 60)
      {
            t-> segundos = 0;
            t-> minutos++;
      }
     
      if(t-> minutos == 60)
      {
            t-> minutos = 0;
            t-> horas++;
      }
     
      if(t-> horas == 24)
            t-> horas = 0;
           
      retardo();
}// fin actualizar

void mostrar(struct mi_hora *t)
{

      printf("%02d:", t-> horas);
      printf("%02d:", t-> minutos);
      printf("%02d:", t-> segundos);
      printf("\n");
           
}// fin de mostrar

void retardo(void)
{
      long int t;
     
      /* cambiese esto segun sea necesario */
      for(t = 1; t < RETAR ; ++t);
}// fin de retardo

Programa de lista de correos (arrays de estructuras)


/*Un sencillo programa de lista de correos que ilustra el uso de
arrays de estructuras. */

#include<stdio.h>
#include<stdlib.h>

#define MAX 100

struct dir {
      char nombre[30];
      char calle[40];
      char ciudad[20];
      char provincia[3];
      unsigned long int codigo;
} lista_dir[MAX];

/* Prototipo de funciones **************/
void inic_lista(void), intro(void);
void borrar(void), listar(void);   
int menu(void), busca_libre(void); 
/***************************************/

int main(void)
{
      char opcion;
     
      inic_lista();     // inicializar el array de estructuras
     
      for(;;)
      {
            opcion = menu();
            switch(opcion)
            {
                  case 1: intro();
                        break;
                  case 2: borrar();
                        break;
                  case 3: listar();
                        break;
                  case 4:     exit(0);
            } //fin de switch
      } //fin de for
     
      system("PAUSE");
      return 0; //terminacion exitosa
}// fin de main

/****************************************************************/
/* Inicializar la lista. ****************************************/
/****************************************************************/
void inic_lista(void)
{
      register int t;
     
      for(t = 0; t < MAX; ++t)     lista_dir[t].nombre[0] = '\0';
}
/****************************************************************/

/*************************************************/
/* Seleccionar una operacion. ********************/
/*************************************************/
int menu(void)
{
      char s[80];
      int c;
     
      printf("1. Introducir un nombre\n");
      printf("2. Borrar un nombre\n");
      printf("3. Listar el archivo\n");
      printf("4. Salir\n");
     
      do
      {
            printf("\nIntroduce tu opcion:  ");
            gets(s);
            c = atoi(s);
      }while(c < 0 || c > 4);  //fin de do_while
     
      return c;
} //fin de menu
/***************************************************/

/**************************************/
/* Introducir direcciones en la lista */
/**************************************/

void intro(void)
{
      int sitio;
      char s[80];
     
      sitio = busca_libre();
     
      if(sitio == -1)
      {
            printf("\nLista llena");
            return;
      }
     
      printf("Introduce el nombre: ");
      gets(lista_dir[sitio].nombre);
     
      printf("Introduce la calle: ");
      gets(lista_dir[sitio].calle);
     
      printf("Introduce la ciudad: ");
      gets(lista_dir[sitio].ciudad);
     
      printf("Introduce las siglas de la provincia:  ");
      gets(lista_dir[sitio].provincia);
     
      printf("Introduzca el codigo postal:  ");
      gets(s);
      lista_dir[sitio].codigo = strtoul(s, '\0', 10);
     
} // fin de intro
/*********************************************************/

/************************************/
/* Buscar una estructura no usada ***/
/************************************/

int busca_libre(void)
{
      register int t;
     
      for( t = 0; lista_dir[t].nombre[0] && t < MAX; ++t);
     
      if(t == MAX) return -1; // no hay sitio libre
      return t;
     
} // fin de busca_libre
/*********************************************************/

/*****************************************************/
/* Eliminar una direccion ****************************/
/*****************************************************/

void borrar(void)
{
      register int sitio;
      char s[80];
     
      printf("Introduce el numero de registro:  ");
      gets(s);
      sitio = atoi(s);
     
      if(sitio >= 0 && sitio < MAX)
            lista_dir[sitio].nombre[0] = '\0';
     
} // fin de borrar
/*****************************************************/

/*****************************************************/
/*  Mostrar la lista en la pantalla ******************/
/*****************************************************/

void listar(void)
{
      register int t;
     
      for(t = 0; t < MAX; ++t)
      {
            if(lista_dir[t].nombre[0])
            {
                  printf("%s\n", lista_dir[t].nombre);
                  printf("%s\n", lista_dir[t].calle);
                  printf("%s\n", lista_dir[t].ciudad);
                  printf("%s\n", lista_dir[t].provincia);
                  printf("%lu\n\n", lista_dir[t].codigo);
           
            }//fin de if
      }//fin de for
      printf("\n\n");
}//fin de listar

/******************************************************/

jueves, 23 de mayo de 2013

Calcular el factorial de un numero utilizando recursividad


#include <stdio.h>

long int fact(int num); //prototipo de funcion

int main()
{
            int n;
           
            printf("Introduzca el valor de n =>  ");
            scanf("%ld", &n);
            printf("\nn! es igual a %8ld",fact(n));
           
            printf("\n\n");
            system("PAUSE");
            return 0;
}

/* definicion de la funcion fact */

long int fact(int num)
{
            if(num == 0)
                        return(1);
            else
                        return(num * fact(num-1));
}