Ejemplos de SQL

Puede acceder a una base de datos SQL de cualquiera de estas formas:
En cualquier caso, puede utilizar un registro SQL como área de memoria y para proporcionar una forma sencilla de comprobar si la operación ha sido satisfactoria. Los ejemplos de esta sección presuponen que se ha declarado un componente de registro en un archivo fuente EGL y que se ha declarado un registro basado en el componente en un programa de ese archivo:

Para obtener más detalles acerca de los registros y las sentencias implícitas SQL, consulte el apartado Soporte SQL.

Codificar sentencias SQL

Para preparar la codificación de sentencias SQL, debe declarar variables:
  empnum decimal(6,0);
  empname char(40);

Añadir una fila a una tabla SQL

Para preparar la adición de una fila, asigne valores a las variables:
  empnum = 1;
  empname = "John";
Para añadir la fila, asocie una sentencia EGL execute con una sentencia SQL INSERT, del siguiente modo:
  try
    execute
      #sql{
        insert into employee (empnum, empname)
        values (:empnum, :empname)
      };
  onException
    myErrorHandler(8);
  end

Leer un conjunto de filas de una tabla SQL

Para preparar la lectura de un conjunto de filas de una tabla SQL, identifique una clave de registro:
  empnum = 1;  
Para obtener los datos, codifique una serie de sentencias EGL:
  • Para seleccionar un conjunto de resultados, ejecute una sentencia EGL open:
      open selectEmp 
        with #sql{
          select empnum, empname
          from employee
          where empnum >= :empnum
          for update of empname    
        }
        into empnum, empname;
  • Para acceder a la fila siguiente del conjunto de resultados, ejecute una sentencia EGL get next:
      get next from selectEmp;        
    Si no ha especificado la cláusula into en la sentencia open, debe especificar la cláusula into en la sentencia get next; si ha especificado la cláusula into en ambas ubicaciones, la cláusula de la sentencia get next tiene preferencia:
      get next from selectEmp
        into empnum, empname;  

    El cursor se cierra automáticamente cuando se lee el último registro del conjunto de resultados.

A continuación se proporciona un ejemplo de código más completo que actualiza un conjunto de filas:
  VGVar.handleHardIOErrors  = 1;

  try
    open selectEmp
      with #sql{
        select empnum, empname
        from employee
        where empnum >= :empnum
        for update of empname
      }
      into empnum, empname;
  onException
    myErrorHandler(6);    // salir del programa
  end

  try 
    get next from selectEmp;
  onException
    if (sqlcode != 100)
      myErrorHandler(8);    // salir del programa
    end 
  end

  while (sqlcode != 100) 
    empname = empname + " " + "III";

    try
      execute
        #sql{
          update employee
          set empname = :empname
          where current of selectEmp
        };
    onException
      myErrorHandler(10); // salir del programa
    end

    try
      get next from selectEmp;
    onException
      if (sqlcode != 100)
        myErrorHandler(8);    // salir del programa
      end 
    end
  end  // fin de while; el cursor se cierra automáticamente
       // cuando se ha leído la última fila del conjunto de resultados

  sysLib.commit();
En lugar de codificar las sentencias get next y while, puede utilizar la sentencia forEach que ejecuta un bloque de sentencias para cada fila de un conjunto de resultados:
  VGVar.handleHardIOErrors  = 1;

  try
    open selectEmp
      with #sql{
        select empnum, empname
        from employee
        where empnum >= :empnum
        for update of empname
      }
      into empnum, empname;
  onException
    myErrorHandler(6);    // salir del programa
  end

  try 
    forEach (from selectEmp)
      empname = empname + " " + "III";
    
      try
        execute
          #sql{
            update employee
            set empname = :empname
          where current of selectEmp
          };
      onException
        myErrorHandler(10); // salir del programa
      end
    end  // fin de forEach; el cursor se cierra automáticamente
         // cuando se ha leído la última fila del conjunto de resultados

  onException
    // el bloque de excepción relacionado con forEach no se ejecuta si la condición 
    // es "sqlcode = 100", así que evite la prueba "if (sqlcode != 100)"
    myErrorHandler(8);    // salir del programa
  end

  sysLib.commit();

