DATE()
Devuelve la fecha del sistema como un valor de fecha ------------------------------------------------------------------------------ Sintaxis DATE() --> fFechaSistema Devuelve DATE() devuelve la fecha del sistema como un valor de fecha. Descripción DATE() es una función de conversión que permite inicializar variables de memoria con la fecha actual, comparar otros valores de fecha con la fecha actual y ejecutar cálculos de fecha correspondientes a la fecha actual. El formato de visualización de fechas se controla con el mandato SET DATE. El formato por defecto es mm/dd/aa. Ejemplos . Estos ejemplos muestran diversos resultados de la utilización de la función DATE(): ? DATE() // Resultado: 09/01/90 ? DATE() + 30 // Resultado: 10/01/90 ? DATE() - 30 // Resultado: 08/02/90 fFecha := DATE() ? CMONTH(fFecha) // Resultado: Septiembre Ficheros: La biblioteca asociada es CLIPPER.LIB.


DAY()
 Devuelve el día del mes como un valor numérico
------------------------------------------------------------------------------
 Sintaxis

     DAY(<fFecha>) --> nD.a

 Argumentos

     <fFecha> es el valor de fecha que se va a convertir.

 Devuelve

     DAY() devuelve un número comprendido entre 0 y 31, como valor numérico
     entero. Si el mes es febrero, se tienen en cuenta los a.os bisiestos. Si
     el argumento es el 29 de febrero y el a.o no es bisiesto, DAY() devuelve
     cero. Si el argumento de fecha es un valor vac.o, DAY() devuelve cero.

 Descripción

     DAY() es una función de conversión que sirve para convertir un valor de
     fecha en el día del mes. Esta función se utiliza con CMONTH() y YEAR()
     para dar formato a las fechas. Se utiliza también con frecuencia en
     diversos cálculos de fecha.

 Ejemplos

     .  Estos ejemplos muestran diversos resultados de la utilización
        de la función DAY():

        ? DATE()                     // Resultado: 09/01/90
        ? DAY(DATE())                // Resultado: 1
        ? DAY(DATE()) + 1            // Resultado: 2
        ? DAY(CTOD(""))              // Resultado: 0

     .  Este ejemplo utiliza DAY() con CMONTH() y YEAR() para dar
        formato a un valor de fecha:

        ? STR(DAY(DATE())) + "de" + CMONTH(DATE()) +;
          STR(YEAR(DATE()))          // Resultado:
                                     // 15 de Junio de 1990

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.


DBAPPEND()
 Añade un nuevo registro
------------------------------------------------------------------------------
 Sintaxis

     DBAPPEND() --> NIL

 Devuelve

     DBAPPEND() devuelve siempre NIL.

 Descripción

     DBAPPEND() a.ade un nuevo registro al fichero de base de datos (.dbf)
     utilizado en el área de trabajo actual. Si la inserci.n se realiza
     correctamente, se asigna a los campos del registro el valor vac.o
     correspondiente a su tipo de datos y el nuevo registro pasa a ser el
     registro actual.

     DBAPPEND() realiza la misma función que un mandato APPEND BLANK
     estándar. Si desea más información, consulte el mandato APPEND BLANK.

 Notas

     .  Registros lógicos: DBAPPEND() no respeta la visibilidad
        l.gica; es decir, si el registro se a.ade satisfactoriamente, se
        convierte en el registro actual, independientemente de cualquier
        condición de índice o de filtro.

     .  Entorno de red: En una base de datos utilizada en modo
        compartido en una red, DBAPPEND() bloquea autom.ticamente el nuevo
        registro. Si no puede bloquearse el registro, no se a.ade y se
        produce un error de ejecución recuperable. El manejador de errores
        por defecto de CA-Clipper trata el error, establece en verdadero
        el nuevo valor de NETERR() y continúa.la ejecución. Si desea m.s
        información, consulte el capítulo Programaci.n en Red en la gu.a
        de Programaci.n y Utilidades.



 Ejemplos

     .  En el ejemplo siguiente se a.ade un registro en blanco, se
        comprueba si existe un error de red y se actualizan los datos:

        DBUSEAREA(.T., "DBFNTX", "Ventas", "Ventas", .T.)
        .
        . <sentencias>
        .
        DBAPPEND()

        IF !NETERR()
           Ventas->Nombre := cNombre
           Ventas->Apellido := cApellido
        ELSE
           ? "Ha fallado la operación.de inserci.n"
           BREAK
        ENDIF

 Ficheros: La biblioteca asociada es CLIPPER.LIB.


DBCLEARFILTER()
 Borra una condición de filtro
------------------------------------------------------------------------------
 Sintaxis

     DBCLEARFILTER() --> NIL

 Devuelve

     DBCLEARFILTER() devuelve siempre NIL.

 Descripción

     DBCLEARFILTER() borra, si la hay, la condición l.gica de filtro del .rea
     de trabajo actual.

     DBCLEARFILTER() realiza la misma función que un mandato SET FILTER
     estándar sin expresión. Si desea más información, consulte el mandato
     SET FILTER.

 Notas

     .  Registros lógicos: DBCLEARFILTER() afecta a la visibilidad
        l.gica de los registros en el área de trabajo actual. Si desea m.s
        información, consulte DBSETFILTER() y el mandato SET FILTER.

 Ejemplos

     .  En el ejemplo siguiente se crea un filtro, los datos se listan
        en el orden filtrado y se borra el filtro:

        USE Empleado NEW
        DBSETFILTER( {|| Edad < 40}, "Edad < 40" )
        LIST Empleado->Nombre
        DBCLEARFILTER()

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.



DBCLEARINDEX()
 Cierra todos los ííndices del área de trabajo actual
------------------------------------------------------------------------------
 Sintaxis

     DBCLEARINDEX() --> NIL

 Devuelve

     DBCLEARINDEX() devuelve siempre NIL.

 Descripción

     DBCLEARINDEX() cierra los ííndices activos en al área de trabajo actual.
     Se escriben las actualizaciones y se cierran los ficheros ííndice.

     DBCLEARINDEX() realiza la misma función que un mandato SET INDEX
     estándar sin ningún índice. Si desea más información, consulte el
     mandato SET INDEX.

 Ejemplos

     .  En el ejemplo siguiente se borran los ficheros ííndice, si hay
        alguno seleccionado:

        cApellido := "L.pez"
        DBUSEAREA(.T., "DBFNTX", "Ventas", "Ventas", .T.)
        DBSETINDEX( "NOMBRE" )
        DBSETINDEX( "APELLIDO" )
        //

        IF INDEXORD() > 0            // .existe alg.n índice?
           DBCLEARINDEX()            // borrar ficheros de índice
        ELSE
           COPY TO FILE TEMP SDF     // copiar en formato
        ENDIF                        // SDF en su orden natural

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.


DBCLEARRELATION()
 Borra las relaciones activas
------------------------------------------------------------------------------
 Sintaxis

     DBCLEARRELATION() --> NIL

 Devuelve

     DBCLEARRELATION() devuelve siempre NIL.

 Descripción

     DBCLEARRELATION() borra cualquier relaci.n activa del área de trabajo
     actual.

     DBCLEARRELATION() realiza la misma función que un mandato SET RELATION
     TO estándar sin ningúna cláusula. Si desea más información, consulte el
     mandato SET RELATION.

 Ejemplos

     .  En el ejemplo siguiente se crea una relaci.n, se listan los
        datos y se borra la relaci.n:

        USE Empleado NEW
        USE Departamento NEW INDEX Dept
        //
        SELECT Empleado
        DBSETRELATION("Departamento", ;
           {|| Empleado->Dept}, "Empleado->Dept")
        LIST Empleado->Nombre, Departamento->Nombre
        DBCLEARRELATION()

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.


DBCLOSEALL()
 Cierra todas las áreas de trabajo ocupadas
------------------------------------------------------------------------------
 Sintaxis

     DBCLOSEALL() --> NIL

 Devuelve

     DBCLOSEALL() devuelve siempre NIL.

 Descripción

     DBCLOSEALL() libera todas las áreas de trabajo ocupadas. Equivale a
     utilizar DBCLOSEAREA() en todas las áreas de trabajo ocupadas.
     DBCLOSEALL() tiene el mismo efecto que el mandato CLOSE DATABASES
     estándar. Si desea más información, consulte los mandatos USE y CLOSE.

 Ejemplos

     .  En el ejemplo siguiente se cierran todas las áreas de trabajo:

        cApellido := "L.pez"
        DBUSEAREA(.T., "DBFNTX", "Ventas", "Ventas", .T.)
        DBSETINDEX( "SALEFNAM" )
        DBSETINDEX( "SALELNAM" )
        //
        DBUSEAREA(.T., "DBFNTX", "Distribu", "Distribu", .T.)
        DBSETINDEX( "COLLFNAM" )
        DBSETINDEX( "COLLLNAM" )
        //
        DBSELECTAREA( "Ventas" )         // seleccionar el .rea
                                         // de trabajo "Ventas"
        //
        IF ( Ventas->(DBSEEK(cApellido)) )
           IF Ventas->( DELETED() )
              IF RLOCK()
                 Ventas->( DBRECALL() )
                 ? "Registro borrado: ", Ventas->( DELETED() )
              ENDIF
           ENDIF
        ELSE
           ? "No se encuentra"
        ENDIF
        DBCLOSEALL()                     // cerrar todas las áreas
                                         // de trabajo

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.


DBCLOSEAREA()
 Cierra un área de trabajo
------------------------------------------------------------------------------
 Sintaxis

     DBCLOSEAREA() --> NIL

 Devuelve

     DBCLOSEAREA() devuelve siempre NIL.

 Descripción

     DBCLOSEAREA() libera el área de trabajo actual. Se escriben las
     actualizaciones pendientes, se liberan los bloqueos y se cierra o se
     libera cualquier recurso asociado con el área de trabajo. DBCLOSEAREA()
     es equivalente al mandato CLOSE estándar sin cláusulas. Si desea m.s
     información, consulte los mandatos USE y CLOSE.

 Ejemplos

     .  En el ejemplo siguiente se cierra un área de trabajo con una
        referencia de alias:

        cApellido := "L.pez"
        //
        DBUSEAREA(.T., "DBFNTX", "Ventas", "Ventas", .T.)
        DBSETINDEX( "SALEFNAM" )
        DBSETINDEX( "SALELNAM" )
        //
        DBUSEAREA(.T., "DBFNTX", "Distribu", "Distribu", .T.)
        DBSETINDEX( "COLLFNAM" )
        DBSETINDEX( "COLLLNAM" )
        //
        DBSELECTAREA( "Ventas" )         // seleccionar el .rea
                                         // de trabajo "Ventas"
        IF ( Ventas->(DBSEEK(cApellido)) )
           IF Ventas->( DELETED() ) .AND. Ventas->( RLOCK() )
              Ventas->( DBRECALL() )
              ? "Registro borrado: ", Ventas->( DELETED() )
           ENDIF
        ELSE
           ? "No se encuentra"
           Distribu->( DBCLOSEAREA() )
        ENDIF

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.



DBCOMMIT()
 Escribe en el disco las actualizaciones pendientes
------------------------------------------------------------------------------
 Sintaxis

     DBCOMMIT() --> NIL

 Devuelve

     DBCOMMIT() devuelve siempre NIL.

 Descripción

     DBCOMMIT() hace que se guarden en el disco todas las actualizaciones del
     área de trabajo actual. Todas las bases de datos actualizadas y las
     memorias intermedias de índice se guardan en las del DOS y se ejecuta un
     mandato COMMIT del DOS para el fichero de base de datos (.dbf) y
     cualquier fichero ííndice asociado con el área de trabajo.

     DBCOMMIT() realiza la misma función que un mandato COMMIT estándar, con
     la excepci.n de que act.a sólo en el área de trabajo actual. Si desea
     más información, consulte el mandato COMMIT.

 Notas

     .  Entorno de red: DBCOMMIT() hace visibles a los restántes
        procesos las actualizaciones realizadas en la base de datos. Para
        asegurarse de la integridad de los datos, ejecute DBCOMMIT() antes de
        ejecutar UNLOCK. Si desea más información, consulte el capítulo
        Programaci.n en Red en la gu.a Programaci.n y Utilidades.

     .  DBCOMMIT() utiliza la interrupci.n 21h, función 68h del DOS
        para ejecutar la escritura en el disco duro. La realizaci.n correcta
        de esta petición depende del sistema operativo de la red. Consulte
        con el distribuidor de red para comprobar si puede utilizarse esta
        interrupci.n.



 Ejemplos

     .  En este ejemplo, se utiliza COMMIT para forzar una escritura
        en el disco después de haber asignado una serie de variables de
        memoria a las variables de campo:

        USE Ventas EXCLUSIVE NEW
        MEMVAR->Nombre := Ventas->Nombre
        MEMVAR->Cantidad := Ventas->Cantidad
        //
        @ 10, 10 GET MEMVAR->Nombre
        @ 11, 10 GET MEMVAR->Cantidad
        READ
        //
        IF UPDATED()
           APPEND BLANK
           REPLACE Ventas->Nombre WITH MEMVAR->Nombre
           REPLACE Ventas->Cantidad WITH MEMVAR->Cantidad
           Ventas->( DBCOMMIT() )
        ENDIF

 Ficheros: La biblioteca asociada es CLIPPER.LIB.


DBCOMMITALL()
 Escribe en el disco las actualizaciones pendientes de todas las áreas de
 trabajo
------------------------------------------------------------------------------
 Sintaxis

     DBCOMMITALL() --> NIL

 Devuelve

     DBCOMMITALL() devuelve siempre NIL.

 Descripción

     DBCOMMITALL() hace que se guarden en el disco todas las actualizaciones
     pendientes de todas las áreas de trabajo. Equivale a invocar el mandato
     DBCOMMIT() en cada área de trabajo ocupada.

     Si desea más información, consulte DBCOMMIT() y el mandato COMMIT.

 Notas

     .  DBCOMMITALL() utiliza la interrupci.n 21h, función 68h del DOS
        para ejecutar la escritura de disco duro. La realizaci.n correcta de
        esta petición es función del sistema operativo de red. Consulte con
        el distribuidor de red para comprobar si se acepta esta función.

 Ejemplos

     .  En el ejemplo siguiente se escriben todas las actualizaciones
        pendientes en el disco:

     cApellido := "L.pez"
        //
        DBUSEAREA(.T., "DBFNTX", "Ventas", "Ventas", .T.)
        DBSETINDEX( "SALEFNAM" )
        DBSETINDEX( "SALELNAM" )
        //
        DBUSEAREA(.T., "DBFNTX", "Distribu", "Distribu", .T.)
        DBSETINDEX( "COLLFNAM" )
        DBSETINDEX( "COLLLNAM" )

        DBSELECTAREA( "Ventas" )         // seleccionar el .rea
                                         // de trabajo "Ventas"

        IF ( Ventas->(DBSEEK(cApellido)) )
           IF Ventas->(DELETED() ) .AND. Ventas( RLOCK())
              Ventas->( DBRECALL() )
              ? "Se ha recuperado el registro borrado."
           ENDIF
        ELSE
           ? "No se encuentra"
        ENDIF
        // proceso completado, escribir las
        // actualizaciones en el disco y cerrar
        DBCOMMITALL()
        DBCLOSEALL()

        QUIT

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.


