| gvSIG desktop 1

<?xml version="1.0" encoding="UTF-8"?>

<classpath>

	<classpathentry kind="src" path="src"/>

	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>

	<classpathentry kind="src" path="/DriverManager"/>

	<classpathentry kind="lib" path="lib/mysql-connector-java-3.0.15-ga-bin.jar"/>

	<classpathentry kind="output" path="bin"/>

</classpath>

bin

java.hprof.txt

vias.dbf

metrics

<?xml version="1.0" encoding="UTF-8"?>

<jardesc>

    <jar path="C:/eclipse3.0.1/workspace/GDBMS/drivers/csv/driver.jar"/>

    <options overwrite="false" compress="true" exportErrors="true" exportWarnings="true" saveDescription="true" descriptionLocation="/GDBMS/csv driver.jardesc" useSourceFolders="false" buildIfNeeded="true"/>

    <manifest manifestVersion="1.0" usesManifest="true" reuseManifest="false" saveManifest="false" generateManifest="true" manifestLocation="/jws/al servidor">

        <sealing sealJar="false">

            <packagesToSeal/>

            <packagesToUnSeal/>

        </sealing>

    </manifest>

    <selectedElements exportClassFiles="true" exportOutputFolder="false" exportJavaFiles="false">

        <javaElement handleIdentifier="=GDBMS/src&lt;com.hardcode.gdbms.driver.csv"/>

    </selectedElements>

</jardesc>

<?xml version="1.0" encoding="UTF-8"?>

<jardesc>

    <jar path="C:/eclipse3.0.1/workspace/GDBMS/drivers/dbf/driver.jar"/>

    <options overwrite="false" compress="true" exportErrors="true" exportWarnings="true" saveDescription="true" descriptionLocation="/GDBMS/dbf driver.jardesc" useSourceFolders="false" buildIfNeeded="true"/>

    <manifest manifestVersion="1.0" usesManifest="true" reuseManifest="false" saveManifest="false" generateManifest="true" manifestLocation="/jws/al servidor">

        <sealing sealJar="false">

            <packagesToSeal/>

            <packagesToUnSeal/>

        </sealing>

    </manifest>

    <selectedElements exportClassFiles="true" exportOutputFolder="false" exportJavaFiles="false">

        <javaElement handleIdentifier="=GDBMS/src&lt;com.hardcode.gdbms.driver.dbf"/>

    </selectedElements>

</jardesc>

<?xml version="1.0" encoding="UTF-8"?>

<projectDescription>

	<name>GDBMS estable</name>

	<comment></comment>

	<projects>

		<project>DriverManager</project>

		<project>Utilities</project>

	</projects>

	<buildSpec>

		<buildCommand>

			<name>org.eclipse.jdt.core.javabuilder</name>

			<arguments>

			</arguments>

		</buildCommand>

	</buildSpec>

	<natures>

		<nature>org.eclipse.jem.workbench.JavaEMFNature</nature>

		<nature>org.eclipse.jdt.core.javanature</nature>

		<nature>org.eclipse.jem.beaninfo.BeanInfoNature</nature>

	</natures>

</projectDescription>

<project name="all" default="compile-javacc" basedir=".">

  <target name="init">

    <tstamp/>

    <property environment="env"/>

    <property name="src" value="src"/>

    <property name="build" value="bin"/>

    <property name="doc" value="/home/andrew/doc/html/javadoc" />

    <property name="javacchome" value="C:/software/javacc-3.2"/>

	<!--    <property name="build.compiler" value="jikes" />

    <property name="junitclasspath" value="/home/andrew/junit3.8.1/junit.jar"/>

    <property name="classpath" value="${junitclasspath}:${build}"/>-->

    <!-- <echo message="classpath: ${classpath}"/> -->

  </target>

  <target name="clean" depends="init">

    <delete>

      <fileset dir="${build}"/>

    </delete>

  </target>

  <target name="compile-javacc" depends="init">

    <delete failonerror="true">

      <fileset dir="${src}/com/hardcode/gdbms/parser">

        <include name="*.java"/>

      </fileset>

    </delete>

<!--    <jjtree target="${src}/com/hardcode/gdbms/parser/sql.jj"

            static="no"

            nodescopehook="true"

            javacchome="${javacchome}"/>-->

    <javacc target="${src}/com/hardcode/gdbms/parser/sql.jj"

            static="no"

            javacchome="${javacchome}"/>

  </target>