Utilizar registros SQL con sentencias SQL implícitas

Para empezar a utilizar registros SQL EGL, declare un componente de registro SQL:
  Record Employee type sqlRecord
    { 
      tableNames = [["employee"]],
      keyItems = ["empnum"],
      defaultSelectCondition = 
        #sqlCondition{
          aTableColumn = 4  -- iniciar cada componente SQL 
                           -- con un guión doble
        }
    }

    empnum  decimal(6,0) {isReadonly=yes};
    empname char(40);
  end
Declare un registro basado en el componente de registro:
  emp Employee;

Añadir una fila a una tabla SQL

Para preparar la adición de una fila a una tabla SQL, coloque valores en el registro EGL:
  emp.empnum = 1;
  emp.empname = "John";
Añada un empleado a la tabla especificando la sentencia EGL add:
  try
    add emp;
  onException
    myErrorHandler(8);
  end

Leer filas de una tabla SQL

Para preparar la lectura de filas de una tabla SQL, identifique una clave de registro:
  emp.empnum = 1;  
Obtenga una sola fila de cualquiera de estas formas:
  • Especifique la sentencia EGL get de forma que genere una serie de sentencias (DECLARE cursor, OPEN cursor, FETCH row y, en ausencia de forUpdate, CLOSE cursor):
      try
        get emp;
      onException
        myErrorHandler(8);
      end
  • Especifique la sentencia EGL get de forma que genere una sola sentencia SELECT:
      try
        get emp singleRow;
      onException
        myErrorHandler(8);
      end
Procese varias filas de cualquiera de estas formas:
  • Utilice las sentencias EGL open, get next y while:
      VGVar.handleHardIOErrors  = 1;
    
      try
        open selectEmp forUpdate for emp;
      onException
        myErrorHandler(6);    // salir del programa
      end
    
      try 
        get next emp;
      onException
        if (emp not noRecordFound)
          myErrorHandler(8);  // salir del programa
        end 
      end
    
      while (emp not noRecordFound) 
        myRecord.empname = myRecord.empname + " " + "III";
    
        try
          replace emp;
        onException
          myErrorHandler(10); // salir del programa
        end
    
        try
          get next emp;
        onException
          if (emp not noRecordFound)
            myErrorHandler(8);    // salir del programa
          end 
        end
      end  // fin de while; el cursor se cierra automáticamente
           // cuando se ha leído la última fila del conjunto de resultados
    
      sysLib.commit();
  • Utilice las sentencias EGL open y forEach:
      VGVar.handleHardIOErrors  = 1;
    
      try
        open selectEmp forUpdate for emp;
      onException
        myErrorHandler(6);    // salir del programa
      end
    
      try 
        forEach (from selectEmp)
          myRecord.empname = myRecord.empname + " " + "III";
         
          try
            replace emp;
          onException
            myErrorHandler(10); // salir del programa
          end
        end  // fin de forEach; el cursor se cierra automáticamente
             // cuando se ha leído la última fila del conjunto de resultados
    
      onException
    
        // el bloque de excepción relacionado con forEach no se ejecuta si la condición 
        // es noRecordFound, así que evite la prueba "if (not noRecordFound)" 
        myErrorHandler(8);  // salir del programa
      end
    
      sysLib.commit();

Utilizar registros SQL con sentencias SQL explícitas

Antes de utilizar registros SQL con sentencias SQL explícitas, debe declarar un componente de registro SQL. Este componente se diferencia del anterior en la sintaxis de las propiedades de elementos SQL y en la utilización de un valor calculado:
  Record Employee type sqlRecord
    {
      tableNameVariables = [["empTable"]], 
                   // la utilización de una variable de nombre de tabla
                   // significa que la tabla se especifica
                   // durante la ejecución
      keyItems = ["empnum"]
    }
    empnum decimal(6,0) { isReadonly = yes };
    empname char(40);

    // especificar propiedades de una columna calculada 
    aValue decimal(6,0) 
      { isReadonly = yes,
        column = "(empnum + 1) as NEWNUM" };
  end
Declare variables:
  emp Employee;
  empTable char(40);

Añadir una fila a una tabla SQL

