Mensajes

Saludos

Tengo la siguiente tabla que se llama partidas_pedidos que cuenta con los siguientes campos:

id_pedido,cliente,fecha_pedido,producto,cantidad

y luego me hace una consulta que dice :

Listar los valores de id_pedido, cliente y producto de la tabla partidas_pedidos, cuya compra se haya efectuado en un mes de abril. Suponga que el campo fecha_pedido sea de tipo char(10).

SELECT id_pedido,cliente,producto FROM partidas_pedidos WHERE fecha_pedido LIKE '';

el problema es que no se que ponerle en las comillas del LIKE'', si la fecha es algo como:  2000-04-01  como ponerle que la fecha tiene que ser en el mes de abril??

y luego si tengo una tabla que se llama info_clientes con los campos: id_cliente,nombre,apellido,ciudad y estado. La consulta dice:

Desplegar la información de los clientes cuyo apellido empiece con 'H' y termine con 'A' y viva en un estado cuyo nombre lo formen 7 letras.

SELECT *FROM info_clientes
WHERE apellido LIKE 'H%' AND apellido LIKE '%A' AND estado='';

pero aqui no se como verificar que el estado este conformado por solo 7 letras, tedria que usar el COUT(*)???

gracias

[Darhius]

muchas gracias por tu respuestaDarhius, una ultima pregunta si yo quiero respaldar la base de datos que acabo de hacer en un archivo.txt, como lo hago?? que comando tengo que usar?

Saludos, ya puede instalar bien el postgres y ahora estoy creando dos tablas, una con datos de un empleado y otra del departamento al que pertence

CREATE TABLE compania.empleado (
    codigo       INT,
    nombrep      VARCHAR(15)    NOT NULL,
    apellido     VARCHAR(15)    NOT NULL,
    sexo         CHAR           DEFAULT 'M',
    salario      DECIMAL(10,2),
    nd           INT            NOT NULL,

   CONSTRAINT pk_empleado PRIMARY KEY (codigo)
);

esta es la primer tabla, y la segunda es:

CREATE TABLE compania.departamento (
    numerod      INT            NOT NULL,
    nombred      VARCHAR(25)    NOT NULL,
    gerente      CHAR(9)        NOT NULL,

   CONSTRAINT pk_departamento PRIMARY KEY(numerod)
);

despues el ejercicio me dice que tengo que definir una llave foranea que apunte al departamento al que pertenece el empleado (nd) y hago lo siguiente:

ALTER TABLE compania.empleado ADD CONSTRAINT restriccion FOREIGN KEY(nd) REFERENCES compania.departamento(numerod);

no me marca error, pero no se si he hecho la llave correctamente, y antes de seguir agregandole cosas a las tablas quiero saber si esta mal

gracias

es dentro del cmd

Saludos

estoy empezando a utilizar postgres, el problema que tengo es que después de instalarlo cuando quiero ir a donde esta la carpeta pgsql que tengo en el escritorio y escribo esto:

C:Users>Invitado>cd Escritorio

me aparece el mensaje

El sistema no puede encontrar la ruta especificada

y no entiendo por qué me aparece esto, me dijeron que lo hiciera en una cuenta diferente a la de Administrador y eso hice pero aun asi no funciona

gracias

Saludos tengo el siguiente archivo de texto que dice:

;ejemplo con errores
Et12_xyz123     ADCA      1,PC
%ET3        LDAA      #$90
Netq%23        RMB      556
etv1
XYZ        Ldaaxyz   4
        %XYZ
        a.c.      %1111000
Abc        SWI%

y el codigo me tiene que imprimir esto

COMENTARIO

ETIQUETA = Et12_xyz123
CODOP =ADCA
OPERANDO = 1,PC
.....
....
....

y asi con todas las lineas, pero me imprime

COMENTARIO

NO SE ENCONTRO CODOP

y no entiendo por que imprime esto ultimo si solo en las lineas que no son comentarios me tiene que verificar si se encontro el codop o no

el codigo es este:

Código (c) [Seleccionar] Expandir

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#define LONG_ETIQUETA 8
#define LONG_CODOP 5
#define COMENTARIO ';'
#define TABULADOR '\t'
#define ESPACIOS_ ' '
#define MAX 8
#define MAXIMO 40