<!--  

  <target name="doc-public" depends="init">

    <delete>

      <fileset dir="${doc}/public"/>

    </delete>

    <javadoc packagenames="org.acooke.*"

             sourcepath="${src}"

             destdir="${doc}/public"

             public="true">

      <doctitle><![CDATA[<h1>org.acooke - public</h1>]]></doctitle>

    </javadoc>

  </target>

  <target name="doc-package" depends="init">

    <delete>

      <fileset dir="${doc}/package"/>

    </delete>

    <javadoc packagenames="org.acooke.*"

             sourcepath="${src}"

             destdir="${doc}/package"

             package="true">

      <doctitle><![CDATA[<h1>org.acooke - package</h1>]]></doctitle>

    </javadoc>

  </target>

  <target name="doc-private" depends="init">

    <delete>

      <fileset dir="${doc}/private"/>

    </delete>

    <javadoc packagenames="org.acooke.*"

             sourcepath="${src}"

             destdir="${doc}/private"

             private="true">

      <doctitle><![CDATA[<h1>org.acooke - private</h1>]]></doctitle>

    </javadoc>

  </target>

  <target name="doc" depends="init">

    <parallel>

      <antcall target="doc-private"/>

      <antcall target="doc-package"/>

      <antcall target="doc-public"/>

    </parallel>

  </target>

-->

</project>

/*

 * Created on 17-oct-2004

 */

package com.hardcode.gdbms.driver.mysql;

import java.sql.Connection;

import java.sql.DriverManager;

import java.sql.Statement;

/**

 * DOCUMENT ME!

 *

 * @author Fernando Gonz?lez Cort?s

 */

public class Auz {

    /**

     * DOCUMENT ME!

     *

     * @param args DOCUMENT ME!

     */

    public static void main(String[] args) {

        try {

            Class.forName("com.mysql.jdbc.Driver").newInstance();

            Connection conn = DriverManager.getConnection(

                    "jdbc:mysql://localhost/prueba?user=root");

            Statement s = conn.createStatement();

            for (int i = 1000000; i <= 1000000; i++){

                s.execute("INSERT INTO prueba values('cadena "+i+"')");

            }

            s.close();

            conn.close();

        } catch (Exception ex) {

            ex.printStackTrace();

        }

    }

}

/*

 * Created on 16-oct-2004

 */

package com.hardcode.gdbms.driver.mysql;

import com.hardcode.driverManager.Driver;

import com.hardcode.gdbms.engine.data.DBDriver;

import com.hardcode.gdbms.engine.data.DriverException;

import com.hardcode.gdbms.engine.values.Value;

import com.hardcode.gdbms.engine.values.ValueFactory;

import java.sql.Connection;

import java.sql.DriverManager;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.sql.Statement;

import java.sql.Types;

/**

 * DOCUMENT ME!

 *

 * @author Fernando Gonz?lez Cort?s

 */

public class MySQLDriver implements DBDriver, Driver {

    private static Exception driverException;

    static {

        try {

            Class.forName("com.mysql.jdbc.Driver").newInstance();

        } catch (Exception ex) {

            driverException = ex;

        }

    }

    private Connection conn;

    private Statement st;

    private ResultSet res;

    private long tableLength;

    /**

     * DOCUMENT ME!

     *

     * @param host DOCUMENT ME!

     * @param port DOCUMENT ME!

     * @param dbName DOCUMENT ME!

     * @param user DOCUMENT ME!

     * @param password DOCUMENT ME!

     *

     * @throws SQLException

     * @throws RuntimeException DOCUMENT ME!

     *

     * @see com.hardcode.gdbms.engine.data.DBDriver#connect(java.lang.String)

     */

    public void connect(String host, int port, String dbName, String user,

        String password) throws SQLException {

        if (driverException != null) {

            throw new RuntimeException(driverException);

        }

        String connectionString = "jdbc:mysql://" + host;

        if (port != -1){

        	connectionString += ":" + port;

        }

        connectionString += "/" + dbName;

        if (user != null){

        	connectionString += "?user=" + user + "&password=" + password;

        }

        conn = DriverManager.getConnection(connectionString);

    }

    /**

     * DOCUMENT ME!

     *

     * @throws SQLException

     *

     * @see com.hardcode.gdbms.engine.data.DBDriver#closeConnection()

     */

    public void closeConnection() throws SQLException {

        conn.close();

    }

    /**

     * @see com.hardcode.gdbms.engine.data.ReadDriver#getFieldValue(long, int)

     */

    public Value getFieldValue(long rowIndex, int fieldId)