Para preparar la adición de una fila a una tabla SQL, coloque valores en el registro EGL y en una variable de nombre de tabla:
  emp.empnum = 1;
  emp.empname = "John";
  empTable = "Employee";
Añada un empleado a la tabla especificando la sentencia EGL add y modificando la sentencia SQL:
  // la variable de nombre de tabla no va precedida de un signo de dos puntos
  try
    add emp
      with #sql{
        insert into empTable (empnum, empname)
        values (:empnum, :empname || ' ' || 'Smith')
      }

  onException
    myErrorHandler(8);
  end

Leer filas de una tabla SQL

Para preparar la lectura de filas de una tabla SQL, identifique una clave de registro:
  emp.empnum = 1;  
Obtenga una sola fila de cualquiera de estas formas:
  • Especifique la sentencia EGL get de forma que genere una serie de sentencias (DECLARE cursor, OPEN cursor, FETCH row, CLOSE cursor):
      try
        get emp into empname   // La cláusula into es opcional. (No
                               // no estar en la sentencia SELECT).
        with #sql{
          select empname         
          from empTable      
          where empum = :empnum + 1
        }
      onException
        myErrorHandler(8);
      end
  • Especifique la sentencia EGL get de forma que genere una sola sentencia SELECT:
      try
        get emp singleRow // La cláusula into se deriva
                          // del registro SQL y se basa en
                          // las columnas de la cláusula select
        with #sql{
          select empname         
          from empTable         
          where empnum = :empnum + 1
        }
      onException
        myErrorHandler(8);
      end
Procese varias filas de cualquiera de estas formas:
  • Utilice las sentencias EGL open, get next y while:
      try
    
      // La cláusula into se deriva
      // del registro SQL y se basa en
      // las columnas de la cláusula select
        open selectEmp forUpdate 
          with #sql{
            select empnum, empname
            from empTable
            where empnum >= :empnum
            order by NEWNUM       -- utiliza el valor calculado
            for update of empname 
          } for emp;
      onException
        myErrorHandler(8);  // salir del programa
      end
       
      try
        get next emp;
      onException
        myErrorHandler(9);    // salir del programa
      end
    
      while (emp not noRecordFound)
        try 
          replace emp
          with #sql{
            update :empTable
            set empname = :empname || ' ' || 'III'
          } from selectEmp;
    
        onException
          myErrorHandler(10); // salir del programa 
        end
      
        try 
          get next emp;
        onException
          myErrorHandler(9);    // salir del programa
        end
      end  // fin de while
    
      // no es necesario indicar "close emp;", ya que emp
      // se cierra automáticamente cuando se ha leído 
      // el último registro del conjunto de resultados o 
      // (en caso de una excepción) cuando el programa finaliza
    
      sysLib.commit();
  • Utilice las sentencias EGL open y forEach:
      try
    
        // La cláusula into se deriva
        // del registro SQL y se basa en
        // las columnas de la cláusula select
        open selectEmp forUpdate 
          with #sql{
            select empnum, empname
            from empTable
            where empnum >= :empnum
            order by NEWNUM       -- utiliza el valor calculado
            for update of empname 
          } for emp;
    
      onException
        myErrorHandler(8);  // salir del programa
      end
       
      try
        forEach (from selectEmp) 
          
          try 
            replace emp 
            with #sql{
              update :empTable
              set empname = :empname || ' ' || 'III'
            } from selectEmp;
         
          onException
            myErrorHandler(9);  // salir del programa
          end 
    
        end   // fin de sentencia forEach, y
              // no es necesario indicar "close emp;", ya que emp
              // se cierra automáticamente cuando se ha leído 
              // el último registro del conjunto de resultados o 
              // (en caso de una excepción) cuando el programa finaliza
    
      onException
        // el bloque de excepción relacionado con forEach no se ejecuta si la condición 
        // es noRecordFound, así que evite la prueba "if (not noRecordFound)" 
        myErrorHandler(9);  // salir del programa
      end
    
      sysLib.commit();

Utilizar sentencias EGL prepare