typedef enum {FALSO,VERDADERO} booleano;
typedef enum {ETIQUETA,CODOP,OPERANDO} linea;
typedef enum {INS,OP,DIR,MAQ,CALCULADO,CALCULAR,TOTAL} tabla;

typedef struct nodo
{
   char *instruccion;
   char *operando;
   char **modo_direccionamiento;
   char **codigo_maquina;
   char **bytes_calculados;
   char **bytes_x_calcular;
   char **suma_bytes;
   int tipo_linea;
   struct nodo *sig;
}COD;

void imprimirInfo(COD *p);
int verificarCombinacion(FILE *fd);
booleano esComentario(FILE *fd);
char *Etiqueta_Codop_Operando(FILE *fd,int linea);
char *_Codop_Operando(FILE *fd,int linea);
void ultimaLinea(char *codop);
void erroresEtiqueta(char *etiqueta);
void erroresCodop(char *codop);
void buscarFinLinea(FILE *fd);
void ignorarEspacios(FILE *fd);
void listaTABOP(COD **cabeza);
COD *ultimoElemento(COD **cabeza);
COD *crearNodo(char *ins,char *op,char **dir,char **maq,char **cal,char **x_cal,char **sum,int n);
void insertarFinal(char *ins,char *op,char **dir,char **maq,char **cal,char **x_cal,char **sum,COD *ultimo,int n);
char *Tabla_Operandos(FILE *hc12,int tabla);
COD *buscarCodop(COD *cabeza,char *codop);
void quitarSaltosLinea(char *cadena);
booleano esNumero(char caracter);
booleano esLetra(char caracter);
void verificarOperando(COD *encontrado,char *operando);

int main()
{
   FILE *fd;
   int car,combinacion;
   COD *cabeza = NULL,*encontrado = NULL;
   char nombre[MAXIMO],archivo[MAXIMO],respuesta,*etiqueta,*codop,*operando;
   listaTABOP(&cabeza);
   do
   {
       printf("\nQue archivo quieres abrir: ");
       fgets(nombre,sizeof(nombre),stdin);
       quitarSaltosLinea(nombre);
       sprintf(archivo,"%s.txt",nombre);
       if((fd = fopen(archivo,"r"))!= NULL)
       {
           while((car = fgetc(fd))!= EOF)
           {
               switch(car)
               {
                   case COMENTARIO:
                      if(esComentario(fd))
                         printf("COMENTARIO\n\n");
                      else
                         buscarFinLinea(fd);
                      break;
                   case ESPACIOS_:
                   case TABULADOR:
                      etiqueta = "null";
                      printf("ETIQUETA = %s\n",etiqueta);
                      ignorarEspacios(fd);
                      codop = Etiqueta_Codop_Operando(fd,CODOP);
                      printf("CODOP = %s\n",codop);
                      erroresCodop(codop);
                      combinacion = verificarCombinacion(fd);
                      if(combinacion == 2)
                      {
                          operando = "null";
                          printf("OPERANDO = %s\n\n",operando);
                      }
                      else
                      {
                          ignorarEspacios(fd);
                          operando = Etiqueta_Codop_Operando(fd,OPERANDO);
                          printf("OPERANDO = %s\n\n",operando);
                      }
                      break;
                   default:
                      etiqueta = Etiqueta_Codop_Operando(fd,ETIQUETA);
                      printf("ETIQUETA = %s\n",etiqueta);
                      erroresEtiqueta(etiqueta);
                      combinacion = verificarCombinacion(fd);
                      if(combinacion == 2)
                      {
                          codop = "null";
                          printf("CODOP = %s\n",codop);
                          erroresCodop(codop);
                          operando = "null";
                          printf("OPERANDO = %s\n\n",operando);
                      }
                      else
                      {
                          ignorarEspacios(fd);
                          codop = Etiqueta_Codop_Operando(fd,CODOP);
                          printf("CODOP = %s\n",codop);
                          erroresCodop(codop);
                          combinacion = verificarCombinacion(fd);
                          if(combinacion == 2)
                          {
                              operando = "null";
                              printf("OPERANDO = %s\n\n",operando);
                          }
                          else
                          {
                              ignorarEspacios(fd);
                              operando = Etiqueta_Codop_Operando(fd,OPERANDO);
                              printf("OPERANDO = %s\n\n",operando);
                          }
                      }
                      break;
               }
               if((strcmp(codop,"null"))!= 0)
               {
                   if((encontrado = buscarCodop(cabeza,codop)) == NULL)
                      printf("NO SE ENCONTRO EL CODOP DE OPERACION\n\n");
                   else
                   {
                       verificarOperando(encontrado,operando);
                       imprimirInfo(encontrado);
                   }
               }

           }
           ultimaLinea(codop);
       }
       else
          printf("No se pudo abrir el archivo");
       printf("Quieres abrir otro archivo S/N: ");
       fgets(nombre,MAX,stdin);
       sscanf(nombre,"%c",&respuesta);
       system("cls");
   }while(respuesta == 'S' || respuesta == 's');
   return 0;
}