        throws DriverException {

        try {

            fieldId++;

            res.absolute((int) rowIndex + 1);

            int type = res.getMetaData().getColumnType(fieldId);

            switch (type) {

                case Types.BIGINT:

                    return ValueFactory.createValue(res.getLong(fieldId));

                case Types.BIT:

                    return ValueFactory.createValue(res.getBoolean(fieldId));

                case Types.CHAR:

                    return ValueFactory.createValue(res.getString(fieldId));

                case Types.DATE:

                    return ValueFactory.createValue(res.getDate(fieldId));

                case Types.FLOAT:

                case Types.DOUBLE:

                    return ValueFactory.createValue(res.getDouble(fieldId));

                case Types.INTEGER:

                    return ValueFactory.createValue(res.getInt(fieldId));

                case Types.REAL:

                    return ValueFactory.createValue(res.getFloat(fieldId));

                case Types.VARCHAR:

                    return ValueFactory.createValue(res.getString(fieldId));

                case Types.VARBINARY:

                case Types.TINYINT:

                case Types.TIMESTAMP:

                case Types.TIME:

                case Types.SMALLINT:

                case Types.OTHER:

                case Types.NUMERIC:

                case Types.LONGVARCHAR:

                case Types.LONGVARBINARY:

                case Types.DECIMAL:

                case Types.BINARY:default:

                    throw new DriverException("Type not recognized: " + type);

            }

        } catch (SQLException e) {

            throw new DriverException(e);

        }

    }

    /**

     * @see com.hardcode.gdbms.engine.data.ReadDriver#getFieldCount()

     */

    public int getFieldCount() throws DriverException {

        try {

            return res.getMetaData().getColumnCount();

        } catch (SQLException e) {

            throw new DriverException(e);

        }

    }

    /**

     * @see com.hardcode.gdbms.engine.data.ReadDriver#getFieldName(int)

     */

    public String getFieldName(int fieldId) throws DriverException {

        try {

        	fieldId++;

            return res.getMetaData().getColumnName(fieldId);

        } catch (SQLException e) {

            throw new DriverException(e);

        }

    }

    /**

     * @see com.hardcode.gdbms.engine.data.ReadDriver#getRowCount()

     */

    public long getRowCount() throws DriverException {

        return tableLength;

    }

    /**

     * @see com.hardcode.driverManager.Driver#getName()

     */

    public String getName() {

        return "mysql";

    }

    /**

     * @see com.hardcode.gdbms.engine.data.DBDriver#openTable(java.lang.String)

     */

    public void openTable(String table) throws SQLException {

        st = conn.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,

                ResultSet.CONCUR_READ_ONLY);

        res = st.executeQuery("select * from " + table);

        res.last();

        tableLength = res.getRow();

        res.beforeFirst();

    }

    /**

     * @see com.hardcode.gdbms.engine.data.DBDriver#closeTable()

     */

    public void closeTable() throws SQLException {

        res.close();

        st.close();

    }

    /**

     * @see com.hardcode.gdbms.engine.data.Delegable#executeSQL(java.lang.String)

     */

    public void executeSQL(String sql) throws SQLException {

        st = conn.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,

                ResultSet.CONCUR_READ_ONLY);

        res = st.executeQuery(sql);

        res.last();

        tableLength = res.getRow();

        res.beforeFirst();

    }

}

package com.hardcode.gdbms.driver.csv;

import java.io.BufferedReader;

import java.io.File;

import java.io.FileReader;

import java.io.IOException;

import java.util.ArrayList;

import com.hardcode.driverManager.Driver;

import com.hardcode.gdbms.engine.data.DriverException;

import com.hardcode.gdbms.engine.data.FileDriver;

import com.hardcode.gdbms.engine.values.IntValue;

import com.hardcode.gdbms.engine.values.StringValue;

import com.hardcode.gdbms.engine.values.Value;

/**

 * Driver para ficheros csv, en el que la primera fila se toma como la que

 * define los nombres de los campos

 *

 * @author Fernando Gonz?lez Cort?s

 */

public class CSVDriver implements Driver, FileDriver {

    private BufferedReader reader;

    private ArrayList lineas;

    /**

     * @see com.hardcode.gdbms.driver.Driver#getName()

     */

    public String getName() {

        return "csv";

    }

    /**

     * @see com.hardcode.gdbms.data.DataSource#getFieldName(int)

     */

    public String getFieldName(int fieldId) throws DriverException {

        String[] campos = (String[]) lineas.get(0);

        return campos[fieldId];

    }

    /**

     * @see com.hardcode.gdbms.data.DataSource#getIntFieldValue(int, int)

     */

    public Value getFieldValue(long rowIndex, int fieldId)