DBCREATE()
 Crea un fichero de base de datos a partir de una matriz de estructura
------------------------------------------------------------------------------
 Sintaxis

     DBCREATE(<cBasedeDatos>, <aEstruct>,
        [<cControlador>]) --> NIL

 Argumentos

     <cBasedeDatos> es el nombre del nuevo fichero de base de datos
     especificado como cadena de carácteres e incluyendo, opciónalmente, la
     unidad y directorio. Si se especifica sin extensión, se supone (.dbf).

     <aEstruct> es una matriz que contiene la estructura de
     <cBasedeDatos> como una serie de submatrices, una por campo. Cada
     submatriz contiene la definición de los atributos de campo y presenta la
     estructura siguiente:

     Submatriz de Definici.n de Campos
     ------------------------------------------------------------------------
     Posici.n     Metas.mbolo      Dbstruct.ch
     ------------------------------------------------------------------------
     1            cNombre          DBS_NAME
     2            cTipo            DBS_TYPE
     3            nLongitud        DBS_LEN
     4            nDecimales       DBS_DEC
     ------------------------------------------------------------------------

     <cControlador> especifica el controlador de base de datos
     sustituible (RDD) que va a utilizarse para procesar el área de trabajo
     actual. <cControlador> es el nombre del RDD especificado como una
     expresión de carácteres. Si especifica <cControlador> como un valor
     literal, debe encerrarlo entre comillas.

 Devuelve

     DBCREATE() devuelve siempre NIL.

 Descripción

     DBCREATE() es una función de base de datos que crea un fichero a partir
     de una matriz que contiene la estructura. Puede crear la matriz de forma
     literal o utilizando DBSTRUCT(). DBCREATE() es similar al mandato CREATE
     FROM que crea una nueva estructura de base de datos a partir de un
     fichero de estructura extendido. Para crear el fichero extendido se
     utilizan los mandatos CREATE o COPY STRUCTURE EXTENDED.

     Antes de utilizar DBCREATE(), debe crearse la matriz <aEstruct> y
     rellenarla con las matrices de definición de campos de acuerdo a la
     estructura de la tabla anterior. Existen determinadas reglas para crear
     una matriz de definición de campo, entre ellas:

     .  Especificar todos los atributos de campo con un valor del tipo
        de datos apropiado para el atributo. Es necesario especificar el
        atributo de decimales, incluso para campos no numéricos. Si el campo
        no tiene un atributo de decimales, especifique cero.

     .  Especificar el atributo de tipo, utilizando la primera letra
        del tipo de datos como mínimo. Para mejorar la legibilidad, utilice
        m.s t.rminos descriptivos y t.rminos m.s largos. Por ejemplo, pueden
        especificarse "C" y "Car.cter" como el atributo de tipo para campos
        de carácteres.

     .  En CA-Clipper, los campos de carácteres pueden contener hasta
        64.000 carácteres. A diferencia del mandato CREATE FROM, DBCREATE()
        no utiliza el atributo de decimales para especificar la parte
        superior de la longitud de campo. Especifique la longitud de campo
        directamente, independientemente de su magnitud.

     Para que las referencias a los diversos elementos de la submatriz de
     definición de campos sean m.s legibles, se incluye el fichero de
     cabecera, llamado Dbstruct.ch, que contiene #defines para asignar un
     nombre a la posición de matriz para cada atributo de campo. Este fichero
     se encuentra en \CLIPPER5\INCLUDE.

 Ejemplos

     .  Este ejemplo crea una matriz vac.a y después se a.aden
        submatrices de definición de campos, utilizando la función AADD()
        antes de crear Agenda.dbf. Puede utilizar esta t.cnica para a.adir
        din.micamente definiciónes de campo a su matriz:

        aDbf := {}
        AADD(aDbf, { "Nombre", "C", 25, 0 })
        AADD(aDbf, { "Direccion", "C", 1024, 0 })
        AADD(aDbf, { "Telefono", "N", 13, 0 })
        //
        DBCREATE("Agenda", aDbf)

     .  Este ejemplo realiza las mismas acciones, pero declara la
        matriz de estructura como una matriz bidimensiónal y después utiliza
        el direccionamiento de subííndices para especificar las definiciónes
        de campos. Se crea utilizando el controlador DBFMDX:

     #include "Dbstruct.ch"
        //
        LOCAL aDbf[1][4]
        aDbf[1][ DBS_NAME ] := "Nombre"
        aDbf[1][ DBS_TYPE ] := "Caracteres"

        aDbf[1][ DBS_LEN ] := 25
        aDbf[1][ DBS_DEC ] := 0
        //
        DBCREATE("Nombre", aDbf, "DBFMDX")

 Ficheros:  La biblioteca asociada es CLIPPER.LIB,
            el fichero de cabecera es Dbstruct.ch.



DBCREATEINDEX()
 Crea un fichero ííndice
------------------------------------------------------------------------------
 Sintaxis

     DBCREATEINDEX(<cNombreíndice>, <cExprClave>,
        <bExprClave>, [<lUnico>]) --> NIL

 Argumentos

     <cNombreíndice> es un valor de carácteres, que especifica el nombre
     del fichero de índice que va a crearse.

     <cExprClave> es un valor de carácteres, que representa la expresión
     clave del índice en forma de texto.

     <bExprClave> es un bloque de código, que representa la expresión
     clave del índice en forma ejecutable.

     <lUnico> es un valor l.gico opciónal, que especifica si debe crearse
     un ííndice .nico. Si se omite <lUnico>, se utiliza el valor de SET UNIQUE
     global actual.

 Devuelve

     DBCREATEINDEX() devuelve siempre NIL.

 Descripción

     DBCREATEINDEX() crea un ííndice para el fichero de base de datos (.dbf)
     asociado con el área de trabajo actual. Si el área de trabajo tiene
     ííndices activos, se cierran. Cuando se crea el nuevo índice, se
     convierte en el de control del área de trabajo y el puntero se sit.a en
     el primer registro l.gico.

     DBCREATEINDEX() realiza la misma función que un mandato INDEX estándar.
     Si desea más información, consulte el mandato INDEX.

 Notas

     .  Efectos laterales: DBCREATEINDEX() garantiza la creaci.n
        de un ííndice, que cuando se activa, impone el orden l.gico
        especificado en la base de datos. Si la expresión clave se basa en
        información externa al fichero de base de datos o área de trabajo, el
        efecto es impredecible. Si la expresión clave cambia el estado del
        área de trabajo (por ejemplo, desplazando el contenido de un registro
        a un registro diferente o cambiando el contenido del mismo), el
        efecto es impredecible.

     .  Contexto de evaluaci.n: Cuando se eval.a la expresión
        clave, el área de trabajo asociada se selecciona autom.ticamente como
        el área de trabajo actual antes de la evaluaci.n. Posteriormente se
        restablece el área de trabajo seleccionada prevíamente.

     .  Entorno de red: DBCREATEINDEX() crea el nuevo índice para
        uso exclusivo del proceso actual.

 Ejemplos

     .  Este ejemplo crea un fichero ííndice, INombre, cuya clave es el
        campo Nombre:

        USE Empleados NEW
        DBCREATEINDEX( "INombre", "Nombre", { || Nombre })

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.




DBDELETE()
 Marca un registro para borrar
------------------------------------------------------------------------------
 Sintaxis

     DBDELETE() --> NIL

 Devuelve

     DBDELETE() devuelve siempre NIL.

 Descripción

     DBDELETE() marca el registro actual como borrado. Los registros marcados
     para borrarse pueden filtrarse utilizando SET DELETED o eliminarse del
     fichero al utilizar el mandato PACK.

     DBDELETE() realiza la misma función que un mandato DELETE estándar con
     ámbito en el registro actual. Si desea más información, consulte el
     mandato DELETE.

 Notas

     .  Registros lógicos: Si se ha establecido SET DELETED ON,
        los registros borrados no son visibles l.gicamente. Esto significa
        que las operación.s de base de datos que act.en en registros lógicos
        no tienen en cuenta los registros marcados como borrados. Recuerde,
        sin embargo, que si se ha establecido SET DELETED OFF el registro
        marcado como borrado permanece visible hasta que deja de ser el
        registro actual.

     .  Entorno de red: En una base de datos compartida en una
        red, DBDELETE() requiere bloquear el registro actual. Si desea m.s
        información, consulte el capítulo Programaci.n en Red de la gu.a
        Programaci.n y Utilidades.

 Ejemplos

     .  En el ejemplo siguiente se borra un registro después de
        efectuar un bloqueo satisfactorio:

        cApellido := "L.pez"
        DBUSEAREA(.T., "DBFNTX", "Ventas", "Ventas", .T.)
        DBSETINDEX( "APELLIDO" )
        //
        IF ( Ventas->(DBSEEK(cApellido)) )
           IF Ventas->( RLOCK() )
              Ventas->( DBDELETE() )
              ? "Registro borrado: ", Ventas->( DELETED() )
           ELSE
              ? "No puede borrarse el registro..."
           ENDIF
        ELSE
           ? "No se encuentra"
        ENDIF

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.



DBEDIT()*
 Visualiza registros en un formato de tabla
