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 caracteres, incluidas opcionalmente la
     unidad y directorio. Si no se especifica la 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 caracteres. 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 desde
     dentro del programa 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 de
     estructura 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
        términos descriptivos y más largos. Por ejemplo, pueden
        especificarse "C" y "Character" como el atributo de tipo para campos
        de caracteres.

      En CA-Clipper, los campos de caracteres pueden contener hasta
        64.000 caracteres. 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, Dbstruct.ch. Este fichero contiene #defines para asignar un
     nombre a la posición de matriz para cada atributo de campo. Este
     fichero se encuentra en \CLIP53\INCLUDE.

 Notas

     ■ Nombres de campo duplicados: DBCREATE() no comprueba la
        existencia de nombres de campo duplicados. Por lo tanto, es tarea
        del desarrollador asegurarse de no utilizar dos veces el mismo
        nombre.

     ■ Error EG_ARG: DBCREATE() genera un error EG_ARG si el nombre
        del fichero es NIL.

 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 definiciones 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 bidimensional y después utiliza
        el direccionamiento de subíndices para especificar las definiciones
        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.
 To download this example - click here.

See Also: AFIELDS()* COPY STRU EXTE CREATE FROM DBSTRUCT()