        throws DriverException {

        String[] campos = (String[]) lineas.get((int) (rowIndex + 1));

        if (fieldId == 0) {

            IntValue value = new IntValue();

            value.setValue(Integer.parseInt(campos[fieldId]));

            return value;

        }

        StringValue value = new StringValue();

        value.setValue(campos[fieldId]);

        return value;

    }

    /**

     * @see com.hardcode.gdbms.data.DataSource#getFieldCount()

     */

    public int getFieldCount() throws DriverException {

        String[] campos = (String[]) lineas.get(0);

        return campos.length;

    }

    /**

     * @see com.hardcode.gdbms.data.DataSource#open(java.io.File)

     */

    public void open(File file) throws IOException {

        reader = new BufferedReader(new FileReader(file));

        lineas = new ArrayList();

        String aux;

        while ((aux = reader.readLine()) != null) {

            String[] campos = aux.split(";");

            lineas.add(campos);

        }

    }

    /**

     * @see com.hardcode.gdbms.data.DataSource#close()

     */

    public void close() throws IOException {

        reader.close();

    }

    /**

     * @see com.hardcode.gdbms.data.DataSource#getRowCount()

     */

    public long getRowCount() {

        return lineas.size() - 1;

    }

	/**

	 * @see com.hardcode.gdbms.engine.data.FileDriver#fileAccepted(java.io.File)

	 */

	public boolean fileAccepted(File f) {

		return f.getAbsolutePath().toUpperCase().endsWith("CSV");

	}

}

package com.hardcode.gdbms.driver.dbf;

import java.io.File;

import java.io.IOException;

import java.util.Calendar;

import com.hardcode.driverManager.Driver;

import com.hardcode.gdbms.engine.data.DriverException;

import com.hardcode.gdbms.engine.data.FileDriver;

import com.hardcode.gdbms.engine.values.BooleanValue;

import com.hardcode.gdbms.engine.values.DoubleValue;

import com.hardcode.gdbms.engine.values.StringValue;

import com.hardcode.gdbms.engine.values.Value;

import com.hardcode.gdbms.engine.values.ValueFactory;

/**

 * DOCUMENT ME!

 *

 * @author Fernando Gonz?lez Cort?s

 */

public class DBFDriver implements Driver, FileDriver {

    private DbaseFile dbf = new DbaseFile();

    private char[] fieldTypes;

    /**

     * @see com.hardcode.driverManager.Driver#getName()

     */

    public String getName() {

        return "gdbms dbf driver";

    }

    /**

     * @see com.hardcode.gdbms.engine.data.GDBMSDriver#open(java.io.File)

     */

    public void open(File file) throws IOException {

        dbf.open(file);

        try {

            fieldTypes = new char[getFieldCount()];

            for (int i = 0; i < fieldTypes.length; i++) {

                fieldTypes[i] = dbf.getFieldType(i);

            }

        } catch (DriverException e) {

            throw new IOException(e.getMessage());

        }

        /*            memory = new Value[getRowCount()][getFieldCount()];

                    for (int i = 0; i < getRowCount(); i++){

                            for (int j = 0; j < getFieldCount(); j++){

                                    try {

                                                memory[i][j] = getFieldValueOff(i,j);

                                        } catch (IOException e) {

                                                e.printStackTrace();

                                        } catch (SemanticException e) {

                                                e.printStackTrace();

                                        }

                            }

                    }

            */

    }

    /**

     * @see com.hardcode.gdbms.engine.data.GDBMSDriver#close()

     */

    public void close() throws IOException {

        dbf.close();

    }

    /**

     * @see com.hardcode.gdbms.engine.data.ReadAccess#getFieldValue(long, int)

     */

    public Value getFieldValue(long rowIndex, int fieldId)