------------------------------------------------------------------------------
 Sintaxis

     DBEDIT([<nSup>], [<nIzq>],
        [<nInf>], <nDer>],
        [<acColumnas>],
        [<cfunciónUsuario>],
        [<acPatrónesFormatoSayColumna> | <PatrónFormatoSayColumna>],
        [<acCabecerasColumna> | <cCabeceraColumna>],
        [<acSeparadoresCabecera> | <cSeparadorCabecera>],
        [<acSeparadoresColumna> | <cSeparadorColumna>],
        [<acSeparadoresPie> | <cSeparadorPie>],
        [<acPiesColumna> | <cPieColumna>]) --> NIL

 Argumentos

     <nSup>, <nIzq>, <nInf> y <nDer> definen las
     coordenadas de la parte superior izquierda e inferior derecha de la
     ventana DBEDIT(). Los valores de fila pueden ir de cero a MAXROW() y
     las posiciónes de columna de cero a MAXCOL(). Si no se especifica, las
     coordenadas por defecto son 0, 0, MAXROW() y MAXCOL().

     <acColumnas> es una matriz de expresiónes de carácteres que contiene
     nombres de campos de base de datos o expresiónes para utilizar como
     valores de columna para cada columna que se muestra. Si no se especifica
     este argumento, DBEDIT() muestra todos los campos en el área de trabajo
     actual como columnas.

     <cfunciónUsuario> es el nombre de una función definida por el
     usuario, que se ejecuta cuando se pulsa una tecla irreconocible o no
     quedan teclas pendientes en la memoria intermedia de teclado.
     Especifique el nombre de función como una expresión de carácteres sin
     paréntesis ni argumentos. Recuerde que el funciónamiento de DBEDIT() se
     ve afectado por la presencia de este argumento. Consulte la Descripción
     que se ofrece m.s adelante, si desea más información.

     <acPatrónFormatoSayColumna> es una matriz paralela de patrones para
     formatear cada columna. Si se especifica <cPatrónFormatoSayColumna> en
     lugar de una matriz se muestran todas las columnas con el mismo formato.
     Si desea más información sobre patrones de formato, consulte TRANSFORM()
     o @...SAY.

     <acCabecerasColumna> es una matriz paralela de expresiónes de
     carácteres, que define las cabeceras de cada columna. Si se especifica
     <cCabecerasColumna> todas las columnas reciben el mismo encabezado. Si
     desea mostrar una cabecera de líneas m.ltiples, a.ada un punto y coma en
     la expresión de cabecera donde desea que se interrumpa la cadena. Si no
     se especifica, las cabeceras de columna se toman de la matriz
     <acColumnas> o de los nombres de campo del área de trabajo actual si no
     se especifica el argumento <acColumnas>.

     <acSeparadoresCabeceras> es una matriz paralela de carácteres, que
     define los carácteres útilizados para dibujar líneas horizontales que
     separan las cabeceras de columnas del .rea de campos. Si se especifica
     <cSeparadorCabeceras> en lugar de una matriz, se utiliza el mismo
     separador de cabeceras para todas las columnas. Si no se especifica este
     argumento, el separador por defecto es una línea de gr.ficos doble.

     <acSeparadoresColumna> es una matriz paralela de expresiónes de
     carácteres, que define los carácteres útilizados para dibujar las líneas
     verticales que separan las columnas. Si se especifica
     <cSeparadorColumna> en lugar de una matriz se utiliza el mismo separador
     para todas las columnas. Si este argumento no se especifica, el
     separador por defecto es una línea simple de gr.ficos.

     <acSeparadoresPie> es una matriz paralela de expresiónes de
     carácteres, que define los carácteres útilizados para dibujar las líneas
     horizontales que separan los pies de columnas del .rea de campos. Si se
     especifica <cSeparadorPie> en lugar de una matriz, se utiliza el mismo
     separador de pie para todas las columnas. Si no se especifica este
     argumento, no existe separador de pie.

     <acPiesColumna> es una matriz paralela de expresiónes de carácteres,
     que definen pies para cada columna. Si se especifica <cPieColumna> en
     lugar de una matriz, todas las columnas reciben el mismo pie. Para que
     se muestre un pie de líneas m.ltiples, a.ada un punto y coma en la
     expresión del pie, donde desea que se interrumpa la cadena. Si no se
     especifica este argumento, no existen pies de columna.

 Devuelve

     DBEDIT() devuelve siempre NIL.

 Descripción

     DBEDIT() es una función de interfaz de usuario y de compatibilidad que
     muestra registros de una o más .reas de trabajo en forma de tabla. La
     pantalla de la ventana DBEDIT() es una rejilla de celdas divididas en
     columnas y filas. Las columnas corresponden a los campos de base de
     datos y las filas corresponden a los registros de la base de datos. Cada
     columna se define mediante un elemento de la matriz <acColumnas>. La
     anchura de cada columna est. determinada por la evaluaci.n de la
     expresión de columna en la matriz <acColumnas> o el patr.n de formato de
     columna especificado en la matriz <acPatrónFormatoSayColumna>.

     Todas las teclas de desplazamiento del cursor pueden utilizarse con
     DBEDIT(), incluyendo ReP.g, AvP.g, Inicio, Fin, las cuatro teclas de
     flechas y todas las combinaciónes de tecla con Ctrl que producen el
     desplazamiento del cursor. Las teclas de movimiento a las que responde
     DBEDIT() cuando no se especifica un argumento de función de usuario se
     listan en la tabla siguiente de Teclas Activas:

     Teclas Activas de DBEDIT() 
     ------------------------------------------------------------------------
     Tecla             Acción
     ------------------------------------------------------------------------
     Arriba            Sube una fila
     Abajo             Baja una fila
     Izquierda         Columna a la izquierda
     Derecha           Columna a la derecha
     Ctrl-Izquierda    Desplaza la visualización una columna a la izquierda
     Ctrl-Derecha      Desplaza la visualización una columna a la derecha
     Inicio            Sitúa el cursor en la columna del extremo izquierdo
                       de la pantalla actual
     Fin               Sitúa el cursor en la columna del extremo derecho de
                       la pantalla actual
     Ctrl-Inicio       Sitúa el cursor sobre la primera columna de la tabla
                       de visualización
     Ctrl-Fin          Sitúa el cursor sobre la .ltima columna de la tabla
                       de visualización
     ReP.g             Pantalla anterior
     AvP.g             Pantalla siguiente
     Ctrl-ReP.g        Primera fila de la columna actual
     Ctrl-AvP.g        Ultima fila de la columna actual
     Intro             Finaliza DBEDIT()
     Esc               Finaliza DBEDIT()
     ------------------------------------------------------------------------


     Cuando se especifica el argumento de función (<cfunciónUsuario>), todas
     las teclas indicadas en la tabla anterior están activas con excepci.n de
     Esc y Intro. Cuando DBEDIT() llama a la función de usuario, le pasa
     autom.ticamente dos argumentos:

     .  El modo actual, pasado como valor numérico

     .  El índice de la columna actual en <acColumnas>, pasado como un
        valor numérico

     El parámetro de modo indica el estado actual de DBEDIT(), seg.n la
     .ltima tecla ejecutada. Los valores de modo posibles se listan en la
     tabla siguiente:

     Modos DBEDIT() 
     ------------------------------------------------------------------------
     Estado   Dbedit.ch      Descripción
     ------------------------------------------------------------------------
     0        DE_IDLE        Inactividad, se han procesado todas las
                             pulsaciones de teclas de desplazamiento y no
                             queda ningúna pendiente
     1        DE_HITTOP      Intento de desplazar el cursor antes de la parte
                             superior del fichero
     2        DE_HITBOTTOM   Intenta de situar el cursor después del final del
                             fichero
     3        DE_EMPTY       No hay registros en el área de trabajo
     4        DE_EXCEPT      Excepci.n de teclado
     ------------------------------------------------------------------------

     El parámetro de índice apunta a la posición en la matriz <acColumnas>
     donde se encuentra la columna actual. Si no se especifica <acColumnas>,
     el parámetro de índice se.ala la posición del campo en la estructura de
     base de datos actual. Acceda al nombre de campo utilizando FIELD().

     La función definida por el usuario debe devolver un valor que indique a
     DBEDIT() la acci.n qu. debe ejecutar. En la tabla siguiente se listan
     los posibles valores de retorno y las acciones correspondientes:

     Valores de Retorno de funciónes de Usuario DBEDIT() 
     ------------------------------------------------------------------------
     Valor   Dbedit.ch     Descripción
     ------------------------------------------------------------------------
     0       DE_ABORT      Cancela DBEDIT()
     1       DE_CONT       Contin.a DBEDIT()
     2       DE_REFRESH    Fuerza a volver a leer o dibujar y continúa..
                           Despu.s de redibujar, procesa las teclas y queda
                           inactivo
     ------------------------------------------------------------------------

     Existen varios casos en los se invoca la función de usuario:

     .  Excepciones de teclado. Se producen cuando DBEDIT() recoge una
        pulsaci.n de tecla que no reconoce. Cualquier tecla pendiente
        permanece en la memoria intermedia del teclado hasta que se recoge
        dentro de la función de usuario o hasta que DBEDIT() continúa.

     .  DBEDIT() entra en el modo inactivo (es decir, se han procesado
        todas las teclas pendientes). Se produce cuando el teclado est. vac.o
        o después de una actualizaci.n de pantalla. En este caso, se invoca
        la función del usuario y después DBEDIT() espera una pulsaci.n.

     .  Se alcanza el principio o final del fichero. Es id.ntico al
        estado inactivo. Se ejecutan todas las teclas ejecutables y se
        produce una llamada a la función de usuario con el mensaje de estado
        apropiado.

     Recuerde que cuando se ejecuta DBEDIT() por primera vez, todas las
     teclas pendientes en la memoria intermedia del teclado se ejecutan y,
     después, DBEDIT() queda en el modo inactivo e invoca la función de
     usuario. Si no quedan teclas pendientes, se pasa al modo inactivo
     inmediatamente.

     La función de usuario debe manejar todos los modos y mensajes de estado
     recibidos de DBEDIT().

     La función definida por el usuario debe asegurar que el estado de
     DBEDIT() sea equivalente al de DE_EXCEPT (4). De lo contrario, el valor
     de LASTKEY() carece de significado y el valor retorno de DE_REFRESH (2)
     sit.a la aplicación en un bucle sin fin.

     FUNCTION FuncEdicDB ( nModo, nPosColumna )
        LOCAL ValRet := DE_CONT

        IF ( nModo == DE_EXCEPT )
           IF ( LASTKEY() == K_F5 )
                    ValRet := DE_REFRESH
           ENDIF
        ENDIF
     RETURN( ValRet )

     DBEDIT() es una función reentrante, por lo que puede contener llamadas
     anidadas. Esta función permite utilizar simultáneamente m.ltiples
     ventanas de visualización.

     DBEDIT() es una función de compatibilidad, por lo que no es recomendable
     su utilización como función de visualización programable. Como tal, ha
     sido sustituida por la clase TBrowse. Si desea más información, consulte
     la clase TBrowse en este capítulo.

 Ejemplos

     .  Este ejemplo muestra una llamada gen.rica a DBEDIT():

           USE Nombres NEW
           DBEDIT()

     .  Este ejemplo muestra una llamada DBEDIT() con una función de
        usuario:

        #include "dbedit.ch"
        #include "inkey.ch"

        // La matriz debe ser visible a los otros

        // programas definidos en el programa

        STATIC acColumnas := {}

        PROCEDURE Main()

           USE Nombres NEW
           INDEX ON Nombres->Apellido + Nombres->Nombre TO Nombres

           CLS

           acColumnas := { "Apellido", "Nombre" }

           DBEDIT( 5, 5, 20, 70, acColumnas, "FuncUsuario" )

        RETURN


        FUNCTION FuncUsuario( nModo, nCol )
           LOCAL nTecla := LASTKEY()
           LOCAL nValRet := DE_CONT            // Valores de
                                               // retorno por defecto
           DO CASE
           CASE nModo == DE_IDLE
              nValRet := FuncInac()
           CASE nModo == DE_HITTOP
              TONE( 100, 3 )
           CASE nModo == DE_HITBOTTOM
              TONE( 100, 3 )
              nValRet := FuncAnex( nTecla )
           CASE nModo == DE_EMPTY
              nValRet := FunVacia()
           CASE nModo == DE_EXCEPT
              nValRet := FuncExcep( nTecla, nCol )
           OTHERWISE
              TONE( 100, 3 )
           ENDCASE

        RETURN nValRet

        FUNCTION FuncAnex( nTecla )
           LOCAL nValRet := DE_CONT            // Valor de retorno
                                               // por defecto

           IF nTecla == K_DOWN                 // Si es la flecha Abajo
              APPEND BLANK                     // A.adir registro en
        // blanco. Nota: El registro a.adido aparecer. en la parte
        // superior de la ventana DBEDIT() en la que se indexa
        // la base de datos.

              nValRet := DE_REFRESH            // Actualizar pantalla
           ENDIF

        RETURN nValRet


        FUNCTION FuncExcep( nTecla, nCol )
           LOCAL nValRet := DE_CONT            // Valor de retorno por
                                               // defecto

           DO CASE
           CASE nTecla == K_ESC                // Si ESCAPE
              nValRet := DE_ABORT              // Salir
           CASE nTecla == K_RETURN             // Si RETURN
              nValRet := FuncEdit( nCol )      // función para editar
                                               // campo

           // Activar/desactivar estado DELETED
           CASE nTecla == K_DEL .AND. LASTREC() != 0   // Pulsada
                                                       // tecla SUPR
              IF DELETED()
                 RECALL
              ELSE
                 DELETE
              ENDIF
           OTHERWISE
                 TONE( 100, 1 )
           ENDCASE

        RETURN nValRet


        FUNCTION FuncEdic( nCol )
           LOCAL cValíndice                    // Valor de la expresión
                                               // clave actual
           LOCAL nValRet                       // Valor de retorno
           LOCAL nCampo                        // Posici.n del
                                               // campo actual
           LOCAL cValCampo                     // Valor del campo actual
           LOCAL nGuardarCursor                // Conservar el estado
                                               // del cursor
           // Devuelve un error si no hay índice abierto
           cValíndice := &( INDEXKEY(0) )

           nCampo := FIELDPOS( acColumnas[nCol] )

           IF nCampo != 0
              nGuardarCursor := SETCURSOR()       // Guardar el estado
                                                  // del cursor
              SETCURSOR(1)         // Cambiar la forma del cursor
              cValCampo := FIELDGET( nCampo )     // Guardar el
                                                  // contenido
                                                  // del campo
              @ ROW(), COL() GET cValCampo        // nuevo valor GET
              READ
              FIELDPUT( nCampo, cValCampo )       // Sustituir por
                                                  // el nuevo valor
              SETCURSOR( nGuardarCursor )         // Restablecer
                                                  // la forma del

                                                  // cursor
           ENDIF


           IF cValíndice != &( INDEXKEY(0) )      // Si se modific. la
                                                  // expresión clave,
              nSolicitud := DE_REFRESH            // actualizar
                                                  // pantalla
           ELSE                                   // En caso contrario,
              nSolicitud := DE_CONT               // continúa.
           ENDIF

        RETURN nSolicitud

        FUNCTION FuncInac()
           // Rutina de inactividad
        RETURN DE_CONT

        FUNCTION FuncVacia()
           // Rutina de registros vac.os
        RETURN DE_CONT

 Ficheros:  La biblioteca asociada es EXTEND.LIB,
            los ficheros de cabecera son Dbedit.ch y Inkey.ch.


DBEVAL()
  Eval.a un bloque de código en cada registro dentro de un ámbito que cumpla
 una condición
------------------------------------------------------------------------------
 Sintaxis

     DBEVAL(<bBloque>,
        [<bCondici.nFor>],
        [<bCondici.nWhile>],
        [<nRegistrosSiguientes>],
        [<nRegistro>],
        [<lResto>]) --> NIL

 Argumentos

     <bBloque> es un bloque de código que va a ejecutarse en cada
     registro procesado.

     <bCondici.nFor> es una condición opciónal especificada como un
     bloque de código, que se eval.a en cada registro del ámbito. Realiza la
     misma función que la cláusula FOR de mandatos de tratamiento de
     registros.

     <bCondici.nWhile> es una condición opciónal especificada como un
     bloque de código, que se eval.a en cada registro del fichero actual,
     hasta que la condición devuelva falso (.F.). Realiza la misma función
     que la cláusula WHILE de los mandatos de tratamiento de registros.

     <nRegistrosSiguientes> es un número opciónal, que especifica el
     número de registros que van a procesarse, empezando por el actual. Es
     id.ntico a la cláusula NEXT.

     <nRegistro> es un número de registro opciónal que va a procesarse.
     Si se especifica este argumento, <bBloque> se eval.a para el registro
     especificado. Este argumento es id.ntico a la cláusula RECORD.

     <lResto> es un valor l.gico opciónal, que determina si el ámbito de
     DBEVAL() es todos los registros del fichero o todos los registros desde
     el registro actual. Este argumento corresponde a las cláusulas REST y
     ALL de los mandatos de tratamiento de registros. Si es verdadero (.T.) ,
     el ámbito es REST; de lo contrario, el ámbito es ALL. Si no se
     especifica <lResto> el ámbito por defecto es todos los registros.

 Devuelve

     DBEVAL() devuelve siempre NIL.

 Descripción

     DBEVAL() es una función de base de datos, que eval.a un .nico bloque de
     código para cada registro del área de trabajo actual que cumpla un
     ámbito y/o condición especificada. En cada iteraci.n, DBEVAL() eval.a el
     bloque especificado. Se procesan todos los registros dentro del ámbito o
     que cumplan la condición, hasta alcanzar el final del fichero.

     Por defecto, DBEVAL() act.a en el área de trabajo actual. Si desea
     utilizarla en otra área de trabajo, debe especificarla con una expresión
     de alias.

     DBEVAL() es similar a AEVAL(), que aplica un bloque a cada elemento de
     una matriz. Al igual que AEVAL(), DBEVAL() puede utilizarse como
     primitiva para la creaci.n de mandatos definidos por el usuario para
     ficheros de base de datos. De hecho, existen diversos mandatos de
     tratamiento de base de datos de CA-Clipper que se crean por medio de
     DBEVAL().

     Si desea más información sobre la sintaxis y teor.a de los bloques de
     código, consulte el apartado Bloques de C.digo en el capítulo Conceptos
     Básicos de la gu.a Programaci.n y Utilidades. Consulte también el
     apartado Sistema de Base de Datos en el capítulo Conceptos Básicos si
     desea más información sobre el ámbito y condiciónes de registros; y el
     fichero de cabecera estándar de CA-Clipper, STD.CH, que se encuentra en
     \CLIPPER5\INCLUDE si desea ejemplos sobre definiciónes de mandatos de
     base de datos de CA-Clipper, que utilizan DBEVAL().

 Ejemplos

     .  Este ejemplo utiliza DBEVAL() para crear Contar(), una función
        definida por el usuario, que cuenta el número de registros en un .rea
        de trabajo comprendidos en un ámbito especificado. El ámbito se pasa
        como una matriz a Contar(). Para que los ejemplos resulten m.s
        interesantes, existe un mandato definido por el usuario que crea la
        matriz de ámbito, que permite especificar el ámbito de forma que
        resulte familiar. Además, existe un conjunto de constantes
        declaradas, que definen los atributos del objeto de ámbito:

        // Definici.n de mandato de ámbito
        #command CREATE SCOPE <aámbito> [FOR <for>] ;
           [WHILE <while>] [NEXT <next>] [RECORD <rec>] ;
           [<rest:REST>] [ALL];
        =>;
           <aámbito> := { <{for}>, <{while}>, <next>, ;
              <rec>, <.rest.> }
        //
        // Constantes de atributos de ámbito
        #define FOR_COND        1
        #define WHILE_COND      2
        #define NEXT_SCOPE      3
        #define REC_SCOPE       4
        #define REST_SCOPE      5
        //
        // Crear un ámbito y contar registros us.ndolo
        LOCAL miConjunto, miContar
        USE Cliente NEW
        CREATE SCOPE miConjunto FOR Cliente = "L.pez" WHILE ;
                  CodPostal > "90000"
        miContar := Contar( miConjunto )
        RETURN

        FUNCTION Contar( aámbito )
           LOCAL nContar := 0
           DBEVAL( {|| nContar++},;
              aámbito[ FOR_COND ],;
              aámbito[ WHILE_COND ],;
              aámbito[ NEXT_SCOPE ],;
              aámbito[ REC_SCOPE ],;
              aámbito[ REST_SCOPE ];
           )
           RETURN nContar

 Ficheros: La biblioteca asociada es CLIPPER.LIB



DBF()*
 Devuelve el nombre de alias actual
------------------------------------------------------------------------------
 Sintaxis

     DBF() --> cAlias

 Devuelve

     DBF() devuelve el alias del área de trabajo actual, como cadena de
     carácteres. Si no hay abierto un fichero de base de datos en el .rea de
     trabajo actual, DBF() devuelve una cadena nula ("").

 Descripción

     DBF() es una función de compatibilidad que duplica la función DBF() en
     dBASE III PLUS. CA-Clipper la ejecuta llamando a la función ALIAS() sin
     argumentos.

     DBF() es una función de compatibilidad, por lo que su utilización no es
     recomendable. Puede sustituirse completamente por la función ALIAS().

 Ficheros:  La biblioteca asociada es EXTEND.LIB,
            el fichero fuente es SOURCE\SAMPLE\DBF.PRG