booleano esComentario(FILE *fd)
{
   int car;
   while((car = fgetc(fd))!= '\n')
   {
       if(car == ';')
          return 0;
   }
   return 1;
}

void buscarFinLinea(FILE *fd)
{
   int car;
   while((car = fgetc(fd))!= '\n')
       ;
}

void ignorarEspacios(FILE *fd)
{
   int car;
   do
   {
       car = fgetc(fd);
   }while(car == '\t' || car == ' ');
}

int verificarCombinacion(FILE *fd)
{
   int car,combinacion;
   fseek(fd,-1,SEEK_CUR);
   if((car = fgetc(fd))== '\n')
      combinacion = 2;
   else
      combinacion = 1;
   return combinacion;
}

booleano esLetra(char caracter)
{
   if((caracter >= 'A' && caracter <= 'Z')||(caracter >= 'a' && caracter <= 'z'))
      return 1;
   else
      return 0;
}

booleano esNumero(char caracter)
{
   if(caracter >= '0' && caracter <= '9')
      return 1;
   else
      return 0;
}

char *Etiqueta_Codop_Operando(FILE *fd,int linea)
{
   int car,lon = 0,pos;
   char *cadena;
   fseek(fd,-1,SEEK_CUR);
   pos = ftell(fd);
   if((linea == ETIQUETA)||(linea == CODOP))
   {
       do
       {
           car = fgetc(fd);
           lon++;
       }while(car != '\t' && car != ' ' && car != '\n');
   }
   else
   {
       do
       {
           car = fgetc(fd);
           lon++;
       }while(car != '\n');
   }
   cadena = (char*)calloc((lon+1),sizeof(char));
   fseek(fd,pos,SEEK_SET);
   fgets(cadena,lon+1,fd);
   quitarSaltosLinea(cadena);
   return cadena;
}

void erroresEtiqueta(char *etiqueta)
{
   int tam,i = 0,esEtiqueta = 1;
   tam = strlen(etiqueta);
   if(tam > LONG_ETIQUETA)
      printf("\tError:la longitud maxima de una etiqueta es de 8 caracteres\n");
   if(!esLetra(etiqueta[i]))
      printf("\tError:la etiqueta debe iniciar con letra\n");
   else
   {
       for(i = 0;(i < tam)&&(esEtiqueta);i++)
       {
          if((!esLetra(etiqueta[i]))&&(!esNumero(etiqueta[i]))&&(etiqueta[i] != '_'))
             esEtiqueta = 0;
       }
       if(!esEtiqueta)
          printf("\tError:los caracteres validos en las etiquetas son letras, digitos(0..9) y el guion bajo\n");
   }
}

void erroresCodop(char *codop)
{
   int tam,i = 0,esCodop = 1,punto = 0;
   tam = strlen(codop);
   if(tam > LONG_CODOP)
      printf("\tError:la longitud maxima de un codigo de operacion es de 5 caracteres\n");
   if((strcmp(codop,"null"))== 0)
      printf("\tError:siempre debe de haber un codigo de operacion\n");
   else
   {
       if(!esLetra(codop[i]))
       printf("\tError:los codigos de operacion deben iniciar con letra\n");
       else
       {
           for(i = 1;(i < tam)&&(esCodop)&&(punto>=0&&punto<=1);i++)
           {
               if((!esLetra(codop[i]))&&(codop[i] != '.'))
                  esCodop = 0;
               else if(codop[i] == '.')
                  punto++;
           }
           if(!esCodop)
              printf("\tError:los caracteres validos en un codigo de operacion son letras y el caracter punto\n");
           if(punto > 1)
              printf("\tError:los codigos de operacion no pueden tener mas de un punto\n");
       }
   }
}