        throws DriverException {

        // Field Type (C  or M)

        char fieldType = fieldTypes[fieldId];

        if (fieldType == 'L') {

            return new BooleanValue(dbf.getBooleanFieldValue((int) rowIndex,

                    fieldId));

            /*                }else if (fieldType == 'N'){

                                    String strValue = dbf.getStringFieldValue(rowIndex, fieldId);

                                    long value = Long.parseLong(strValue);

                                    if ((value > Integer.MIN_VALUE) && (value < Integer.MAX_VALUE)){

                                            return new IntValue((int) value);

                                    }else{

                                            return new LongValue(value);

                                    }

            */

        } else if ((fieldType == 'F') || (fieldType == 'N')) {

            String strValue = dbf.getStringFieldValue((int) rowIndex, fieldId)

                                 .trim();

            //if (strValue.length() == 0) return null;

            double value = Double.parseDouble(strValue);

            return new DoubleValue(value);

        } else if (fieldType == 'C') {

            return new StringValue(dbf.getStringFieldValue((int) rowIndex,

                    fieldId).trim());

        } else if (fieldType == 'D') {

            String date = dbf.getStringFieldValue((int) rowIndex, fieldId).trim();

            //if (date.length() == 0) return null;

            String year = date.substring(0, 4);

            String month = date.substring(4, 2);

            String day = date.substring(6, 2);

            Calendar c = Calendar.getInstance();

            c.set(Calendar.YEAR, Integer.parseInt(year));

            c.set(Calendar.MONTH, Integer.parseInt(month));

            c.set(Calendar.DAY_OF_MONTH, Integer.parseInt(day));

            return ValueFactory.createValue(c.getTime());

        } else {

            throw new DriverException("Unknown field type");

        }

    }

    /**

     * @see com.hardcode.gdbms.engine.data.ReadAccess#getFieldCount()

     */

    public int getFieldCount() throws DriverException {

        return dbf.getFieldCount();

    }

    /**

     * @see com.hardcode.gdbms.engine.data.ReadAccess#getFieldName(int)

     */

    public String getFieldName(int fieldId) throws DriverException {

        return dbf.getFieldName(fieldId);

    }

    /**

     * @see com.hardcode.gdbms.engine.data.ReadAccess#getRowCount()

     */

    public long getRowCount() throws DriverException {

        return dbf.getRecordCount();

    }

	/**

	 * @see com.hardcode.gdbms.engine.data.FileDriver#fileAccepted(java.io.File)

	 */

	public boolean fileAccepted(File f) {

		return f.getAbsolutePath().toUpperCase().endsWith("DBF");

	}

    /*

     * @see com.hardcode.gdbms.engine.data.ReadAccess#getFieldValue(int, int)

     *

    public Value getFieldValue(int rowIndex, int fieldId) throws IOException, SemanticException {

            return memory[rowIndex][fieldId];

    }*/

}

/*

 * Created on 16-feb-2004

 *

 * To change the template for this generated file go to

 * Window>Preferences>Java>Code Generation>Code and Comments

 */

package com.hardcode.gdbms.driver.dbf;

import java.io.IOException;

import java.nio.ByteBuffer;

import java.nio.ByteOrder;

import java.util.Calendar;

import java.util.Date;

/**

 * Class to represent the header of a Dbase III file. Creation date: (5/15/2001

 * 5:15:30 PM)

 */

public class DbaseFileHeader {

    // Constant for the size of a record

    private int FILE_DESCRIPTOR_SIZE = 32;

    // type of the file, must be 03h

    private int myFileType = 0x03;

    // Date the file was last updated.

    private Date myUpdateDate = new Date();

    // Number of records in the datafile

    private int myNumRecords = 0;

    // Length of the header structure

    private int myHeaderLength;

    // Length of the records

    private int myRecordLength;

    // Number of fields in the record.

    private int myNumFields;

    // collection of header records.

    private DbaseFieldDescriptor[] myFieldDescriptions;

//TODO descomentar esto cuando tenga la clase WarningSupport

//    private WarningSupport warnings = new WarningSupport();

    /**

     * DbaseFileHreader constructor comment.

     */

    public DbaseFileHeader() {

        super();

    }

    /**

     * Add a column to this DbaseFileHeader. The type is one of (C N L or D)

     * character, number, logical(true/false), or date. The Field length is

     * the total length in bytes reserved for this column. The decimal count

     * only applies to numbers(N), and floating point values (F), and refers

     * to the number of characters to reserve after the decimal point.

     *

     * @param inFieldName DOCUMENT ME!

     * @param inFieldType DOCUMENT ME!

     * @param inFieldLength DOCUMENT ME!

     * @param inDecimalCount DOCUMENT ME!

     *

     * @throws Exception DOCUMENT ME!

     */