DBFILTER()
 Devuelve la expresión de filtro actual, como cadena de carácteres
------------------------------------------------------------------------------
 Sintaxis

     DBFILTER() --> cFiltro

 Devuelve

     DBFILTER() devuelve la condición de filtro definida en el .rea de
     trabajo actual, en forma de cadena de carácteres. Si no se ha
     establecido ningún filtro, DBFILTER() devuelve una cadena nula ("").

 Descripción

     DBFILTER() es una función de base de datos que se utiliza para guardar y
     volver a ejecutar un filtro activo, devolviendo la expresión de filtro
     como una cadena de carácteres que puede recompilarse y ejecutarse m.s
     tarde con el operador de macro (&). Esta función act.a de forma similar
     a las funciónes DBRELATION() y DBRSELECT(), que guardan y vuelven a
     ejecutar la expresión de enlace de una relaci.n dentro de un .rea de
     trabajo.

     Puesto que cada área de trabajo puede tener un filtro activo, DBFILTER()
     puede devolver la expresión de filtro de cualquier área de trabajo. Esto
     se realiza, haciendo referencia a DBFILTER() dentro de una expresión de
     alias, tal como se muestra a continúa.ión.

 Notas

     .  Variables declaradas: Una cadena de carácteres devuelta
        por DBFILTER() es posible que no funcióne correctamente, cuando se
        recompila y ejecuta utilizando el operador de macro (&) si la
        expresión de filtro original contiene referencias a variablesólocales
        o estáticas o que dependan de declaraciónes que se resuelven durante
        la compilación.

 Ejemplos

     .  Este ejemplo abre dos ficheros de base de datos, crea dos
        filtros y muestra las expresiónes de filtro para ambas .reas de
        trabajo:

        USE Cliente INDEX Cliente NEW
        SET FILTER TO Apellido = "L.pez"
        USE Facturas INDEX Facturas NEW
        SET FILTER TO IdCliente = "L.p001"
        SELECT Cliente
        //
        ? DBFILTER()                  // Resultado: Apellido = "L.pez"
        ? Facturas->(DBFILTER())   // Resultado: IdCliente = "L.p001"

     .  Esta función, CrearConsulta(), utiliza DBFILTER() para crear
        un fichero de memoria que contiene la expresión de filtro actual en
        la variable privada cFiltro:

        FUNCTION CrearConsulta( cNombreCons )
           PRIVATE cFiltro := DBFILTER()
           SAVE ALL LIKE cFiltro TO (cNombreCons + ".con")
           RETURN NIL

     .  Posteriormente, puede restablecer el fichero de consulta con
        la función SelecFiltro():

        FUNCTION SelecFiltro()
        PARAMETER cNombreCons
           RESTORE FROM &cNombreCons..con ADDITIVE
           SET FILTER TO &cFiltro.
           RETURN NIL

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.



DBGOBOTTOM()
 Desplaza el puntero al último registro l.gico
------------------------------------------------------------------------------
 Sintaxis

     DBGOBOTTOM() --> NIL

 Devuelve

     DBGOBOTTOM() devuelve siempre NIL.

 Descripción

     DBGOBOTTOM() desplaza el puntero al último registro l.gico en el .rea de
     trabajo actual.

     DBGOBOTTOM() realiza la misma función que un mandato GO BOTTOM estándar.
     Si desea más información, consulte el mandato GO.

 Notas

     .  Registros lógicos: DBGOBOTTOM() act.a con registros
        lógicos. Si existe un ííndice activo, DBGOBOTTOM() se desplaza al
        último registro en el orden indexado. Si se selecciona un filtro,
        sólo se procesan los registros que cumplan la condición del filtro.

     .  Orden de control: Si hay activo m.s de un ííndice en el
        área de trabajo, la operación.se ejecuta utilizando el orden de
        control, establecido por la función DBSETORDER() o el mandato SET
        ORDER. Si desea más información, consulte el mandato SET ORDER.

     .  Entorno de red: Al desplazarse a otro registro en un
        entorno de red, las modificaciones efectuadas en el registro actual
        se hacen visibles a los otros procesos. Si desea más información,
        consulte el capítulo Programaci.n en Red en la gu.a Programaci.n y
        Utilidades.

 Ejemplos

     .  En el ejemplo siguiente se utiliza DBGOBOTTOM() para situar el
        puntero en el último registro l.gico:

        cApellido := "L.pez"
        DBUSEAREA(.T., "DBFNTX", "Ventas", "Ventas", .T.)
        DBSETINDEX( "APELLIDO" )
        //
        Ventas->( DBGOBOTTOM() )
        IF ( Ventas->Apellido == "L.pez" )
           IF RLOCK()
              Ventas->( DBDELETE() )
              ? "Registro borrado: ", Ventas->( DELETED() )
           ELSE
              ? "No puede bloquearse el registro..."
           ENDIF
        END

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.



DBGOTO()
 Desplaza el puntero al registro del número especificado.
------------------------------------------------------------------------------
 Sintaxis

     DBGOTO(<nNúmeroRegistro>) --> NIL

 Argumentos

     <nNúmeroRegistro> es un valor numérico que especifica el número del
     registro deseado.

 Devuelve

     DBGOTO() devuelve siempre NIL.

 Descripción

     DBGOTO() desplaza el puntero al registro cuyo número es igual a
     <nNúmeroRegistro>. Si no existe un registro de este tipo, el .rea de
     trabajo se sit.a en LASTREC() + 1 y tanto EOF() como BOF() devuelven
     verdadero (.T.).

     DBGOTO() realiza la misma función que un mandato estándar GO. Si desea
     más información, consulte el mandato GO.

 Notas

     .  Registros lógicos: DBGOTO() no respeta la visibilidad
        l.gica. Es decir, si el registro especificado existe, se convertir.
        en el registro actual con independencia de cualquier condición de
        índice o filtro.

     .  Entorno de red: Al desplazarse a otro registro en un
        entorno de red, las modificaciones efectuadas en el registro actual
        se hacen visibles a los otros procesos. Si desea más información,
        consulte el capítulo Programaci.n en Red en la gu.a Programaci.n y
        Utilidades.

 Ejemplos

     .  En el ejemplo siguiente se utiliza DBGOTO() para procesar
        iterativamente saltando los registros de cuatro en cuatro:

        DBUSEAREA(.T., "DBFNTX", "Ventas", "Ventas", .T.)
        //
        // saltar registros de cuatro en cuatro
        DO WHILE !EOF()
           DBGOTO( RECNO() + 4 )
           Ventas->Grupo := "Osos"
        ENDDO

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.


DBGOTOP()
 Desplaza el puntero al primer registro l.gico
------------------------------------------------------------------------------
 Sintaxis

     DBGOTOP() --> NIL

 Devuelve

     DBGOTOP() devuelve siempre NIL.

 Descripción

     DBGOTOP() desplaza el puntero al primer registro l.gico del .rea de
     trabajo actual.

     DBGOTOP() realiza la misma función que un mandato GO TOP estándar. Si
     desea más información, consulte el mandato GO TOP.

 Notas

     .  Registros lógicos: DBGOTOP() act.a sobre registros
        lógicos. Si existe un ííndice activo, DBGOTOP() desplaza el puntero al
        primer registro en orden indexado. Si hay establecido un filtro, sólo
        se examinan los registros que cumplen con la condición del filtro.

     .  Orden de control: Si hay activo m.s de un ííndice en el
        área de trabajo, la operación.se realiza utilizando el orden de
        control establecido con la función DBSETORDER() o el mandato SET
        ORDER. Si desea más información, consulte el mandato SET ORDER.

     .  Entorno de red: Al desplazarse a otro registro en un
        entorno de red, las modificaciones efectuadas en el registro actual
        se hacen visibles a los otros procesos. Si desea más información,
        consulte el capítulo Programaci.n en Red en la gu.a Programaci.n y
        Utilidades.

 Ejemplos

     .  Este ejemplo muestra la utilización normal de DBGOTOP():

        DBGOTOP()
        WHILE ( !EOF() )
           ? FIELD->Nombre
           DBSKIP()
        END

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.



DBRECALL()
 Recupera un registro marcado para borrarse
------------------------------------------------------------------------------
 Sintaxis

     DBRECALL() --> NIL

 Devuelve

     DBRECALL() devuelve siempre NIL.

 Descripción

     DBRECALL() hace que el registro actual se recupere si est. marcado para
     ser borrado.

     DBRECALL() realiza la misma función que un mandato RECALL. Si desea m.s
     información, consulte los mandatos DELETE y RECALL.

 Notas

     .  Registros lógicos: La recuperaci.n de un registro borrado
        afecta a la visibilidad l.gica del registro si el estado global SET
        DELETED es verdadero (.T.). Si desea más información, consulte la
        función DBDELETE() y los mandatos DELETE y RECALL .

     .  Entorno de red: Para una base de datos compartida en una
        red, DBRECALL() requiere bloquear el registro actual. Si desea m.s
        información, consulte el capítulo Programaci.n en Red en la gu.a
        Programaci.n y Utilidades.

 Ejemplos

     .  En el ejemplo siguiente se recupera un registro marcado para
        borrarse si el intento de bloqueo ha sido satisfactorio:

        cApellido := "L.pez"
        DBUSEAREA(.T., "DBFNTX", "Ventas", "Ventas", .T.)
        DBSETINDEX( "APELLIDO" )
        //
        IF ( Ventas->(DBSEEK(cApellido)) )
           IF Ventas->( DELETED() )
              IF Ventas->( RLOCK() )
                 Ventas->( DBRECALL() )
                 ? "Registro recuperado"
              ELSE
                 "No puede bloquearse el registro..."
              ENDIF
           ENDIF
        ELSE
           ? "No se encuentra"
        ENDIF

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.


DBREINDEX()
 Vuelve a crear todos los ííndices activos en el área de trabajo actual
------------------------------------------------------------------------------
 Sintaxis

     DBREINDEX() --> NIL

 Devuelve

     DBREINDEX() devuelve siempre NIL.

 Descripción

     DBREINDEX() reconstruye todos los ííndices activos asociados con el .rea
     de trabajo actual. Despu.s de crearse los ííndices, el área de trabajo se
     desplaza al primer registro l.gico del orden de control.

     DBREINDEX() realiza la misma función que un mandato REINDEX estándar. Si
     desea más información, consulte el mandato REINDEX.

 Ejemplos

     .  En el ejemplo siguiente se reindexa el área de trabajo:

        cApellido := "L.pez"
        DBUSEAREA(.T., "DBFNTX", "Ventas", "Ventas", .T.)
        DBSETINDEX( "APELLIDO" )
        //
        IF ( Ventas->(DBSEEK(cApellido)) )
           IF RLOCK()
              DELETE FOR Ventas->Apellido == "L.pez"
              Ventas->( DBREINDEX() )
           ELSE
              ? "No puede bloquearse el registro..."
           ENDIF
        ELSE
           ? "No se encuentra"
        ENDIF

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.


DBRELATION()
 Devuelve la expresión de enlace de una relaci.n especificada
------------------------------------------------------------------------------
 Sintaxis

     DBRELATION(<nRelaci.n>) --> cExpEnlace

 Argumentos

     <nRelaci.n> es la posición de la relaci.n deseada en la lista de
     relaciones del área de trabajo actual. Las relaciones están numeradas de
     acuerdo con el orden en el que se definieron con SET RELATION.

 Devuelve

     DBRELATION() devuelve una cadena de carácteres que contiene la expresión
     de enlazado de la relaci.n especificada por <nRelaci.n>. Si no existe
     ningúna relaci.n para <nRelaci.n>, DBRELATION() devuelve una cadena nula
     ("").

 Descripción

     DBRELATION() es una función de base de datos que se utiliza con
     DBRSELECT() para determinar la expresión de enlazado y el .rea de
     trabajo de una relaci.n existente creada con el mandato SET RELATION.

     DBRELATION() devuelve la expresión de enlazado definida por la cláusula
     TO. DBRSELECT() devuelve el área de trabajo enlazada definida por la
     cláusula INTO.

     Por defecto, DBRELATION() opera en el área de trabajo actual. Si desea
     utilizarla en un área de trabajo no seleccionada, debe indicarla con una
     expresión de alias (consulte el ejemplo siguiente).

 Notas

     .  Variables declaradas: Una cadena de carácteres devuelta
        por DBRELATION() puede no actuar correctamente cuando se recompila y
        se ejecuta utilizando el operador de macro (&), si la expresión
        original contiene referencias a variablesólocales o estáticas, o
        declaraciónes que se resuelvan durante la compilación.

 Ejemplos

     .  Este ejemplo abre tres ficheros de base de datos, se
        establecen dos relaciones desde el área de trabajo padre, y
        después se muestra la expresión de enlazado para la segunda .rea
        de trabajo hija:

        USE Facturas INDEX Facturas NEW
        USE OrdenInverso INDEX OrdenInverso NEW
        USE Cliente INDEX Cliente NEW
        SET RELATION TO NumCliente INTO Facturas, NumOrden ;
              INTO OrdenInverso
        //
        ? DBRELATION(2)                // Resultado: NumOrden

     .  M.s tarde, puede utilizarse la misma expresión de enlazado
        desde un área de trabajo no seleccionada mediante una expresión con
        alias como .sta:

        USE Fichero NEW
        ? Cliente->(DBRELATION(2))     // Resultado: NumOrden

     .  Este ejemplo es una función definida por el usuario,
        Relacion(), que devuelve los resultados de DBRELATION() y DBRSELECT()
        como una matriz:

        FUNCTION Relacion( nRelacion )
           RETURN { DBRELATION(nRelacion), ;
                 ALIAS(DBRSELECT(nRelacion)) }

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.



DBRSELECT()
 Devuelve el número del área de trabajo destáno de una relaci.n
------------------------------------------------------------------------------
 Sintaxis

     DBRSELECT(<nRelaci.n>) --> nAreaTrabajo

 Argumentos

     <nRelaci.n> es la posición de la relaci.n deseada en la lista de
     relaciones del área de trabajo actual. Las relaciones se numeran de
     acuerdo al orden en el que se definieron con SET RELATION.

 Devuelve

     DBRSELECT() devuelve el número del área de trabajo de la relaci.n
     especificada por <nRelaci.n> como un valor numérico entero. Si no existe
     RELATION SET para <nRelaci.n>, DBRSELECT() devuelve cero.

 Descripción

     DBRSELECT() es una función de base de datos utilizada en combinación con
     DBRELATION() para determinar el área de trabajo y expresión de enlazado
     de una relaci.n existente creada con el mandato SET RELATION.
     DBRSELECT() devuelve el área de trabajo definida por la cláusula INTO.
     DBRELATION() devuelve la expresión de enlazado definida por la cláusula
     TO. Para determinar el alias de la relaci.n en lugar del número de .rea
     de trabajo, utilice la expresión ALIAS(DBRSELECT(<nRelaci.n>)).

     Por defecto, DBRSELECT() act.a en el área de trabajo seleccionada
     actualmente. Act.a en un área de trabajo no seleccionada si la
     especifica como parte de una expresión con alias (consulte el ejemplo
     siguiente).

 Ejemplos

     .  Este ejemplo abre tres ficheros de base de datos, se
        establecen dos relaciones desde el área de trabajo padre, después
        se muestra la expresión de enlace con la segunda área de trabajo
        hija as. como el área de trabajo destáno de la relaci.n:

        USE Facturas INDEX Facturas NEW
        USE OrdenInverso INDEX OrdenInverso NEW
        USE Cliente INDEX Cliente NEW
        SET RELATION TO NumCliente INTO Cliente, ;
              NumOrden INTO OrdenInverso
        //
        ? DBRELATION(2), DBRSELECT(2)  // Resultado:
                                       // NumOrden 3
        ? ALIAS(DBRSELECT(2))          // Resultado:
                                       // OrdenInverso

     .  M.s tarde, puede consultar la misma información para un .rea
        de trabajo no seleccionada utilizando una expresión de alias:

        USE Fichero NEW
        ? Cliente->(DBRELATION(2))     // Resultado: NumOrden
        ? Cliente->(DBRSELECT(2))      // Resultado: 3

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.