void ultimaLinea(char *codop)
{
   int lon1,lon2,i;
   lon1 = strlen(codop);
   lon2 = strlen("end");
   if(lon1 != lon2)
      printf("Error: No se encontro el END.\n");
   else
   {
       for(i = 0;codop[i];i++)
          codop[i] = tolower(codop[i]);
       if((strcmp(codop,"end")) != 0)
          printf("Error: No se encontro el END.\n");
   }
}

void quitarSaltosLinea(char *cadena)
{
   char *ptr;
   if(((ptr=strchr(cadena,'\n'))!=NULL)||((ptr=strchr(cadena,'\t'))!=NULL)||((ptr=strchr(cadena,' '))!=NULL))
      *ptr = '\0';
}

void listaTABOP(COD **cabeza)
{
   int car,i,pos,n;
   FILE *hc12;
   COD *ultimo = NULL;
   char *ins,*op,**dir,**maq,**cal,**x_cal,**sum;
   if((hc12 = fopen("TABOP.txt","r"))!= NULL)
   {
       while((car = fgetc(hc12))!= EOF)
       {
           i = 0;
           ins = Tabla_Operandos(hc12,INS);
           ignorarEspacios(hc12);
           op = Tabla_Operandos(hc12,OP);
           pos = ftell(hc12);
           buscarFinLinea(hc12);
           if((car = fgetc(hc12)) != '\t')
           {
               n = 0;
               fseek(hc12,pos,SEEK_SET);
               ignorarEspacios(hc12);
               dir = (char**)malloc(sizeof(char*));
               dir[i] = Tabla_Operandos(hc12,DIR);
               ignorarEspacios(hc12);
               maq = (char**)malloc(sizeof(char*));
               maq[i] = Tabla_Operandos(hc12,MAQ);
               ignorarEspacios(hc12);
               cal = (char**)malloc(sizeof(char*));
               cal[i] = Tabla_Operandos(hc12,CALCULADO);
               ignorarEspacios(hc12);
               x_cal = (char**)malloc(sizeof(char*));
               x_cal[i] = Tabla_Operandos(hc12,CALCULAR);
               ignorarEspacios(hc12);
               sum = (char**)malloc(sizeof(char*));
               sum[i] = Tabla_Operandos(hc12,TOTAL);
               buscarFinLinea(hc12);
           }
           else
           {
               n = 1;
               fseek(hc12,pos,SEEK_SET);
               dir = (char**)malloc(MAX*sizeof(char*));
               maq = (char**)malloc(MAX*sizeof(char*));
               cal = (char**)malloc(MAX*sizeof(char*));
               x_cal = (char**)malloc(MAX*sizeof(char*));
               sum = (char**)malloc(MAX*sizeof(char*));
               do
               {
                   ignorarEspacios(hc12);
                   dir[i] = Tabla_Operandos(hc12,DIR);
                   ignorarEspacios(hc12);
                   maq[i] = Tabla_Operandos(hc12,MAQ);
                   ignorarEspacios(hc12);
                   cal[i] = Tabla_Operandos(hc12,CALCULADO);
                   ignorarEspacios(hc12);
                   x_cal[i] = Tabla_Operandos(hc12,CALCULAR);
                   ignorarEspacios(hc12);
                   sum[i] = Tabla_Operandos(hc12,TOTAL);
                   buscarFinLinea(hc12);
                   i++;
               }while((car = fgetc(hc12)) == '\t');
               fseek(hc12,-1,SEEK_CUR);
           }
           if(*cabeza == NULL)
              *cabeza = crearNodo(ins,op,dir,maq,cal,x_cal,sum,n);
           else
           {
               ultimo = ultimoElemento(cabeza);
               insertarFinal(ins,op,dir,maq,cal,x_cal,sum,ultimo,n);
           }
       }
   }
   else
      printf("No se pudo abrir el archivo");
}