    public void addColumn(String inFieldName, char inFieldType,

        int inFieldLength, int inDecimalCount) throws Exception {

        if (inFieldLength <= 0) {

            inFieldLength = 1;

        }

        if (myFieldDescriptions == null) {

            myFieldDescriptions = new DbaseFieldDescriptor[0];

        }

        int tempLength = 1; // the length is used for the offset, and there is a * for deleted as the first byte

        DbaseFieldDescriptor[] tempFieldDescriptors = new DbaseFieldDescriptor[myFieldDescriptions.length +

            1];

        for (int i = 0; i < myFieldDescriptions.length; i++) {

            myFieldDescriptions[i].myFieldDataAddress = tempLength;

            tempLength = tempLength + myFieldDescriptions[i].myFieldLength;

            tempFieldDescriptors[i] = myFieldDescriptions[i];

        }

        tempFieldDescriptors[myFieldDescriptions.length] = new DbaseFieldDescriptor();

        tempFieldDescriptors[myFieldDescriptions.length].myFieldLength = inFieldLength;

        tempFieldDescriptors[myFieldDescriptions.length].myDecimalCount = inDecimalCount;

        tempFieldDescriptors[myFieldDescriptions.length].myFieldDataAddress = tempLength;

        // set the field name

        String tempFieldName = inFieldName;

        if (tempFieldName == null) {

            tempFieldName = "NoName";

        }

        if (tempFieldName.length() > 11) {

            tempFieldName = tempFieldName.substring(0, 11);

            warn("FieldName " + inFieldName +

                " is longer than 11 characters, truncating to " +

                tempFieldName);

        }

        tempFieldDescriptors[myFieldDescriptions.length].myFieldName = tempFieldName;

        // the field type

        if ((inFieldType == 'C') || (inFieldType == 'c')) {

            tempFieldDescriptors[myFieldDescriptions.length].myFieldType = 'C';

            if (inFieldLength > 254) {

                warn("Field Length for " + inFieldName + " set to " +

                    inFieldLength +

                    " Which is longer than 254, not consistent with dbase III");

            }

        } else if ((inFieldType == 'S') || (inFieldType == 's')) {

            tempFieldDescriptors[myFieldDescriptions.length].myFieldType = 'C';

            warn("Field type for " + inFieldName +

                " set to S which is flat out wrong people!, I am setting this to C, in the hopes you meant character.");

            if (inFieldLength > 254) {

                warn("Field Length for " + inFieldName + " set to " +

                    inFieldLength +

                    " Which is longer than 254, not consistent with dbase III");

            }

            tempFieldDescriptors[myFieldDescriptions.length].myFieldLength = 8;

        } else if ((inFieldType == 'D') || (inFieldType == 'd')) {

            tempFieldDescriptors[myFieldDescriptions.length].myFieldType = 'D';

            if (inFieldLength != 8) {

                warn("Field Length for " + inFieldName + " set to " +

                    inFieldLength + " Setting to 8 digets YYYYMMDD");

            }

            tempFieldDescriptors[myFieldDescriptions.length].myFieldLength = 8;

        } else if ((inFieldType == 'F') || (inFieldType == 'f')) {

            tempFieldDescriptors[myFieldDescriptions.length].myFieldType = 'F';

            if (inFieldLength > 20) {

                warn("Field Length for " + inFieldName + " set to " +

                    inFieldLength +

                    " Preserving length, but should be set to Max of 20 not valid for dbase IV, and UP specification, not present in dbaseIII.");

            }

        } else if ((inFieldType == 'N') || (inFieldType == 'n')) {

            tempFieldDescriptors[myFieldDescriptions.length].myFieldType = 'N';

            if (inFieldLength > 18) {

                warn("Field Length for " + inFieldName + " set to " +

                    inFieldLength +

                    " Preserving length, but should be set to Max of 18 for dbase III specification.");

            }

            if (inDecimalCount < 0) {

                warn("Field Decimal Position for " + inFieldName + " set to " +

                    inDecimalCount +

                    " Setting to 0 no decimal data will be saved.");

                tempFieldDescriptors[myFieldDescriptions.length].myDecimalCount = 0;

            }

            if (inDecimalCount > (inFieldLength - 1)) {

                warn("Field Decimal Position for " + inFieldName + " set to " +

                    inDecimalCount + " Setting to " + (inFieldLength - 1) +

                    " no non decimal data will be saved.");

                tempFieldDescriptors[myFieldDescriptions.length].myDecimalCount = inFieldLength -

                    1;

            }

        } else if ((inFieldType == 'L') || (inFieldType == 'l')) {

            tempFieldDescriptors[myFieldDescriptions.length].myFieldType = 'L';

            if (inFieldLength != 1) {

                warn("Field Length for " + inFieldName + " set to " +

                    inFieldLength +

                    " Setting to length of 1 for logical fields.");

            }

            tempFieldDescriptors[myFieldDescriptions.length].myFieldLength = 1;

        } else {

            throw new Exception("Undefined field type " + inFieldType +

                " For column " + inFieldName);

        }

        // the length of a record

        tempLength = tempLength +

            tempFieldDescriptors[myFieldDescriptions.length].myFieldLength;

        // set the new fields.

        myFieldDescriptions = tempFieldDescriptors;

        myHeaderLength = 33 + (32 * myFieldDescriptions.length);

        myNumFields = myFieldDescriptions.length;

        myRecordLength = tempLength;

    }