Tiene la opción de utilizar un componente de registro SQL al codificar la sentencia EGL prepare. Declare el siguiente componente:
  Record Employee type sqlRecord
    { 
      tableNames = [["employee"]],
      keyItems = ["empnum"],
      defaultSelectCondition = 
        #sqlCondition{
          aTableColumn = 4  -- iniciar cada componente SQL 
                            -- con un guión doble
        }
    }

    empnum  decimal(6,0) {isReadonly=yes};
    empname char(40);
  end
Declare variables:
  emp Employee;
  empnum02 decimal(6,0);
  empname02 char(40);
  myString char(120);

Añadir una fila a una tabla SQL

Antes de añadir una fila, asigne valores a las variables:
  emp.empnum = 1;
  emp.empname = "John";
  empnum02 = 2;
  empname02 = "Jane";
Desarrolle la sentencia SQL:
  • Codifique la sentencia EGL prepare y haga referencia a un registro SQL, que proporciona una sentencia SQL que puede personalizarse:
      prepare myPrep
        from "insert into employee (empnum, empname) " +
        "values (?, ?)" for emp;
      
      // puede utilizar el registro SQL 
      // para comprobar el resultado de la operación 
      if (emp is error)
        myErrorHandler(8);
      end
  • Como alternativa, codifique la sentencia EGL prepare sin hacer referencia a un registro SQL:
      myString = "insert into employee (empnum, empname) " +
        "values (?, ?)";  
    
      try
        prepare addEmployee from myString;
      onException
        myErrorHandler(8);
      end
En cada uno de los casos anteriores, la sentencia EGL prepare incluye espacios reservados para los datos que suministrará una sentencia EGL execute. A continuación se ofrecen dos ejemplos de la sentencia execute:
  • Puede suministrar valores desde un registro (SQL u otro):
      execute addEmployee using emp.empnum, emp.empname;
  • Puede suministrar valores desde elementos individuales:
      execute addEmployee using empnum02, empname02;

Leer filas de una tabla SQL

Para preparar la lectura de filas de una tabla SQL, identifique una clave de registro:
  empnum02 = 2;
Puede sustituir varias filas de cualquiera de estas formas:
  • Utilice las sentencias EGL open, while y get next:
      myString = "select empnum, empname from employee " + 
                 "where empnum >= ? for update of empname"; 
    
      try
        prepare selectEmployee from myString for emp;
      onException
        myErrorHandler(8);  // salir del programa
      end
     
      try
        open selectEmp with selectEmployee 
          using empnum02 
          into emp.empnum, emp.empname;
      onException
        myErrorHandler(9);    // salir del programa
      end
      
      try
        get next from selectEmp;
      onException
        myErrorHandler(10); // salir del programa
      end
    
      while (emp not noRecordFound)
                                        
        emp.empname = emp.empname + " " + "III";
    
        try 
          replace emp
            with #sql{
              update employee 
              set empname = :empname
            }
          from selectEmp;
        onException
          myErrorHandler(11); // salir del programa
        end
    
        try
          get next from selectEmp;
        onException
          myErrorHandler(12);   // salir del programa
        end
      end  // fin de while; el cierre es automático cuando se ha leído la última fila
    
      sysLib.commit();
  • Utilice las sentencias EGL open y forEach:
      myString = "select empnum, empname from employee " + 
                 "where empnum >= ? for update of empname"; 
    
      try
        prepare selectEmployee from myString for emp;
      onException
        myErrorHandler(8);  // salir del programa
      end
     
      try
        open selectEmp with selectEmployee 
          using empnum02 
          into emp.empnum, emp.empname;
      onException
        myErrorHandler(9);    // salir del programa
      end
      
      try
        forEach (from selectEmp)
          emp.empname = emp.empname + " " + "III";
         
          try 
            replace emp
              with #sql{
                update employee 
                set empname = :empname
              }
            from selectEmp;
          onException
            myErrorHandler(11); // salir del programa
          end
        end // end  // fin de forEach; el cierre es automático cuando se ha leído la última fila
      onException
    
        // el bloque de excepción relacionado con forEach no se ejecuta si la condición 
        // es noRecordFound, así que evite la prueba "if (not noRecordFound)" 
        myErrorHandler(12);   // salir del programa
      end
    
      sysLib.commit();
Comentarios
(C) Copyright IBM Corporation 2000, 2005. Reservados todos los derechos.