COD *ultimoElemento(COD **cabeza)
{
   COD *ptr;
   ptr = *cabeza;
   while(ptr->sig != NULL)
      ptr = ptr->sig;
   return ptr;
}

char *Tabla_Operandos(FILE *hc12,int tabla)
{
   int car,lon = 0,pos;
   char *cadena;
   fseek(hc12,-1,SEEK_CUR);
   pos = ftell(hc12);
   if((tabla==INS)||(tabla==OP)||(tabla==DIR)||(tabla==MAQ)||(tabla==CALCULADO)||(tabla==CALCULAR))
   {
       do
       {
           car = fgetc(hc12);
           lon++;
       }while(car != '\t' && car != EOF);
   }
   else
   {
       do
       {
           car = fgetc(hc12);
           lon++;
       }while(car != '\n' && car != EOF);
       lon--;
   }
   fseek(hc12,pos,SEEK_SET);
   cadena = (char*)calloc((lon+1),sizeof(char));
   fgets(cadena,lon+1,hc12);
   quitarSaltosLinea(cadena);
   return cadena;
}

COD *buscarCodop(COD *cabeza,char *codop)
{
   int i;
   COD *ptr;
   for(i = 0;codop[i];i++)
      codop[i] = toupper(codop[i]);
   for(ptr = cabeza;ptr != NULL;ptr = ptr->sig)
   {
       if((strcmp(ptr->instruccion,codop)) == 0)
          return ptr;
   }
   return NULL;
}

void insertarFinal(char *ins,char *op,char **dir,char **maq,char **cal,char **x_cal,char **sum,COD *ultimo,int n)
{
   ultimo->sig = crearNodo(ins,op,dir,maq,cal,x_cal,sum,n);
   ultimo->sig->sig = NULL;
   ultimo = ultimo->sig;
}

COD *crearNodo(char *ins,char *op,char **dir,char **maq,char **cal,char **x_cal,char **sum,int n)
{
   int tam,tam1,tam2,tam3,i;
   COD *x;
   x = (COD*)malloc(sizeof(COD));
   tam = strlen(ins);
   tam1 = strlen(op);
   x->instruccion = (char*)malloc((tam+1)*sizeof(char));
   x->operando = (char*)malloc((tam1+1)*sizeof(char));
   strcpy(x->instruccion,ins);
   strcpy(x->operando,op);
   x->tipo_linea = n;
   if(n == 1)
   {
       x->modo_direccionamiento = (char**)malloc(MAX*sizeof(char*));
       x->codigo_maquina = (char**)malloc(MAX*sizeof(char*));
       x->bytes_calculados = (char**)malloc(MAX*sizeof(char*));
       x->bytes_x_calcular = (char**)malloc(MAX*sizeof(char*));
       x->suma_bytes = (char**)malloc(MAX*sizeof(char*));
       for(i = 0;i < MAX;i++)
       {
           tam2 = strlen(dir[i]);
           x->modo_direccionamiento[i] = (char*)malloc((tam2+1)*sizeof(char));
           strcpy(x->modo_direccionamiento[i],dir[i]);
           tam3 = strlen(maq[i]);
           x->codigo_maquina[i] = (char*)malloc((tam3+1)*sizeof(char));
           strcpy(x->codigo_maquina[i],maq[i]);
           x->bytes_calculados[i] = (char*)malloc(sizeof(char));
           strcpy(x->bytes_calculados[i],cal[i]);
           x->bytes_x_calcular[i] = (char*)malloc(sizeof(char));
           strcpy(x->bytes_x_calcular[i],x_cal[i]);
           x->suma_bytes[i] = (char*)malloc(sizeof(char));
           strcpy(x->suma_bytes[i],sum[i]);
       }
   }
   else
   {
       x->modo_direccionamiento = (char**)malloc(sizeof(char*));
       x->codigo_maquina = (char**)malloc(sizeof(char*));
       x->bytes_calculados = (char**)malloc(sizeof(char*));
       x->bytes_x_calcular = (char**)malloc(sizeof(char*));
       x->suma_bytes = (char**)malloc(sizeof(char*));
       tam2 = strlen(dir[0]);
       x->modo_direccionamiento[0] = (char*)malloc((tam2+1)*sizeof(char));
       strcpy(x->modo_direccionamiento[0],dir[0]);
       tam3 = strlen(maq[0]);
       x->codigo_maquina[0] = (char*)malloc((tam3+1)*sizeof(char));
       strcpy(x->codigo_maquina[0],maq[0]);
       x->bytes_calculados[0] = (char*)malloc(sizeof(char));
       strcpy(x->bytes_calculados[0],cal[0]);
       x->bytes_x_calcular[0] = (char*)malloc(sizeof(char));
       strcpy(x->bytes_x_calcular[0],x_cal[0]);
       x->suma_bytes[0] = (char*)malloc(sizeof(char));
       strcpy(x->suma_bytes[0],sum[0]);
   }
   x->sig = NULL;
   return x;
}