    /**

     * Remove a column from this DbaseFileHeader.

     *

     * @param inFieldName DOCUMENT ME!

     *

     * @return index of the removed column, -1 if no found

     */

    public int removeColumn(String inFieldName) {

        int retCol = -1;

        int tempLength = 1;

        DbaseFieldDescriptor[] tempFieldDescriptors = new DbaseFieldDescriptor[myFieldDescriptions.length -

            1];

        for (int i = 0, j = 0; i < myFieldDescriptions.length; i++) {

            if (!inFieldName.equalsIgnoreCase(

                        myFieldDescriptions[i].myFieldName.trim())) {

                // if this is the last field and we still haven't found the

                // named field

                if ((i == j) && (i == (myFieldDescriptions.length - 1))) {

                    System.err.println("Could not find a field named '" +

                        inFieldName + "' for removal");

                    return retCol;

                }

                tempFieldDescriptors[j] = myFieldDescriptions[i];

                tempFieldDescriptors[j].myFieldDataAddress = tempLength;

                tempLength += tempFieldDescriptors[j].myFieldLength;

                // only increment j on non-matching fields

                j++;

            } else {

                retCol = i;

            }

        }

        // set the new fields.

        myFieldDescriptions = tempFieldDescriptors;

        myHeaderLength = 33 + (32 * myFieldDescriptions.length);

        myNumFields = myFieldDescriptions.length;

        myRecordLength = tempLength;

        return retCol;

    }

    /**

     * DOCUMENT ME!

     *

     * @param inWarn DOCUMENT ME!

     */

    private void warn(String inWarn) {

//TODO Descomentar esto cuando tenga la clase warning support

//    	warnings.warn(inWarn);

    }

    /**

     * Return the Field Descriptor for the given field.

     *

     * @param inIndex DOCUMENT ME!

     *

     * @return DOCUMENT ME!

     */

    public DbaseFieldDescriptor getFieldDescription(int inIndex) {

        return myFieldDescriptions[inIndex];

    }

    // Retrieve the length of the field at the given index

    public int getFieldLength(int inIndex) {

        return myFieldDescriptions[inIndex].myFieldLength;

    }

    // Retrieve the location of the decimal point within the field.

    public int getFieldDecimalCount(int inIndex) {

        return myFieldDescriptions[inIndex].myDecimalCount;

    }

    // Retrieve the Name of the field at the given index

    public String getFieldName(int inIndex) {

        return myFieldDescriptions[inIndex].myFieldName;

    }

    // Retrieve the type of field at the given index

    public char getFieldType(int inIndex) {

        return myFieldDescriptions[inIndex].myFieldType;

    }

    /**

     * Return the date this file was last updated.

     *

     * @return DOCUMENT ME!

     */

    public Date getLastUpdateDate() {

        return myUpdateDate;

    }

    /**

     * Return the number of fields in the records.

     *

     * @return DOCUMENT ME!

     */

    public int getNumFields() {

        return myNumFields;

    }

    /**

     * Return the number of records in the file

     *

     * @return DOCUMENT ME!

     */

    public int getNumRecords() {

        return myNumRecords;

    }

    /**

     * Return the length of the records in bytes.

     *

     * @return DOCUMENT ME!

     */

    public int getRecordLength() {

        return myRecordLength;

    }

    /**

     * Return the length of the header

     *

     * @return DOCUMENT ME!

     */

    public int getHeaderLength() {

        return myHeaderLength;

    }

    /**

     * Read the header data from the DBF file.

     *

     * @param in DOCUMENT ME!

     *

     * @throws Exception DOCUMENT ME!

     */