DBSEEK()
 Desplaza el puntero al registro del valor clave especificado
------------------------------------------------------------------------------
 Sintaxis

     DBSEEK(<expClave>, [<lB.squedaAprox>]) --> lEncontrado

 Argumentos

     <expClave> es un valor de cualquier tipo que especifica el valor
     clave asociado con el registro deseado.

     <lB.squedaAprox> es un valor l.gico opciónal que especifica si debe
     realizarse una b.squeda aproximada. Esto determina c.mo se sit.a el .rea
     de trabajo si no se localiza el valor clave especificado (consulte m.s
     adelante). Si se omite <lB.squedaAprox>, se utiliza el valor global SET
     SOFTSEEK.

 Devuelve

     DBSEEK() devuelve verdadero (.T.) si se ha localizado el valor clave
     especificado; de lo contrario, devuelve falso (.F.).

 Descripción

     DBSEEK() desplaza el puntero al primer registro l.gico cuyo valor clave
     sea igual a <expClave>. Si se localiza un registro de este tipo, se
     convierte en el registro actual y DBSEEK() devuelve verdadero (.T.). De
     lo contrario, DBSEEK() devuelve falso (.F.) y la situaci.n del .rea de
     trabajo es la siguiente: para una b.squeda normal (no aproximada), el
     área de trabajo se sit.a en LASTREC() + 1 y EOF() devuelve verdadero
     (.T.). En una b.squeda aproximada, el área de trabajo se sit.a en el
     primer registro cuyo valor clave sea mayor que el valor clave
     especificado. Si no existe un registro de este tipo, el área de trabajo
     se sit.a en LASTREC() + 1 y EOF() devuelve verdadero (.T.).

     En un área de trabajo sin ííndices activos, DBSEEK() no tiene efecto.

     DBSEEK() realiza la misma función que un mandato SEEK estándar. Si desea
     más información, consulte el mandato SEEK.

 Notas

     .  Registros lógicos: DBSEEK() act.a sobre registros lógicos.
        Los registros se examinan en el orden indexado. Si se establece un
        filtro, sólo se examinan los registros que cumplan la condición del
        filtro.

     .  Orden de control: Si el área de trabajo tiene m.s de un
        índice activo, la operación.se realiza utilizando el orden de control
        establecido con la función DBSETORDER() o con el mandato SET ORDER.
        Si desea más información, consulte el mandato SET ORDER.

     .  Entorno de red: Al desplazarse a otro registro en un
        entorno de red, las modificaciones efectuadas en el registro actual
        se hacen visibles a los otros procesos. Si desea más información,
        consulte el capítulo Programaci.n en Red en la gu.a Programaci.n y
        Utilidades.

 Ejemplos

     .  En este ejemplo, DBSEEK() desplaza el puntero al registro en
        la base de datos Empleado, en la que el valor del CAMPO "cNombre"
        coincide con el valor introducido de cNombre:

        ACCEPT "Nombre del Empleado: " TO cNombre
        IF ( Empleado->(DBSEEK(cNombre)) )
           Empleado->(MostrarRegistro())
        ELSE
           ? "No encontrado"
        END

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.



DBSELECTAREA()
 Cambia el área de trabajo actual
------------------------------------------------------------------------------
 Sintaxis

     DBSELECTAREA(<nArea> | <cAlias>) --> NIL

 Argumentos

     <nArea> es un valor numérico comprendido entre 0 y 250, inclusive,
     que especifica el área de trabajo que se va a seleccionar.

     <cAlias> es un valor de carácteres que especifica el alias de un
     área de trabajo ocupada actualmente que se va a seleccionar.

 Devuelve

     DBSELECTAREA() devuelve siempre NIL.

 Descripción

     DBSELECTAREA() hace que el área de trabajo especificada se convierta en
     el área de trabajo actual. Todas las operación.s de base de datos
     posteriores se aplican a este área de trabajo a menos que se especifique
     explícitamente otra área de trabajo para una operación. DBSELECTAREA()
     realiza la misma función que un mandato SELECT estándar. Si desea m.s
     información, consulte el mandato SELECT.

 Notas

     .  Selecci.n cero: Si se selecciona un área de trabajo cero,
        el área de trabajo libre con el número m.s bajo se convierte en el
        área de trabajo actual.

     .  Expresiones de alias: El operador de alias (->) puede
        seleccionar temporalmente un área de trabajo mientras se eval.a una
        expresión y, posteriormente, restablecer el área de trabajo anterior.
        Si desea más información, consulte el operador de alias (->).

 Ejemplos

     .  El ejemplo siguiente selecciona un área de trabajo mediante el
        nombre de alias:

        cApellido := "L.pez"
        DBUSEAREA(.T., "DBFNTX", "Ventas", "Ventas", .T.)
        DBSETINDEX( "NOMVENDE" )
        DBSETINDEX( "APEVENDE" )
        //
        DBUSEAREA(.T., "DBFNTX", "DISTRIBU", "DISTRIBU", .T.)
        DBSETINDEX( "NOMDISTR" )
        DBSETINDEX( "APEDISTR" )
        //
        DBSELECTAREA( "Ventas" )       // seleccionar .rea
                                       // de trabajo "Ventas"
        IF ( Ventas->(DBSEEK(cApellido)) )
           IF Ventas->( DELETED() ) .AND. Ventas->( RLOCK() )
              Ventas->( DBRECALL() )
              ? "Se ha recuperado el registro borrado."
           ENDIF
        ELSE
           ? "No encontrado"
        ENDIF

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.


DBSETDRIVER()
 Devuelve el controlador de base de datos por defecto y, opciónalmente,
 selecciona un nuevo controlador
------------------------------------------------------------------------------
 Sintaxis

     DBSETDRIVER([<cControlador>]) --> cControladorActual

 Argumentos

     <cControlador> es un valor opciónal de carácteres que especifica el
     nombre del controlador de base de datos que va a utilizarse para activar
     y gestionar nuevas .reas de trabajo cuando no hay ningún controlador
     explícitamente especificado.

 Devuelve

     DBSETDRIVER() devuelve el nombre del controlador actual por defecto.

 Descripción

     DBSETDRIVER() establece el controlador de base de datos que va a
     utilizarse cuando se activan nuevas .reas de trabajo sin especificar un
     controlador. Si el controlador especificado no est. disponible para la
     aplicación, la llamada no tiene efecto. DBSETDRIVER() devuelve el nombre
     del controlador actual por defecto, si lo hay.

 Ejemplos

     .  Este ejemplo convierte al controlador "DBFNDX" en el
        controlador por defecto. Si el controlador no est. disponible, se
        emite el mensaje:

        DBSETDRIVER("DBFNDX")
        IF ( DBSETDRIVER() <> "DBFNDX" )
           ? "Controlador DBFNDX no disponible"
        ENDIF

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.


DBSETFILTER()
 Establece una condición de filtro
------------------------------------------------------------------------------
 Sintaxis

     DBSETFILTER(<bCondici.n>, [<cCondici.n>]) --> NIL

 Argumentos

     <bCondici.n> es un bloque de código que expresa la condición de
     filtro, en forma ejecutable.

     <cCondici.n> es un valor opciónal de carácteres que expresa la
     condición de filtro en forma de texto. Si se omite <cCondici.n>, la
     función DBFILTER() devuelve una cadena vac.a para el área de trabajo.

 Devuelve

     DBSETFILTER() devuelve siempre NIL.

 Descripción

     DBSETFILTER() establece una condición de filtro l.gico en el .rea de
     trabajo actual. Cuando se establece un filtro, los registros que no
     cumplen con la condición del mismo no son l.gicamente visibles. Es
     decir, las operación.s de base de datos que act.an sobre registros
     lógicos no procesan esos registros.

     La expresión de filtro suministrada para DBSETFILTER() resulta verdadera
     (.T.) si el registro actual cumple con la condición del filtro; y de lo
     contrario resulta falsa (.F.).

     La expresión de filtro debe ser un bloque de código (<bCondici.n>) o
     un bloque de código y texto equivalente (<cCondici.n>). Si se
     utilizan ambas versiones, deben expresar la misma condición. Si se
     omite la versi.n de texto, DBFILTER() devuelve una cadena vac.a para
     el área de trabajo.

     DBSETFILTER() realiza la misma función que un mandato SET FILTER
     estándar. Si desea más información, consulte el mandato SET FILTER.

 Notas

     .  Registros lógicos: DBSETFILTER() afecta a la visibilidad
        l.gica de los registros (consulte las notas anteriores).

     .  Efectos laterales: La condición de filtro sólo garantiza
        la limitaci.n de visibilidad en ciertos registros, como se ha
        descrito anteriormente. Si la expresión de filtro se basa en la
        información externa al fichero de base de datos o área de trabajo, el
        efecto es impredecible. Si la expresión de filtro cambia el estado
        del área de trabajo (por ejemplo, desplaz.ndose a un registro
        diferente o cambiando el contenido de un registro), el efecto es
        impredecible.

     .  Contexto de evaluaci.n: Cuando se eval.a la expresión de
        filtro, el área de trabajo asociada se selecciona autom.ticamente
        como área de trabajo actual antes proceder a la evaluaci.n. El .rea
        de trabajo prevíamente seleccionada se restablece posteriormente.

 Ejemplos

     .  Este ejemplo limita el acceso de datos, a los registros en los
        que el valor del campo Edad es inferior a 40:

        USE Empleado NEW
        DBSETFILTER( {|| Edad < 40}, "Edad < 40" )
        DBGOTOP()

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.


DBSETINDEX()
 Abre un ííndice
------------------------------------------------------------------------------
 Sintaxis

     DBSETINDEX(<cNombreíndice>) --> NIL

 Argumentos

     <cNombreíndice> es un valor de carácteres que especifica el nombre
     del fichero ííndice que va a abrirse.

 Devuelve

     DBSETINDEX() devuelve siempre NIL.

 Descripción

     DBSETINDEX() abre un fichero ííndice en el área de trabajo actual. Todos
     los ficheros ííndice que ya estuviesen asociados con el área de trabajo
     continúa. activos. Si el nuevo índice abierto es el .nico asociado al
     área de trabajo, se convierte en el índice de control. En caso
     contrario, el orden de control permanece inalterado.

     Despu.s de que se haya abierto el nuevo fichero ííndice, el .rea de
     trabajo se sit.a en el primer registro l.gico en el orden de control.

     DBSETINDEX() realiza la misma función que un mandato SET INDEX estándar
     o la cláusula INDEX del mandato USE. Si desea más información, consulte
     el mandato SET INDEX.

 Notas

     .  Registros lógicos: La activaci.n de un ííndice afecta al
        orden l.gico de los registros del área de trabajo. Es decir, cuando
        un ííndice est. activo, los mandatos que act.an sobre los registros
        lógicos procesan los registros en el orden del índice. Si el índice
        de control es un ííndice con el atributo de unicidad, los registros
        que tengan claves de índice duplicadas no son visibles.

     .  Entorno de red: DBSETINDEX() abre el índice en modo
        compartido si el fichero de base de datos asociado fue abierto en
        modo compartido. De lo contrario, el índice se abre en modo
        exclusivo.

 Ejemplos

     .  El ejemplo siguiente establece ííndices m.ltiples:

     cApellido := "L.pez"
        DBUSEAREA(.T., "DBFNTX", "Ventas", "Ventas", .T.)
        DBSETINDEX( "NOMBRE" )
        DBSETINDEX( "APELLIDO" )
        //
        IF ( Ventas->(DBSEEK(cApellido)) )
           IF Ventas->( DELETED() ) .AND. Ventas->( RLOCK() )
              Ventas->( DBRECALL() )
              ? "Se ha recuperado el registro borrado."
           ENDIF

        ELSE
           ? "No encontrado"
        ENDIF

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.


DBSETORDER()
 Establece el orden de control
------------------------------------------------------------------------------
 Sintaxis

     DBSETORDER(<nN.mOrden>) --> NIL

 Argumentos

     <nN.mOrden> es un valor numérico que especifica cu.l de los ííndices
     activos debe ser el índice de control.

 Devuelve

     DBSETORDER() devuelve siempre NIL.

 Descripción

     DBSETORDER() controla cu.l de los ííndices activos en el área de trabajo
     actual es el índice de control. El índice de control es el que determina
     el orden l.gico de los registros del área de trabajo.

     Los ííndices activos se numeran del uno al número de ííndices activos,
     según el orden en que se abrieron los ííndices. <nN.mOrden> especifica el
     número de índice deseado.

     DBSETORDER() realiza la misma función que un mandato SET ORDER estándar.
     Si desea más información, consulte el mandato SET ORDER.

 Notas

     .  Poner a cero el orden: Si se pone a cero el orden, se
        accede al área de trabajo en su orden natural (número de registro).
        S.lo se ve afectado el orden l.gico de los registros; cualquier
        índice que haya abierto continúa.activo y se mantiene adecuadamente.

 Ejemplos

     .  Este ejemplo establece el segundo índice, llamado Edad, como
        el índice de control:

        USE Empleado NEW
        SET INDEX TO Nombre, Edad
        DBSETORDER(2)

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.


DBSETRELATION()
 Relaciona dos .reas de trabajo
