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.