    public void readHeader(ByteBuffer in) throws IOException {

        // type of file.

        myFileType = in.get();

        if (myFileType != 0x03) {

            throw new IOException("Unsupported DBF file Type " +

                Integer.toHexString(myFileType));

        }

        // parse the update date information.

        int tempUpdateYear = (int) in.get();

        int tempUpdateMonth = (int) in.get();

        int tempUpdateDay = (int) in.get();

        tempUpdateYear = tempUpdateYear + 1900;

        Calendar c = Calendar.getInstance();

        c.set(Calendar.YEAR, tempUpdateYear);

        c.set(Calendar.MONTH, tempUpdateMonth - 1);

        c.set(Calendar.DATE, tempUpdateDay);

        myUpdateDate = c.getTime();

        // read the number of records.

        in.order(ByteOrder.LITTLE_ENDIAN);

        myNumRecords = in.getInt();

        // read the length of the header structure.

        myHeaderLength = in.getShort();

        // read the length of a record

        myRecordLength = in.getShort();

		in.order(ByteOrder.BIG_ENDIAN);

        // skip the reserved bytes in the header.

        in.position(in.position()+20);

        // calculate the number of Fields in the header

        myNumFields = (myHeaderLength - FILE_DESCRIPTOR_SIZE - 1) / FILE_DESCRIPTOR_SIZE;

        // read all of the header records

        myFieldDescriptions = new DbaseFieldDescriptor[myNumFields];

        for (int i = 0; i < myNumFields; i++) {

            myFieldDescriptions[i] = new DbaseFieldDescriptor();

            // read the field name

            byte[] buffer = new byte[11];

            in.get(buffer);

            myFieldDescriptions[i].myFieldName = new String(buffer);

            // read the field type

            myFieldDescriptions[i].myFieldType = (char) in.get();

            // read the field data address, offset from the start of the record.

            myFieldDescriptions[i].myFieldDataAddress = in.getInt();

            // read the field length in bytes

            int tempLength = (int) in.get();

            if (tempLength < 0) {

                tempLength = tempLength + 256;

            }

            myFieldDescriptions[i].myFieldLength = tempLength;

            // read the field decimal count in bytes

            myFieldDescriptions[i].myDecimalCount = (int) in.get();

            // read the reserved bytes.

			in.position(in.position()+14);

        }

        // Last byte is a marker for the end of the field definitions.

        in.get();

    }

    /**

     * Set the number of records in the file

     *

     * @param inNumRecords DOCUMENT ME!

     */

    protected void setNumRecords(int inNumRecords) {

        myNumRecords = inNumRecords;

    }

    /*

     * Write the header data to the DBF file.

     *

     * @param out DOCUMENT ME!

     *

     * @throws Exception DOCUMENT ME!

     *

    public void writeHeader(LEDataOutputStream out) throws Exception {

        // write the output file type.

        out.writeByte(myFileType);

        // write the date stuff

        Calendar c = Calendar.getInstance();

        c.setTime(new Date());

        out.writeByte(c.get(Calendar.YEAR) - 1900);

        out.writeByte(c.get(Calendar.MONTH) + 1);

        out.writeByte(c.get(Calendar.DAY_OF_MONTH));

        // write the number of records in the datafile.

        out.writeInt(myNumRecords);

        // write the length of the header structure.

        out.writeShort(myHeaderLength);

        // write the length of a record

        out.writeShort(myRecordLength);

        // write the reserved bytes in the header

        for (int i = 0; i < 20; i++)

            out.writeByte(0);

        // write all of the header records

        int tempOffset = 0;

        for (int i = 0; i < myFieldDescriptions.length; i++) {

            // write the field name

            for (int j = 0; j < 11; j++) {

                if (myFieldDescriptions[i].myFieldName.length() > j) {

                    out.writeByte((int) myFieldDescriptions[i].myFieldName.charAt(

                            j));

                } else {

                    out.writeByte(0);

                }

            }

            // write the field type

            out.writeByte(myFieldDescriptions[i].myFieldType);

            // write the field data address, offset from the start of the record.

            out.writeInt(tempOffset);

            tempOffset += myFieldDescriptions[i].myFieldLength;

            // write the length of the field.

            out.writeByte(myFieldDescriptions[i].myFieldLength);

            // write the decimal count.

            out.writeByte(myFieldDescriptions[i].myDecimalCount);

            // write the reserved bytes.

            for (int j = 0; j < 14; j++)

                out.writeByte(0);

        }

        // write the end of the field definitions marker

        out.writeByte(0x0D);

    }

*/

    /**

     * Class for holding the information assicated with a record.

     */

    class DbaseFieldDescriptor {

        // Field Name

        String myFieldName;

        // Field Type (C N L D F or M)

        char myFieldType;

        // Field Data Address offset from the start of the record.

        int myFieldDataAddress;

        // Length of the data in bytes

        int myFieldLength;

        // Field decimal count in Binary, indicating where the decimal is

        int myDecimalCount;

    }

}

/*

 * Created on 16-feb-2004

 *

 * To change the template for this generated file go to

 * Window>Preferences>Java>Code Generation>Code and Comments

 */

package com.hardcode.gdbms.driver.dbf;

/**

 */

import java.io.File;

import java.io.FileInputStream;

import java.io.IOException;