------------------------------------------------------------------------------
 Sintaxis

     DBSETRELATION(<nArea> | <cAlias>, <bExpr>, [<cExpr>])    --> NIL

 Argumentos

     <nArea> es un valor numérico que especifica el número del .rea de
     trabajo hija.

     <cAlias> es un valor de carácteres que especifica el alias del .rea
     de trabajo hija.

     <bExpr> es un bloque de código que contiene la expresión de la
     relaci.n, en forma ejecutable.

     <cExpr> es un valor opciónal de carácteres que expresa la expresión
     relacional en forma de texto. Si se omite <cExpr>, la función
     DBRELATION() devuelve una cadena vac.a para la relaci.n.

 Devuelve

     DBSETRELATION() devuelve siempre NIL.

 Descripción

     DBSETRELATION() relaciona el área de trabajo especificada por <nArea> o
     <cAlias> (el área de trabajo hija), con el área de trabajo actual (el
     área de trabajo padre). Cualquier relaci.n existente permanece activa.

     Las .reas de trabajo relacionadas sincronizan las .reas de trabajo hijas
     con el área de trabajo padre. Esto se consigue desplazando
     autom.ticamente el área de trabajo hija cuando el área de trabajo padre
     se desplaza a un nuevo registro. Si existe un ííndice activo en el .rea
     de trabajo hija, al desplazar el área de trabajo padre se ejecuta una
     operación.SEEK autom.tica en el área de trabajo hija; la clave de
     b.squeda se basa en la expresión especificada mediante <bExpr> y/o
     <cExpr>. Si el área de trabajo hija no tiene un ííndice activo, al
     desplazar el área de trabajo padre se ejecuta un GOTO autom.tico en el
     área de trabajo hija; el número de registro para GOTO se basa en la
     expresión especificada por <bExpr> y/o <cExpr>.

     La expresión de relaci.n puede ser un bloque de código (<bExpr>) o un
     bloque de código y un texto equivalente (<cExpr>). Si se utilizan ambas
     versiones, deben ser equivalentes. Si se omite la versi.n de texto,
     DBRELATION() devuelve una cadena vac.a para la relaci.n.

     DBSETRELATION() realiza la misma función que un mandato SET RELATION
     estándar con la cláusula ADDITIVE. Si desea más información, consulte el
     mandato SET RELATION.

 Notas

     .  Efectos laterales: DBSETRELATION() sólo garantiza la
        sincronizaci.n de las .reas de trabajo, seg.n se describe m.s arriba.
        Si la expresión relacional se basa en información externa al .rea de
        trabajo superior o en su fichero de base de datos asociado, el efecto
        es impredecible. Si la expresión cambia el estado de cualquier .rea
        de trabajo (por ejemplo, desplazando el cursor a un registro
        diferente o cambiando el contenido de un registro), el efecto es
        impredecible.

     .  Contexto de evaluaci.n: Al evaluar la expresión
        relacional, el área de trabajo padre se selecciona autom.ticamente
        como el .rea actual antes de proceder a la evaluaci.n:
        posteriormente, el área de trabajo anterior se restablece
        autom.ticamente.

     .  B.squeda aproximada: Las operación.s de b.squeda que se
        producen como parte del posiciónamiento relacional no son nunca
        b.squedas aproximadas. Si el movimiento relacional no tiene .xito, el
        área de trabajo secundaria se sit.a en LASTREC() + 1, el estado
        FOUND() devuelve falso (.F.) y el estado EOF() devuelve verdadero
        (.T.).

 Ejemplos

     .  Este ejemplo muestra una de los usos m.s frecuentes de la
        función DBSETRELATION():

        USE Empleado NEW
        USE Departamento NEW INDEX Dept
        SELECT Empleado
        DBSETRELATION("Departamento", {|| Empleado->Dept},;
                        "Empleado->Dept")
        LIST Empleado->Nombre, Departamento->Nombre

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.



DBSKIP()
 Desplaza el puntero respecto al registro actual
------------------------------------------------------------------------------
 Sintaxis

     DBSKIP([<nRegistros>]) --> NIL

 Argumentos

     <nRegistros> es el número de registros lógicos que se va a
     desplazar, respecto al registro actual. Un valor positivo significa
     saltar hacia adelante y uno negativo hacerlo hacia atr.s. Si se omite
     este argumento, se supone un valor de 1.

 Devuelve

     DBSKIP() devuelve siempre NIL.

 Descripción

     DBSKIP() desplaza hacia adelante o hacia atr.s el puntero respecto al
     registro actual. Si se intenta pasar m.s all. del último registro, el
     área de trabajo se sit.a en LASTREC() + 1 y EOF() devuelve verdadero
     (.T.). Si intenta pasar antes del primer registro, el área de trabajo se
     sit.a en el primer registro y BOF() devuelve verdadero (.T.).

     DBSKIP() realiza la misma función que un mandato SKIP estándar. Si desea
     más información, consulte el mandato SKIP.

 Notas

     .  Registros lógicos: DBSKIP() act.a en registros lógicos. Si
        existe un ííndice activo, los registros se visualizan en el orden
        indexado. Si se establece un filtro, sólo se visualizan los registros
        que cumplan con la condición del filtro.

     .  Orden de control: Si el área de trabajo tiene m.s de un
        índice activo, se ejecuta la operación.de salto utilizando el orden
        establecido por la función DBSETORDER() o por el mandato SET ORDER.
        Si desea más información, consulte el mandato SET ORDER.

     .  Entorno de red: Al desplazarse a otro registro en un
        entorno de red, las modificaciones efectuadas en el registro actual
        se hacen visibles a los otros procesos. Si desea más información,
        consulte el capítulo Programaci.n en Red en la gu.a Programaci.n y
        Utilidades.

 Ejemplos

     .  Este ejemplo muestra una utilización t.pica de la función
        DBSKIP():

        DBGOTOP()
        DO WHILE ( !EOF() )
           ? FIELD->Nombre
           DBSKIP()
        ENDDO

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.


DBSTRUCT()
 Crea una matriz, que contiene la estructura de una base de datos
------------------------------------------------------------------------------
 Sintaxis

     DBSTRUCT() --> aEstruct

 Devuelve

     DBSTRUCT() devuelve la estructura del fichero de base de datos actual en
     una matriz, cuya longitud es igual al número de campos del fichero de
     base de datos. Cada elemento de la matriz es una submatriz, que contiene
     la información de un campo. Las submatrices tienen el formato siguiente:

     Matriz de Retorno DBSTRUCT() 
     ------------------------------------------------------------------------
     Posici.n     Metas.mbolo    Dbstruct.ch
     ------------------------------------------------------------------------
     1            cNombre        DBS_NAME
     2            cTipo          DBS_TYPE
     3            nLongitud      DBS_LEN
     4            nDecimales     DBS_DEC
     ------------------------------------------------------------------------

     Si no hay fichero de base de datos en uso en el área de trabajo actual,
     DBSTRUCT() devuelve una matriz vac.a ({}).

 Descripción

     DBSTRUCT() es una función de base de datos que act.a de forma similar a
     COPY STRUCTURE EXTENDED creando una matriz de información de estructura
     en lugar de un fichero de base de datos de información de estructura.
     Existe otra función, DBCREATE(), que puede crear un fichero de base de
     datos a partir de la matriz de estructura.

     Por defecto, DBSTRUCT() act.a en el área de trabajo seleccionada
     actualmente. funcióna en un área de trabajo no seleccionada si la
     especifica como parte de una expresión de alias, tal como se muestra a
     continúa.ión.

     Observe, que un fichero de cabecera, Dbstruct.ch, situado en
     \CLIPPER5\INCLUDE contiene una serie de constantes declaradas para cada
     atributo de campo.

 Ejemplos

     .  Este ejemplo abre dos ficheros de base de datos, después, se
        crea una matriz que contiene la estructura de base de datos,
        utilizando DBSTRUCT() en una expresión alias. Los nombres de campo se
        listan utilizando AEVAL():

        #include "Dbstruct.ch"
        //
        LOCAL aEstruct
        USE Cliente NEW
        USE Facturas NEW
        //
        aEstruct := Cliente->(DBSTRUCT())
        AEVAL( aEstruct, {|aCampo| QOUT(aCampo[DBS_NAME])} )

 Ficheros:  La biblioteca asociada es CLIPPER.LIB,
            el fichero de cabecera es Dbstruct.ch.


DBUNLOCK()
 Libera todos los bloqueos del área de trabajo actual
------------------------------------------------------------------------------
 Sintaxis

     DBUNLOCK() --> NIL

 Devuelve

     DBUNLOCK() devuelve siempre NIL.

 Descripción

     DBUNLOCK() libera cualquier bloqueo de registro o fichero obtenido
     mediante el proceso actual en el área de trabajo actual. DBUNLOCK() sólo
     es significativo en una base de datos compartida en un entorno de red.

     DBUNLOCK() realiza la misma función que un mandato UNLOCK estándar. Si
     desea más información, consulte el mandato UNLOCK.

 Notas

     .  Entorno de red: Al desplazarse a otro registro en un
        entorno de red, las modificaciones efectuadas en el registro actual
        se hacen visibles a los otros procesos. Si desea más información,
        consulte el capítulo Programaci.n en Red de la gu.a Programaci.n y
        Utilidades.

 Ejemplos

     .  En el ejemplo siguiente se ilustra una utilización b.sica de
        la función DBUNLOCK():

        cApellido := "L.pez"
        USE Ventas SHARED NEW VIA "DBFNTX"
        DBSETINDEX( "APELLIDO" )
        //
        IF ( Ventas->(DBSEEK(cApellido)) )
           IF Ventas->( RLOCK() )
              Ventas->( DBDELETE() )
              ? "Registro borrado: ", Ventas->( DELETED() )
              Ventas->( DBUNLOCK() )
           ELSE
              ? "No puede bloquearse el registro..."
           ENDIF
        ELSE
           ? "No encontrado"
        ENDIF

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.



DBUNLOCKALL()
 Libera todos los bloqueos en todas las áreas de trabajo
------------------------------------------------------------------------------
 Sintaxis

     DBUNLOCKALL() --> NIL

 Devuelve

     DBUNLOCKALL() devuelve siempre NIL.

 Descripción

     DBUNLOCKALL() libera cualquier bloqueo de registro o de fichero
     realizado con el proceso actual en cualquier área de trabajo.
     DBUNLOCKALL() sólo es significativo en una base de datos compartida en
     un entorno de red. Equivale a utilizar DBUNLOCK() en las .reas de
     trabajo ocupadas.

     DBUNLOCKALL() realiza la misma función que un mandato UNLOCK ALL. Si
     desea más información, consulte el mandato UNLOCK ALL.

 Ejemplos

     .  En el ejemplo siguiente se marca un registro para borrarlo, si
        el intento de ejecutar RLOCK() ha sido satisfactorio, y luego elimina
        todos los bloqueos en todas las áreas de trabajo:

        cApellido := "L.pez"
        USE Ventas SHARED NEW VIA "DBFNTX"
        DBSETINDEX( "NOMVENDE" )
        DBSETINDEX( "APEVENDE" )
        //
        USE DISTRIBU SHARED NEW VIA "DBFNTX"
        DBSETINDEX( "NOMDISTR" )
        DBSETINDEX( "APEDISTR" )
        //
        DBSELECTAREA( "Ventas" )         // seleccionar el .rea
                                         // de trabajo "Ventas"
        //
        IF ( Distribu->(DBSEEK(cApellido)) )
           IF Distribu->( DELETED() )
              ? "Registro borrado: ", Distribu->( DELETED() )
              IF Distribu->( RLOCK() )
                 Distribu->( DBRECALL() )
                 ? "Registro recuperado..."
              ENDIF
           ENDIF
        ELSE
           ? "No encontrado"
           DBUNLOCKALL()                 // eliminar todos los bloqueos
        ENDIF                            // en las .reas de trabajo

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.


DBUSEAREA()
 Abre un fichero de base de datos en un área de trabajo
------------------------------------------------------------------------------
 Sintaxis

     DBUSEAREA( [<lAreaNueva>], [<cControlador>], <cNombre>,
                  [<xcAlias>], [<lCompartido>], [<lSoloLectura>]) --> NIL

 Argumentos

     <lAreaNueva> es un valor l.gico opciónal. Un valor verdadero (.T.)
     selecciona el área de trabajo no ocupada que tenga la numeraci.n m.s
     baja como el área de trabajo actual antes de la utilización. Si
     <lAreaNueva> es falso (.F.) o se omite, se utiliza el área de trabajo
     actual. Si el área de trabajo est. ocupada se cierra primero.

     <cControlador> es un valor opciónal de carácteres. Si se indica
     especifica el nombre del controlador de la base de datos que se
     utilizar. con al área de trabajo. Si se omite <cControlador>, se utiliza
     el controlador por defecto actual (consulte la nota siguiente).

     <cNombre> especifica el nombre del fichero de base de datos (.dbf)
     que va a abrirse.

     <xcAlias> es un valor opciónal de carácteres. Si se indica,
     especifica el alias que va a asociarse con el área de trabajo. El alias
     debe ser un identificador víaacute;lido de CA-Clipper. Un <xcAlias> víaacute;lido
     puede ser cualquier identificador legal (es decir, debe comenzar con un
     carácter alfabético y puede contener carácteres numéricos o alfabéticos
     y el de subrayado). En una aplicación, CA-Clipper no acepta alias
     duplicados. Si se omite <xcAlias>, el alias por defecto es <cNombre>.

     <lCompartido> es un valor l.gico opciónal. Si se indica, especifica
     si el fichero de base de datos (.dbf) debe ser accesible a los otros
     procesos de una red. Un valor verdadero (.T.) especifica que otros
     procesos podr.n acceder; un valor falso (.F.) especifica que el proceso
     actual debe tener acceso exclusivo. Si se omite <lCompartido>, el valor
     global actual de SET EXCLUSIVE determina si se permite el acceso
     compartido.

     <lS.loLectura> es un valor l.gico opciónal que especifica si se
     prohiben las actualizaciones en el área de trabajo actual. Un valor
     verdadero (.T.) prohibe las actualizaciones; un valor falso (.F.) las
     permite. Un valor verdadero (.T.) también permite el acceso de sólo
     lectura al fichero de base de datos (.dbf) especificado. Si se omite
     <lS.loLectura>, el valor por defecto es falso (.F.).

 Devuelve

     DBUSEAREA() devuelve siempre NIL.

 Descripción

     DBUSEAREA() asocia el fichero de base de datos (.dbf) especificado con
     el área de trabajo actual.

     DBUSEAREA() realiza la misma función que un mandato USE estándar. Si
     desea más información, consulte el mandato USE.

 Notas

     .  Controlador actual: Si no se especifica ningún controlador
        con la llamada a DBUSEAREA() se utiliza el controlador por defecto.
        Si est. disponible m.s de un controlador para la aplicación, el
        controlador por defecto es el especificado en la llamada m.s reciente
        a DBSETDRIVER(). Si no se ha invocado antes DBSETDRIVER(), el nombre
        del controlador por defecto no est. determinado.

 Ejemplos

     .  Este ejemplo es una utilización t.pica de la función
        DBUSEAREA():

        DBUSEAREA(.T., "DBFNDX", "Empleados")

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.


DELETED()
  Devuelve el estado del indicador de borrado del registro actual
------------------------------------------------------------------------------
 Sintaxis

     DELETED() --> lBorrado

 Devuelve

     DELETED() devuelve verdadero (.T.) si el registro actual est. marcado
     para borrarse; de lo contrario, devuelve falso (.F.). Si no existe
     fichero de base de datos en uso en el área de trabajo actual, DELETED()
     devuelve falso (.F.).

 Descripción

     DELETED() es una función de base de datos que determina si el registro
     actual del área de trabajo activa est. marcado para borrarse. Puesto que
     cada área de trabajo con un fichero de base de datos abierto puede tener
     un registro actual, cada área de trabajo tiene su propio valor
     DELETED().

     Por defecto, DELETED() funcióna en el área de trabajo seleccionada
     actualmente. funcióna en un área de trabajo no seleccionada si lo
     especifica como parte de una expresión de alias (consulte el ejemplo
     siguiente).

     En las aplicaciónes, DELETED() se utiliza normalmente para consultar el
     estado borrado como parte de las condiciónes de tratamiento de registros
     o para mostrar el estado borrado como una parte de pantallas e informes.

 Ejemplos

     .  Este ejemplo utiliza DELETED() en el área de trabajo actual y
        en una no seleccionada:

        USE Cliente NEW
        USE Ventas NEW
        ? DELETED()                      // Resultado: .F.
        DELETE
        ? DELETED()                      // Resultado: .T.
        ? Cliente->(DELETED())           // Resultado: .F.

     .  Este ejemplo utiliza DELETED() para mostrar un estado de
        borrado de registro en pantallas e informes:

        @ 1, 65 SAY IF(DELETED(), "Inactivo", "Activo")

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.