void verificarOperando(COD *encontrado,char *operando)
{
   if((strcmp(encontrado->operando,"SI")) == 0)
   {
       if((strcmp(operando,"null")) == 0)
          printf("EL CODOP DEBE TENER OPERANDO\n");
   }
   else if((strcmp(encontrado->operando,"NO")) == 0)
   {
       if(!(strcmp(operando,"null")) == 0)
          printf("EL CODOP NO DEBE TENER OPERANDO\n");
   }
}

void imprimirInfo(COD *p)
{
   int i,num_lineas;
   printf("\n%s ",p->instruccion);
   if(p->tipo_linea == 1)
      num_lineas = MAX;
   else
      num_lineas = 1;
   for(i = 0;i < num_lineas;i++)
   {
       printf("\t%s\t",p->modo_direccionamiento[i]);
       printf("%s\t",p->codigo_maquina[i]);
       printf("%s\t",p->bytes_calculados[i]);
       printf("%s\t",p->bytes_x_calcular[i]);
       printf("%s\n",p->suma_bytes[i]);
   }
}


gracias de antemano

gracias por sus respuestas, creo que no es considerado buena práctica de programación usar la librería conio.h, me dijeron que también podía hacerlo con eventos de teclado, solo que no he encontrado mucha información de como hacer uno

Saludos

Si por ejemplo yo quiero escribir en un archivo solamente dígitos del 0 al 9, que no se acepte ningun otro caracter, y sin necesidad de hacer ninguna otra validación(como leer el archivo y verificar caracter por caracter que todos sean numeros), hay alguna manera de "bloquear" algunas teclas y que no le permita al usuario ingresar caracteres que no sean numeros?? esto se podria hacer???

muchas gracias a todos por sus respuestas, nunca me hubiera dado cuenta que era la función pow() la que me daba problemas, otra duda: por qué en la linea

entero = operando-'0';

le ponen -'0' en vez de -48??

Saludos

tengo una funcion llamada obtener numero, a la que le paso una cadena como argumento algo como #456 y la base(hex,octal,binaria o decimal), y me regresa un int con el numero(ya sin el #) el problema es que si le ingreso el numero #65536 me imprime que el numero es 65535 y no entiendo por qué imprime eso, ya lo habia probado para numeros de otras bases y lo hacia correctamente no se por que ahora no, solo puse la funcion que me da problemas por que el codigo es un poco largo

Código (c) [Seleccionar] Expandir

int obtenerNumero(char *operando,int base)
{
   int i,potencia,num_decimal = 0,lon,entero,x = 1;
   lon = strlen(operando);
   for(i = lon-1,potencia = 0;i >= x;i--,potencia++)
   {
       if(esLetraBase16(operando[i]))
          entero = hexadecimal(operando[i]);
       else
          entero = operando[i]-48;
       num_decimal+= pow(base,potencia)*entero;
       printf("%d\n",num_decimal);
   }
   printf("[%d]",num_decimal);
   return num_decimal;
}

int hexadecimal(char caracter)
{
   int decimal;
   switch(caracter)
   {
       case 'A':case 'a':
          decimal = 10;
          break;
       case 'B':case 'b':
          decimal = 11;
          break;
       case 'C':case 'c':
          decimal = 12;
          break;
       case 'D':case 'd':
          decimal = 13;
          break;
       case 'E':case 'e':
          decimal = 14;
          break;
       case 'F':case 'f':
          decimal = 15;
          break;
       default:
          printf("!Error!\n");
   }
   return decimal;
}


me imprime

6
36
536
5536
65535

gracias de antemano