DESCEND()
 Crea un valor clave para un ííndice descendente
------------------------------------------------------------------------------
 Sintaxis

     DESCEND(<exp>) --> ValorDescendente

 Argumentos

     <exp> es cualquier expresión víaacute;lida de carácter, fecha, l.gica o
     numérica. El tipo memo se trata del mismo modo que el tipo de
     carácteres.

 Devuelve

     DESCEND() devuelve una expresión invertida del mismo tipo de datos que
     <exp>, con la excepci.n de las fechas que devuelven un valor numérico.
     Si se aplica DESCEND() a CHR(0), devuelve siempre CHR(0).

 Descripción

     DESCEND() es una función de conversión que devuelve la forma inversa de
     la expresión especificada, que va a utilizarse con INDEX para crear
     ííndices en orden descendente. Especifique qu. parte de la expresión
     clave desea que sea descendente como el argumento DESCEND(). Si desea
     ejecutar posteriormente una b.squeda con SEEK, especifique DESCEND() en
     la expresión de b.squeda.

 Notas

     .  La forma preferible de crear un ííndice descendente es útilizar
        la cláusula DESCENDING del mandato INDEX. La utilización de
        DESCENDING es equivalente a especificar la función DESCEND(), pero
        sin reducir la velocidad durante las actualizaciones de índice. Si
        crea un ííndice DESCENDING, no necesita utilizar la función DESCEND()
        durante SEEK. DESCENDING es un atributo del fichero (.ntx), donde se
        almacena y se utiliza para reindexados.

 Ejemplos

     .  Este ejemplo utiliza DESCEND() en una expresión INDEX para
        crear un ííndice de fecha de orden descendente:

        USE Ventas NEW
        INDEX ON DESCEND(FechaPedido) TO FechaVentas

        Luego, utilice DESCEND() para efectuar la b.squeda en el índice
        descendente:

     SEEK DESCEND(dBuscarFecha)

     .  Este ejemplo ilustra c.mo crear un ííndice de orden
        descendente, utilizando m.s de un tipo de datos. Aqu., la clave se ha
        creado concatenando campos de fecha y de carácteres después de que se
        haya realizado la conversión del tipo apropiado. Este ejemplo utiliza
        STR() en lugar de DTOS() puesto que DESCEND() de una fecha devuelve
        un valor numérico:

        USE Ventas NEW
        INDEX ON STR(DESCEND(FechaVenta)) + Vendedor TO ULTVENDA

 Ficheros:  La biblioteca asociada es EXTEND.LIB.


DEVOUT()
 Escribe un valor en el dispositivo de salida actual
------------------------------------------------------------------------------
 Sintaxis

     DEVOUT(<exp>, [<cCadenaColor>]) --> NIL

 Argumentos

     <exp> es el valor que va a mostrarse.

     <cCadenaColor> es un argumento opciónal que define el color de la
     pantalla de <exp>. Si se ha establecido SET DEVICE TO SCREEN, la salida
     se muestra en el color especificado.

     Si no se especifica, <exp> se muestra en el color estándar del sistema
     actual, seg.n se define mediante SETCOLOR(). <cCadenaColor> es una
     expresión de carácteres que contiene la selecci.n de color estándar. Si
     desea especificar una selecci.n de color literal, debe encerrarla entre
     comillas.

 Devuelve

     DEVOUT() devuelve siempre NIL.

 Descripción

     DEVOUT() es una función de visualización de pantalla completa, que
     escribe el valor de una expresión sencilla en el dispositivo de salida
     actual en la posición actual del cursor o en la posición del cabezal de
     impresi.n. STD.CH usa DEVOUT() con DEVPOS() para definir el mandato
     @...SAY.

 Ejemplos

     .  Este ejemplo muestra la relaci.n entre la función DEVOUT() y
        el mandato @...SAY:

        DEVPOS(10, 10)
        DEVOUT("Hola .qu. tal?", "BG+/B"))
        //
        @ 10, 10 SAY "Hola .qu. tal?" COLOR "BG+/B"

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.


DEVOUTPICT()
 Escribe un valor en el dispositivo de salida actual utilizando un patr.n de
 formato
------------------------------------------------------------------------------
 Sintaxis

     DEVOUTPICT(<exp>, <cPatrónFormato>, [<cCadenaColor>]) --> NIL

 Argumentos

     <exp> es el valor que va a mostrarse.

     <cPatrónFormato> define el patr.n de formato para la visualización
     de <exp>. El patr.n de formato aqu. especificado es el mismo que se
     utiliza con @...SAY o TRANSFORM y puede incluir plantillas y funciónes.

     <cCadenaColor> es un argumento opciónal que define el color de
     visualización de <exp>. Si se ha establecido SET DEVICE TO SCREEN, la
     salida se muestra en el color especificado.

     Si no se especifica, <exp> se muestra como el color estándar del sistema
     actual, definido con SETCOLOR(). <cCadenaColor> es una expresión de
     carácteres que contiene la selecci.n de color estándar. Si desea
     especificar una selecci.n de color literal, debe encerrarla entre
     comillas.

 Devuelve

     DEVOUTPICT() devuelve siempre NIL.

 Descripción

     DEVOUTPICT() es una función de visualización de pantalla completa, que
     escribe el valor de una expresión en el dispositivo de salida actual, en
     la posición actual del cursor o del cabezal de impresión. DEVOUTPICT()
     se utiliza con DEVPOS() en STD.CH para definir el mandato @...SAY
     utilizado con una cláusula PICTURE.

 Ejemplos

     .  Este ejemplo muestra la relaci.n entre la función DEVOUTPICT()
        y el mandato @...SAY:

        DEVPOS(10, 10)
        DEVOUTPICT("Hola .qu. tal?", "@!", "BG+/B"))
        //
        @ 10, 10 SAY "Hola .qu. tal?" PICTURE "@!" COLOR "BG+/B"

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.


DEVPOS()
 Desplaza el cursor o el cabezal de impresión a una nueva posición, según el
 dispositivo actual
------------------------------------------------------------------------------
 Sintaxis

     DEVPOS(<nFila>, <nCol>) --> NIL

 Argumentos

     <nFila> y <nCol> son las nuevas posiciónes de fila y columna del
     cursor o del cabezal de impresión.

 Devuelve

     DEVPOS() devuelve siempre NIL.

 Descripción

     DEVPOS() es una función de entorno, que sit.a el cursor en la pantalla o
     desplaza el cabezal de impresión, en función del valor actual de SET
     DEVICE. Si se ha establecido SET DEVICE TO SCREEN, DEVPOS() act.a igual
     que SETPOS(): desplaza el cursor a la situaci.n especificada y actualiza
     ROW() y COL() con la nueva posición del cursor.

     Si se ha establecido SET DEVICE TO PRINTER, DEVPOS() desplaza el cabezal
     de impresión. Para ello, envía cierto número de carácteres de salto de
     línea y/o de salto de p.gina a la impresora, haciendo avanzar la cabeza
     de impresión a la nueva posición. Si el valor de SET MARGIN actual es
     mayor que cero, dicho valor se a.ade a <nCol>. El cabezal de impresión
     se desplaza a la posición espec.fica de <nFila> y <nCol> y PROW() y
     PCOL() se actualizan. Si <nFila> o <nCol> son menores que los valores
     PROW() y PCOL() actuales, el cabezal de impresión se desplaza seg.n
     estas reglas:

     .  Si <nFila> es menor que PROW(), se envía un EJECT (CHR(12))
        autom.tico a la impresora seguido por el número de carácteres de
        salto de línea (CHR(10)) necesarios para situar la cabeza de
        impresi.n en la <nFila> de la p.gina siguiente.

     .  Si <nCol>, incluyendo el valor de SET MARGIN actual, es menor
        que PCOL(), se envían a la impresora un carácter de retorno de carro
        (CHR(13)) y el número de carácteres de espacio necesarios para situar
        la cabeza de impresión en <nCol>.

     Si desea evitar este comportamiento, utilice SETPRC() para asignar los
     nuevos valores a PROW() y PCOL() antes de utilizar DEVPOS(). Consulte la
     Descripción de SETPRC() si desea más información.

     Si la salida de la impresora se redirige a un fichero utilizando el
     mandato SET PRINTER, DEVPOS() actualiza el fichero en lugar de la
     impresora.

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.



DIRECTORY()
 Crea una matriz de información de directorios y de ficheros
------------------------------------------------------------------------------
 Sintaxis

     DIRECTORY(<cEspecDir>, [<cAtributos>]) --> aDirectorio

 Argumentos

     <cEspecDir> identifica la unidad, el directorio y el fichero para la
     b.squeda en el directorio. Se permiten carácteres comod.n en la
     especificación de fichero. Si se omite <cEspecDir>, el valor por defecto
     es *.*.

     <cAtributos> incluye en la información devuelta los ficheros que
     tengan los atributos especificados. <cAtributos> es una cadena, que
     contiene uno o m.s de los carácteres siguientes:

     Atributos DIRECTORY() 
     ------------------------------------------------------------------------
     Atributo     Significado
     ------------------------------------------------------------------------
     H            Incluir ficheros ocultos
     S            Incluir ficheros del sistema
     D            Incluir directorios
     V            Buscar la etiqueta de volumen del DOS y excluir el resto de
                  los ficheros
     ------------------------------------------------------------------------

     Los ficheros normales siempre se incluyen en la b.squeda, a menos que
     especifique V.

 Devuelve

     DIRECTORY() devuelve una matriz de submatrices, cada una conteniendo
     información de cada fichero que cumpla la <cEspecDir>. La submatriz
     tiene la estructura siguiente:

     Estructura de Submatriz DIRECTORY() 
     ------------------------------------------------------------------------
     Posici.n     Metas.mbolo    Directry.ch
     ------------------------------------------------------------------------
     1            cNombre        F_NAME
     2            cTama.o        F_SIZE
     3            fFecha         F_DATE
     4            cHora          F_TIME
     5            cAtributos     F_ATT
     ------------------------------------------------------------------------

     Si no se encuentran ficheros que coincidan con <cEspecDir> o si
     <cEspecDir> es una vía o una especificación de fichero ilegal,
     DIRECTORY() devuelve una matriz vac.a ({}).

 Descripción

     DIRECTORY() es una función de entorno que devuelve información sobre los
     ficheros en el directorio actual o en el directorio especificado. Es
     similar a ADIR(), pero devuelve una sola matriz en lugar de a.adir
     valores a una serie de matrices existentes pasadas por referencia.

     Utilice DIRECTORY() para ejecutar acciones en grupos de ficheros. En
     combinación con AEVAL(), puede definir un bloque que puede aplicarse a
     todos los ficheros que cumplan la <cEspecDir> especificada.

     El fichero de cabecera, Directry.ch, situado en el subdirectorio
     \CLIPPER5\INCLUDE contiene #defines para los subííndices de submatriz, a
     fin de mejorar la legibilidad de referencias a cada submatriz.

 Ejemplos

     .  Este ejemplo crea una matriz de información sobre ficheros en
        el directorio actual y después se listan los nombres de los ficheros
        utilizando AEVAL() y QOUT():

     #include "Directry.ch"
        //

        aDirectorio := DIRECTORY("*.*", "D")
        AEVAL( aDirectorio, {|aFichero| QOUT(aFichero[F_NAME])} )

 Ficheros:  La biblioteca asociada es CLIPPER.LIB,
            el fichero de cabecera es Directry.ch.



DISKSPACE()
 Devuelve el espacio disponible en el disco especificado
------------------------------------------------------------------------------
 Sintaxis

     DISKSPACE([<nUnidad>]) --> nBytes

 Argumentos

     <nUnidad> es el número de la unidad que se va a examinar, donde uno
     es la unidad A, dos es B, tres es C, etc. Si se omite <nUnidad> o se
     especifica cero, el valor por defecto es la unidad DOS actual.

 Devuelve

     DISKSPACE() devuelve el número de bytes de espacio vac.o en la unidad de
     disco especificada, en forma de valor numérico entero.

 Descripción

     DISKSPACE() es una función de entorno que determina el número de bytes
     disponibles en la unidad de disco especificada. Se utiliza antes de
     ejecutar un mandato COPY o SORT en otra unidad, para determinar si
     existe suficiente espacio. También puede utilizarse con RECSIZE() y
     RECCOUNT() para crear un procedimiento para realizar una copia de
     seguridad de ficheros de base de datos.

     DISKSPACE() es independiente del valor de SET DEFAULT.

 Ejemplos

     .  Este ejemplo es una función definida por el usuario que
        muestra la utilización de DISKSPACE() para hacer una copia de
        seguridad de un fichero de base de datos en otra unidad:

     FUNCTION CopiaSeg( cFicheroDestáno, cUnidadDestáno )
           LOCAL nEspacioNecesario, nUnidadDestáno
           //
           nEspacioNecesario := INT((RECSIZE() * ;
              LASTREC()) + HEADER() + 1)
           nUnidadDestáno := ASC(UPPER(cUnidadDestáno)) - 64
           //
           IF DISKSPACE(nUnidadDestáno) < nEspacioNecesario
              RETURN .F.
           ENDIF
           COPY TO (cUnidadDestáno + ":" + cFicheroDestáno)

           //
           RETURN .T.

 Ficheros:  La biblioteca asociada es EXTEND.LIB,
            el fichero fuente es EXAMPLEC.C.



DISPBEGIN()
 Inicia el almacenamiento en memoria intermedia de la salida por pantalla
------------------------------------------------------------------------------
 Sintaxis

     DISPBEGIN() --> NIL

 Devuelve

     DISPBEGIN() devuelve siempre NIL.

 Descripción

     DISPBEGIN() es una función de pantalla, que informa al sistema de salida
     por pantalla de CA-Clipper que la aplicación va a realizar una serie de
     operación.s de pantalla.

     Utilice DISPBEGIN() con DISPEND() para permitir que el sistema de salida
     en pantalla sit.e en la memoria intermedia las actualizaciones que se
     realicen. La salida en pantalla comprendida entre DISPBEGIN() y
     DISPEND() se almacena en las memorias intermedias internas. Al
     ejecutarse DISPEND() , las actualizaciones pendientes aparecen en la
     pantalla f.sica. Es .til en aplicaciónes cuyas visualizaciónes sean
     complejas y lentas y en las que se desea aumentar la velocidad.

     Las llamadas DISPBEGIN() y DISPEND() son opciónales. No son necesarias
     para la salida normal.

 Notas

     .  Llamadas anidadas: Las llamadas DISPBEGIN() pueden
        anidarse internamente. Si se producen varias llamadas DISPBEGIN(), se
        permite el almacenamiento en la memoria intermedia hasta que se
        produzca el número correspondiente de llamadas DISPEND().

     .  Operaciones garantizadas: Las actualizaciones de pantalla
        realizadas entre DISPBEGIN() y DISPEND() no siempre están almacenadas
        en la memoria intermedia. Algunas actualizaciones pueden hacerse
        visibles antes de invocar DISPEND(). Sin embargo, todas las
        actualizaciones son visibles después de la llamada DISPEND() de
        cierre.

     .  Operaciones de terminal: No deben realizarse operación.s
        de entrada de terminal, como por ejemplo, INKEY() o READ entre
        DISPBEGIN() y DISPEND(). En caso contrario, puede perderse la entrada
        o la salida por la pantalla.

     .  Operaciones incompatibles: La salida de pantalla de otras
        funciónes de visualización que no sean de CA-Clipper (por ejemplo,
        mediante bibliotecas incorporadas o por el DOS a trav.s de OUTSTD(),
        etc.) pueden no ser compatibles con DISPBEGIN() y DISPEND(). Es
        posible que se pierda la salida.

 Ejemplos

     .  Este ejemplo almacena en la memoria intermedia la salida de
        pantalla, actualiza la pantalla y después muestra la salida de la
        memoria intermedia:

        DISPBEGIN()         // Iniciar almacenamiento de la pantalla
        //
        SETPOS(10, 10)
        DISPOUT("Una actualizaci.n de pantalla")
        SETPOS(11, 10)
        DISPOUT("Otra visualización de pantalla")
        //
        DISPEND()         // Mostrar los datos de la memoria
                          // intermedia

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.


DISPBOX()
 Muestra un cuadro en la pantalla
------------------------------------------------------------------------------
 Sintaxis

     DISPBOX(<nSup>, <nIzq>, <nInf>, <nDer>,
        [<cnCadenaCuadro>], [<cCadenaColor>]) --> NIL

 Argumentos

     <nSup>, <nIzq>, <nInf> y <nDer> definen las coordenadas
     del cuadro. DISPBOX() dibuja un cuadro utilizando valores de fila
     comprendidos entre cero y MAXROW() y valores de columna entre cero y
     MAXCOL(). Si <nInf> y <nDer> son mayores que MAXROW() y MAXCOL(), el
     .ngulo inferior derecho se dibuja fuera de la pantalla.

     <cnCadenaCuadro> es una expresión numérica o de carácteres que
     define los carácteres de borde del cuadro. Si se especifica como una
     expresión numérica, un valor 1 muestra un cuadro de una línea y un valor
     2 muestra un cuadro de dos líneas. El resto de valores numéricos
     muestran un cuadro de una sola línea.

     Si <cnCadenaCuadro> es una expresión de carácteres, especifica los
     carácteres que van a utilizarse para dibujar el cuadro. Esta es una
     cadena de ocho carácteres de borde y uno de relleno. Si se especifica
     <cnCadenaCuadro> como un sólo carácter, dicho carácter se utiliza para
     dibujar todo el cuadro.

     Si no se especifica este argumento, se dibuja un cuadro de una sola
     línea.

     <cCadenaColor> define el color de pantalla del cuadro que se va a
     dibujar. Si no se especifica, el cuadro se dibuja en el color estándar
     del sistema actual, tal como se define con SETCOLOR().

 Devuelve

     DISPBOX() devuelve siempre NIL.

 Descripción

     DISPBOX() es una función de pantalla, que dibuja un cuadro en las
     coordenadas de pantalla especificadas, en el color indicado. Si
     especifica <cnCadenaCuadro>, DISPBOX() dibuja un cuadro en la pantalla,
     utilizando un borde configurable y carácteres de relleno. DISPBOX()
     dibuja el cuadro utilizando <cnCadenaCuadro> comenzando por el .ngulo
     superior izquierdo, siguiendo en sentido de las agujas del reloj y
     llenando el .rea de la pantalla con el noveno carácter. Si no se
     especifica dicho carácter, el .rea de pantalla dentro del cuadro no se
     dibuja. El texto existente y el color permanecen inalterables.

     Despu.s de ejecutar DISPBOX(), el cursor se encuentra en el .ngulo
     superior de la regi.n del cuadro, en <nSup> + 1 y <nIzq> + 1. ROW() y
     COL() también se actualizan para reflejar la nueva posición del cursor.

     Recuerde que Box.ch, situado en \CLIPPER5\INCLUDE, proporciona
     constantes para diversas configuraciónes de borde.

 Ejemplos

     .  Este código de ejemplo muestra un cuadro de doble línea
        utilizando un valor numérico para especificar el borde del cuadro:

        #define B_SINGLE   1
        #define B_DOUBLE   2
        //
        DISPBOX(1, 1, 10, 10, B_DOUBLE, "BG+/B")

     .  Este ejemplo muestra un cuadro de una sola línea en la parte
        superior y un cuadro con dos líneas en la parte lateral de la
        pantalla, especificando carácteres de borde con una constante
        declarada definida en Box.ch:

        #include "Box.ch"
        //
        DISPBOX(1, 1, 10, 10, B_SINGLE_DOUBLE, "BG+/B")

 Ficheros:  La biblioteca asociada es CLIPPER.LIB,
            el fichero de cabecera es Box.ch.


DISPCOUNT()
 Devuelve el número de llamadas DISPEND() pendientes
------------------------------------------------------------------------------
 Sintaxis

     DISPCOUNT() --> nN.mLlamadas

 Devuelve

     DISPCOUNT() devuelve el número de llamadas DISPEND() necesarias para
     restablecer el contexto de la pantalla original.

 Descripción

     DISPCOUNT() permite determinar el contexto de la pantalla actual.
     CA-Clipper utiliza los contextos de pantalla para las operación.s de
     supervisi.n del almacenamiento en la memoria intermedia y de la
     visualización.

     Cada llamada a DISPBEGIN() define un nuevo contexto de pantalla. No
     puede salirse de ese contexto de pantalla hasta que se ejecute la
     sentencia DISPEND() correspondiente.

     Puesto que es posible anidar llamadas DISPBEGIN(), puede utilizar
     DISPCOUNT() para determinar si existen llamadas pendientes de
     actualizaci.n de pantalla.

 Ejemplos

     .  Este ejemplo guarda la selecci.n de DISPCOUNT(), después
        libera todos los contextos de pantalla pendientes y luego escribe la
        pantalla:

        PROCEDURE ObligarVisualz(cExp)
           LOCAL nGuardVeces

        nGuardVeces := DISPCOUNT()

        // Descartar todos los contextos pendientes
        DO WHILE ( DISPCOUNT() > 0)
           DISPEND()
        ENDDO

        DISPOUT(cExp)

        // Volver al contexto de pantalla inicial
        DO WHILE (DISPCCOUNT() < nGuardVeces )
           DISPBEGIN()
        ENDDO

        RETURN

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.



DISPEND()
 Muestra en pantalla las actualizaciones almacenadas en la memoria intermedia
------------------------------------------------------------------------------
 Sintaxis

     DISPEND() --> NIL

 Devuelve

     DISPEND() devuelve siempre NIL.

 Descripción

     DISPEND() es una función de pantalla, que informa al sistema de salida
     en pantalla de CA-Clipper, que la aplicación ha finalizado una serie de
     operación.s de pantalla.

     DISPEND() se utiliza con DISPBEGIN(), para que el sistema de salida
     almacene en la memoria intermedia las actualizaciones de pantalla. Esto
     puede ser importante en aplicaciónes de visualizaciónes complejas y
     lentas, cuya velocidad se desea aumentar.

     Si desea más información, consulte DISPBEGIN()

 Ejemplos

     .  Este ejemplo almacena en la memoria intermedia la salida en
        pantalla, la actualiza y después se muestra en ella el contenido de
        la memoria intermedia:

        DISPBEGIN()         // Iniciar el almacenamiento en la
                            // memoria intermedia
        //
        SETPOS(10, 10)
        DISPOUT("Una actualizaci.n de pantalla")
        SETPOS(11, 10)
        DISPOUT("Otra actualizaci.n de pantalla")
        //
        DISPEND()           // Mostrar los datos de la memoria
                            // intermedia

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.


DISPOUT()
 Escribe un valor en la pantalla
------------------------------------------------------------------------------
 Sintaxis

     DISPOUT(<exp>, [<cCadenaColor>]) --> NIL

 Argumentos

     <exp> es el valor que se va a mostrar.

     <cCadenaColor> es un argumento opciónal, que define el color de
     presentaci.n de <exp>. Si no se especifica, <exp> se muestra en el color
     estándar del sistema, definido mediante SETCOLOR(). <cCadenaColor> es
     una expresión de carácteres que contiene la selecci.n de color estándar.
     Si desea especificar una selecci.n de color literal, debe encerrarla
     entre comillas.

 Devuelve

     DISPOUT() devuelve siempre NIL.

 Descripción

     DISPOUT() es una función de salida sencilla que escribe el valor de una
     expresión en la pantalla en la posición actual del cursor. Esta función
     ignora el valor de SET DEVICE ; la salida se dirige siempre a la
     pantalla. S.lo puede utilizarse esta función dentro de otro
     procedimiento o función.

 Ejemplos

     .  Este ejemplo muestra la salida en la pantalla en una situaci.n
        especificada utilizando colores diferentes. Observe c.mo se guarda la
        posición del cursor y se restablece utilizando ROW(), COL() y
        SETPOS():

        PROCEDURE Mostrarlo
           LOCAL nFila, nCol
           ? nCol := COL()               // guardar la posición del
           ?? nFila := ROW()             // cursor original

           INKEY(2)

           SETPOS(nFila, nCol)
           DISPOUT("Esto es una prueba de DISPOUT()")
           ? COL()                       // mostrar la posición
           ?? ROW()                      // actual del cursor

           INKEY(2)

           SETPOS(nFila, nCol)
           DISPOUT(space(26))            // borrar la posición
                                         // original
           SET DEVICE TO PRINTER         // ignorar SET DEVICE
           SETPOS(nFila, nCol)           // mostrar en la
           DISPOUT("      completa")     // posición original

           RETURN

 Ficheros: La biblioteca asociada es CLIPPER.LIB.


DOSERROR()
 Devuelve el último número de error DOS
------------------------------------------------------------------------------
 Sintaxis

     DOSERROR([<nNuevoC.digoSO>]) --> nC.digoSO

 Argumentos

     <nNuevoC.digoSO>, si se especifica, altera el valor devuelto por
     DOSERROR(). Debe ser un valor numérico que contenga un número de error
     DOS.

 Devuelve

     DOSERROR() devuelve el número de error DOS como un valor numérico
     entero.

 Descripción

     DOSERROR() es una función de error que devuelve el último código de
     error DOS que ha producido una activaci.n del bloque de error de
     ejecución. Cuando se produce un error de ejecución, la función
     DOSERROR() toma el valor del error DOS actual si la operación.tiene un
     error DOS asociado. Este valor se mantiene hasta que se produzca otro
     error de ejecución. Si la operación.fallida no tiene un error DOS
     asociado, DOSERROR() devuelve cero. Con funciónes de fichero de bajo
     nivel, FERROR() devuelve el mismo valor que DOSERROR().

     Si se pasa el argumento <nNuevoC.digoSO> opciónal puede personalizar el
     valor devuelto por la función.

     Si desea una lista completa de números de error DOS y las Descripciónes
     correspondientes, consulte la gu.a Mensajes de Error y Apííndices.

 Ficheros:  La biblioteca es CLIPPER.LIB.


DOW()
 Convierte un valor de fecha en un día de la semana numérico
------------------------------------------------------------------------------
 Sintaxis

     DOW(<fFecha>) --> nD.a

 Argumentos

     <fFecha> es el valor de fecha que se va a convertir.

 Devuelve

     DOW() devuelve el día de la semana en forma de número comprendido entre
     cero y siete. El primer día de la semana es uno (Domingo) y el último
     d.a es siete (S.bado). Si <fFecha> est. vac.a, DOW() devuelve cero.

 Descripción

     DOW() es una función de conversión de fechas que convierte un valor de
     fecha en un número que identifica el día de la semana. Permite calcular
     fechas en base semanal. DOW() es similar a CDOW(), que devuelve el d.a
     de la semana como una cadena de carácteres en lugar de como un número.

 Ejemplos

     .  Estos ejemplos ilustran CDOW() y su relaci.n con DOW():

        ? DATE()                         // Resultado: 09/01/89
        ? DOW(DATE())                    // Resultado: 3
        ? CDOW(DATE())                   // Resultado: Martes
        ? DOW(DATE() - 2)                // Resultado: 1
        ? CDOW(DATE() - 2)               // Resultado: Domingo

     .  Esta es una función que utiliza DOW() para calcular la fecha
        del último lunes de cualquier otra fecha:

        FUNCTION últimoLunes(fFecha)
           RETURN (fFecha - DOW(fFecha) + 2)

 Ficheros: La biblioteca asociada es CLIPPER.LIB.


DTOC()
 Convierte un valor de fecha en una cadena de carácteres
------------------------------------------------------------------------------
 Sintaxis

     DTOC(<fFecha>) --> cFecha

 Argumentos

     <fFecha> es el valor de fecha que se va a convertir.

 Devuelve

     DTOC() devuelve una cadena de carácteres que representa un valor de
     fecha. El valor de retorno se formatea en el formato de fecha actual. El
     formato por defecto es mm/dd/aa. Una fecha nula devuelve una cadena de
     espacios de longitud igual al formato de fecha actual.

 Descripción

     DTOC() es una función de conversión utilizada para mostrar una fecha en
     el formato establecido por SET DATE cuando se requiere una expresión de
     carácteres (por ejemplo, en un LABEL FORM). Si se necesita un formato de
     fecha especializado, puede utilizar TRANSFORM() o una expresión
     personalizada.

     Si precisa crear un ííndice con una clave que contenga una representaci.n
     de la fecha en carácteres, utilice DTOS() en lugar de DTOC() para
     convertir el valor de fecha en una cadena de carácteres.

 Ejemplos

     .  Estos ejemplos muestran la utilización general de DTOC():

        ? DATE()                     // Resultado: 09/01/90
        ? DTOC(DATE())               // Resultado: 09/01/90
        ? "Hoy es " + DTOC(DATE())   // Resultado: Hoy es 09/01/90

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.


DTOS()
 Convierte un valor de fecha en una cadena de carácteres en formato aaaammdd
------------------------------------------------------------------------------
 Sintaxis

     DTOS(<fFecha>) --> cFecha

 Argumentos

     <fFecha> es el valor de fecha que se va a convertir.

 Devuelve

     DTOS() devuelve una cadena de ocho carácteres con el formato aaaammdd.
     Si <fFecha> es una fecha nula (CTOD("")), DTOS() devuelve una cadena de
     ocho espacios. El valor de retorno no se ve afectado por el formato de
     fecha actual.

 Descripción

     DTOS() es una función de conversión de fechas que se utiliza para crear
     expresiónes de índice formadas por un valor de fecha y de una expresión
     de carácteres. DTOS() convierte un valor de fecha en una cadena que
     puede concatenarse con cualquier otra expresión de carácteres. El valor
     de retorno est. estructurado de forma que mantiene el orden de la fecha
     (a.o, mes y d.a).

 Ejemplos

     .  Estos ejemplos muestran la forma de utilizar DTOS() con otras
        funciónes:

     ? DATE()                        // Resultado: 09/01/90
        ? DTOS(DATE())               // Resultado: 19900901

        ? LEN(DTOS(CTOD("")))        // Resultado: 8

     .  Este ejemplo muestra c.mo crear un ííndice con una fecha
        compuesta y una clave de carácteres útilizando DTOS():

        USE Ventas NEW
        INDEX ON DTOS(Fecha) + Vendedor TO NombreFecha

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.

Solo personas registradas pueden poner comentarios