update for EOFM-116, EOFM-117

?? ?

2008-06-12 f74be0cace55a2d65fa65329b521b50e0cef2c31

update for EOFM-116, EOFM-117

 .gitattributes

@@ -51,6 +51,7 @@
xdgnjobs/ximple-spatialjob/src/main/java/com/ximple/eofms/filter/AbstractFLinkageDispatchableFilter.java svneol=native#text/plain
xdgnjobs/ximple-spatialjob/src/main/java/com/ximple/eofms/filter/CreateArcLineStringStrategy.java svneol=native#text/plain
xdgnjobs/ximple-spatialjob/src/main/java/com/ximple/eofms/filter/CreateEllipseShapeStrategy.java svneol=native#text/plain
xdgnjobs/ximple-spatialjob/src/main/java/com/ximple/eofms/filter/CreateFeatureTypeEventListener.java svneol=native#text/plain
xdgnjobs/ximple-spatialjob/src/main/java/com/ximple/eofms/filter/CreateFeatureTypeStrategy.java svneol=native#text/plain
xdgnjobs/ximple-spatialjob/src/main/java/com/ximple/eofms/filter/CreateLineStringStrategy.java svneol=native#text/plain
xdgnjobs/ximple-spatialjob/src/main/java/com/ximple/eofms/filter/CreateLineTextStrategy.java svneol=native#text/plain
@@ -61,6 +62,7 @@
xdgnjobs/ximple-spatialjob/src/main/java/com/ximple/eofms/filter/ElementDispatcher.java svneol=native#text/plain
xdgnjobs/ximple-spatialjob/src/main/java/com/ximple/eofms/filter/ElementLevelCriterion.java svneol=native#text/plain
xdgnjobs/ximple-spatialjob/src/main/java/com/ximple/eofms/filter/ElementTypeCriterion.java svneol=native#text/plain
xdgnjobs/ximple-spatialjob/src/main/java/com/ximple/eofms/filter/FeatureTypeEvent.java svneol=native#text/plain
xdgnjobs/ximple-spatialjob/src/main/java/com/ximple/eofms/filter/TypeCompIdDispatchableFilter.java svneol=native#text/plain
xdgnjobs/ximple-spatialjob/src/main/java/com/ximple/eofms/filter/TypeCompLevelIdDispatchableFilter.java svneol=native#text/plain
xdgnjobs/ximple-spatialjob/src/main/java/com/ximple/eofms/filter/TypeIdDispatchableFilter.java svneol=native#text/plain

 xdgnjobs/ximple-jobcarrier/src/main/resources/log4j.properties

@@ -25,4 +25,4 @@

# Print messages of level INFO or above for examples
log4j.logger.org.cavaness.quartzbook=INFO
log4j.logger.com.ximple.eofms=INFO
log4j.logger.com.ximple.eofms=DEBUG

 xdgnjobs/ximple-spatialjob/src/main/java/com/ximple/eofms/filter/AbstractDispatchableFilter.java

@@ -2,6 +2,8 @@

import java.util.LinkedList;

import javax.swing.event.EventListenerList;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

@@ -15,6 +17,9 @@
    private LinkedList<ElementLevelCriterion> levelCriterions;

    protected Log logger = LogFactory.getLog(AbstractFLinkageDispatchableFilter.class);

    // Create the listener list
    protected EventListenerList listenerList = new EventListenerList();

    public AbstractDispatchableFilter()
    {
@@ -72,4 +77,25 @@
        return -1;
    }

    public void addCreateFeatureTypeEventListener(CreateFeatureTypeEventListener listener)
    {
        listenerList.add(CreateFeatureTypeEventListener.class, listener);
    }

    public void removeCreateFeatureTypeEventListener(CreateFeatureTypeEventListener listener)
    {
        listenerList.remove(CreateFeatureTypeEventListener.class, listener);
    }

    protected void fireFeatureTypeEvent(FeatureTypeEvent evt)
    {
        Object[] listeners = listenerList.getListenerList();
        for (int i = 0; i < listeners.length; i += 2)
        {
            if (listeners[i] == CreateFeatureTypeEventListener.class)
            {
                ((CreateFeatureTypeEventListener) listeners[i + 1]).createFeatureTypeOccurred(evt);
            }
        }
    }
}

 xdgnjobs/ximple-spatialjob/src/main/java/com/ximple/eofms/filter/CreateFeatureTypeEventListener.java

New file
@@ -0,0 +1,8 @@
package com.ximple.eofms.filter;

import java.util.EventListener;

public interface CreateFeatureTypeEventListener extends EventListener
{
    public void createFeatureTypeOccurred(FeatureTypeEvent evt);
}

 xdgnjobs/ximple-spatialjob/src/main/java/com/ximple/eofms/filter/CreateFeatureTypeStrategy.java

@@ -10,6 +10,8 @@
public interface CreateFeatureTypeStrategy
{
    public FeatureType createFeatureElement(String featureName) throws SchemaException;

    public Feature createFeature(FeatureType featureType, Element element) throws IllegalAttributeException;

    public void addCreateFeatureTypeEventListener(CreateFeatureTypeEventListener listener);
    public void removeCreateFeatureTypeEventListener(CreateFeatureTypeEventListener listener);
}

 xdgnjobs/ximple-spatialjob/src/main/java/com/ximple/eofms/filter/CreateLineStringStrategy.java

@@ -3,6 +3,8 @@
import java.util.List;
import java.util.TreeMap;

import javax.swing.event.EventListenerList;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.geotools.feature.Feature;
@@ -31,6 +33,9 @@
    TreeMap<String, FeatureTypeBuilder> typeBuilders = new TreeMap<String, FeatureTypeBuilder>();
    TWD97GeometryConverterDecorator convertDecorator = new TWD97GeometryConverterDecorator();

    // Create the listener list
    protected EventListenerList listenerList = new EventListenerList();

    public CreateLineStringStrategy()
    {
    }
@@ -57,6 +62,7 @@
        {
            FeatureTypeBuilder typeBuilder = FeatureTypeBuilderUtil.createLineStringFeatureTypeBuilder(featureName);
            typeBuilders.put(featureName, typeBuilder);
            fireFeatureTypeEvent(new FeatureTypeEvent(this, typeBuilder.getFeatureType()));
        }
        return typeBuilders.get(featureName).getFeatureType();
    }
@@ -132,4 +138,27 @@

        return feature;
    }


    public void addCreateFeatureTypeEventListener(CreateFeatureTypeEventListener listener)
    {
        listenerList.add(CreateFeatureTypeEventListener.class, listener);
    }

    public void removeCreateFeatureTypeEventListener(CreateFeatureTypeEventListener listener)
    {
        listenerList.remove(CreateFeatureTypeEventListener.class, listener);
    }

    protected void fireFeatureTypeEvent(FeatureTypeEvent evt)
    {
        Object[] listeners = listenerList.getListenerList();
        for (int i = 0; i < listeners.length; i += 2)
        {
            if (listeners[i] == CreateFeatureTypeEventListener.class)
            {
                ((CreateFeatureTypeEventListener) listeners[i + 1]).createFeatureTypeOccurred(evt);
            }
        }
    }
}

 xdgnjobs/ximple-spatialjob/src/main/java/com/ximple/eofms/filter/CreateLineTextStrategy.java

@@ -3,6 +3,8 @@
import java.util.List;
import java.util.TreeMap;

import javax.swing.event.EventListenerList;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.geotools.feature.Feature;
@@ -34,6 +36,9 @@
    TreeMap<String, FeatureTypeBuilder> typeBuilders = new TreeMap<String, FeatureTypeBuilder>();
    TWD97GeometryConverterDecorator convertDecorator = new TWD97GeometryConverterDecorator();

    // Create the listener list
    protected EventListenerList listenerList = new EventListenerList();

    public CreateLineTextStrategy()
    {
    }
@@ -60,6 +65,7 @@
        {
            FeatureTypeBuilder typeBuilder = FeatureTypeBuilderUtil.createLineStringFeatureTypeBuilder(featureName);
            typeBuilders.put(featureName, typeBuilder);
            fireFeatureTypeEvent(new FeatureTypeEvent(this, typeBuilder.getFeatureType()));
        }
        return typeBuilders.get(featureName).getFeatureType();
    }
@@ -147,5 +153,28 @@

        return feature;
    }


    public void addCreateFeatureTypeEventListener(CreateFeatureTypeEventListener listener)
    {
        listenerList.add(CreateFeatureTypeEventListener.class, listener);
    }

    public void removeCreateFeatureTypeEventListener(CreateFeatureTypeEventListener listener)
    {
        listenerList.remove(CreateFeatureTypeEventListener.class, listener);
    }

    protected void fireFeatureTypeEvent(FeatureTypeEvent evt)
    {
        Object[] listeners = listenerList.getListenerList();
        for (int i = 0; i < listeners.length; i += 2)
        {
            if (listeners[i] == CreateFeatureTypeEventListener.class)
            {
                ((CreateFeatureTypeEventListener) listeners[i + 1]).createFeatureTypeOccurred(evt);
            }
        }
    }
}


 xdgnjobs/ximple-spatialjob/src/main/java/com/ximple/eofms/filter/CreateShapeStrategy.java

@@ -3,6 +3,8 @@
import java.util.List;
import java.util.TreeMap;

import javax.swing.event.EventListenerList;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.geotools.feature.Feature;
@@ -28,6 +30,9 @@
    GeometryFactory geometryFactory = new GeometryFactory();
    TreeMap<String, FeatureTypeBuilder> typeBuilders = new TreeMap<String, FeatureTypeBuilder>();
    TWD97GeometryConverterDecorator convertDecorator = new TWD97GeometryConverterDecorator();

    // Create the listener list
    protected EventListenerList listenerList = new EventListenerList();

    public CreateShapeStrategy()
    {
@@ -55,6 +60,7 @@
        {
            FeatureTypeBuilder typeBuilder = FeatureTypeBuilderUtil.createPolygonFeatureTypeBuilder(featureName);
            typeBuilders.put(featureName, typeBuilder);
            fireFeatureTypeEvent(new FeatureTypeEvent(this, typeBuilder.getFeatureType()));
        }
        return typeBuilders.get(featureName).getFeatureType();
    }
@@ -98,4 +104,27 @@
        }
        return feature;
    }


    public void addCreateFeatureTypeEventListener(CreateFeatureTypeEventListener listener)
    {
        listenerList.add(CreateFeatureTypeEventListener.class, listener);
    }

    public void removeCreateFeatureTypeEventListener(CreateFeatureTypeEventListener listener)
    {
        listenerList.remove(CreateFeatureTypeEventListener.class, listener);
    }

    protected void fireFeatureTypeEvent(FeatureTypeEvent evt)
    {
        Object[] listeners = listenerList.getListenerList();
        for (int i = 0; i < listeners.length; i += 2)
        {
            if (listeners[i] == CreateFeatureTypeEventListener.class)
            {
                ((CreateFeatureTypeEventListener) listeners[i + 1]).createFeatureTypeOccurred(evt);
            }
        }
    }
}

 xdgnjobs/ximple-spatialjob/src/main/java/com/ximple/eofms/filter/CreateSymbolStrategy.java

@@ -5,6 +5,8 @@
import java.util.List;
import java.util.TreeMap;

import javax.swing.event.EventListenerList;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.geotools.feature.Feature;
@@ -29,6 +31,9 @@
    GeometryFactory geometryFactory = new GeometryFactory();
    TreeMap<String, FeatureTypeBuilder> typeBuilders = new TreeMap<String, FeatureTypeBuilder>();
    TWD97GeometryConverterDecorator convertDecorator = new TWD97GeometryConverterDecorator();

    // Create the listener list
    protected EventListenerList listenerList = new EventListenerList();

    public CreateSymbolStrategy()
    {
@@ -56,6 +61,7 @@
        {
            FeatureTypeBuilder typeBuilder = FeatureTypeBuilderUtil.createSymbolFeatureTypeBuilder(featureName);
            typeBuilders.put(featureName, typeBuilder);
            fireFeatureTypeEvent(new FeatureTypeEvent(this, typeBuilder.getFeatureType()));
        }
        return typeBuilders.get(featureName).getFeatureType();
    }
@@ -107,5 +113,28 @@
        }
        return feature;
    }


    public void addCreateFeatureTypeEventListener(CreateFeatureTypeEventListener listener)
    {
        listenerList.add(CreateFeatureTypeEventListener.class, listener);
    }

    public void removeCreateFeatureTypeEventListener(CreateFeatureTypeEventListener listener)
    {
        listenerList.remove(CreateFeatureTypeEventListener.class, listener);
    }

    protected void fireFeatureTypeEvent(FeatureTypeEvent evt)
    {
        Object[] listeners = listenerList.getListenerList();
        for (int i = 0; i < listeners.length; i += 2)
        {
            if (listeners[i] == CreateFeatureTypeEventListener.class)
            {
                ((CreateFeatureTypeEventListener) listeners[i + 1]).createFeatureTypeOccurred(evt);
            }
        }
    }
}


 xdgnjobs/ximple-spatialjob/src/main/java/com/ximple/eofms/filter/CreateTextStrategy.java

@@ -4,6 +4,7 @@
import java.math.RoundingMode;
import java.util.List;
import java.util.TreeMap;
import javax.swing.event.EventListenerList;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
@@ -31,6 +32,9 @@
    TreeMap<String, FeatureTypeBuilder> typeBuilders = new TreeMap<String, FeatureTypeBuilder>();
    TWD97GeometryConverterDecorator convertDecorator = new TWD97GeometryConverterDecorator();

    // Create the listener list
    protected EventListenerList listenerList = new EventListenerList();

    public CreateTextStrategy()
    {
    }
@@ -57,6 +61,7 @@
        {
            FeatureTypeBuilder typeBuilder = FeatureTypeBuilderUtil.createPointFeatureTypeBuilder(featureName);
            typeBuilders.put(featureName, typeBuilder);
            fireFeatureTypeEvent(new FeatureTypeEvent(this, typeBuilder.getFeatureType()));
        }
        return typeBuilders.get(featureName).getFeatureType();
    }
@@ -73,6 +78,8 @@
            double angle = txtElement.getRotationAngle();
            angle = BigDecimal.valueOf(angle).setScale(3, RoundingMode.HALF_UP).doubleValue();
            convertDecorator.setConverter(txtElement);
            String content = txtElement.getText();
            content = content.replace('\u0000', ' ');
            feature = featureType.create(new Object[]{
                    convertDecorator.toGeometry(geometryFactory),
                    fLinkage.getFsc(),
@@ -87,7 +94,7 @@
                    (float) txtElement.getTextHeight(),
                    (float) txtElement.getTextWidth(),
                    (float) angle,
                    txtElement.getText()
                    content
            });
        } else if (element instanceof TextNodeElement)
        {
@@ -98,7 +105,8 @@
            {
                if (sb.length() != 0)
                    sb.append("\n");
                sb.append(text);
                String content = text.replace('\u0000', ' ');
                sb.append(content);
            }

            double angle = nodeElement.getRotationAngle();
@@ -123,4 +131,26 @@
        }
        return feature;
    }

    public void addCreateFeatureTypeEventListener(CreateFeatureTypeEventListener listener)
    {
        listenerList.add(CreateFeatureTypeEventListener.class, listener);
    }

    public void removeCreateFeatureTypeEventListener(CreateFeatureTypeEventListener listener)
    {
        listenerList.remove(CreateFeatureTypeEventListener.class, listener);
    }

    protected void fireFeatureTypeEvent(FeatureTypeEvent evt)
    {
        Object[] listeners = listenerList.getListenerList();
        for (int i = 0; i < listeners.length; i += 2)
        {
            if (listeners[i] == CreateFeatureTypeEventListener.class)
            {
                ((CreateFeatureTypeEventListener) listeners[i + 1]).createFeatureTypeOccurred(evt);
            }
        }
    }
}

 xdgnjobs/ximple-spatialjob/src/main/java/com/ximple/eofms/filter/FeatureTypeEvent.java

New file
@@ -0,0 +1,28 @@
package com.ximple.eofms.filter;

import java.util.EventObject;

import org.geotools.feature.FeatureType;

public class FeatureTypeEvent extends EventObject
{
    private FeatureType featureType;

    /**
     * Constructs a prototypical Event.
     *
     * @param source The object on which the Event initially occurred.
     * @param featureType featureType
     * @throws IllegalArgumentException if source is null.
     */
    public FeatureTypeEvent(Object source, FeatureType featureType)
    {
        super(source);
        this.featureType = featureType;
    }

    public FeatureType getFeatureType()
    {
        return featureType;
    }
}

 xdgnjobs/ximple-spatialjob/src/main/java/com/ximple/eofms/filter/TypeCompIdDispatchableFilter.java

@@ -9,6 +9,7 @@
import com.ximple.io.dgn7.FrammeAttributeData;

public class TypeCompIdDispatchableFilter extends AbstractFLinkageDispatchableFilter
        implements CreateFeatureTypeEventListener
{
    private int tid;
    private int cid;
@@ -27,6 +28,7 @@
        this.tid = tid;
        this.cid = compid;
        this.createStrategy = createStrategy;
        this.createStrategy.addCreateFeatureTypeEventListener(this);
    }

    public int getTid()
@@ -111,4 +113,9 @@
        }
        return sb.toString();
    }

    public void createFeatureTypeOccurred(FeatureTypeEvent evt)
    {
        fireFeatureTypeEvent(evt);
    }
}

 xdgnjobs/ximple-spatialjob/src/main/java/com/ximple/eofms/filter/TypeCompLevelIdDispatchableFilter.java

@@ -9,6 +9,7 @@
import com.ximple.io.dgn7.FrammeAttributeData;

public class TypeCompLevelIdDispatchableFilter extends AbstractFLinkageDispatchableFilter
        implements CreateFeatureTypeEventListener
{
    private int tid;
    private int cid;
@@ -29,6 +30,7 @@
        this.cid = compid;
        this.lid = level;
        this.createStrategy = createStrategy;
        this.createStrategy.addCreateFeatureTypeEventListener(this);
    }

    public int getTid()
@@ -120,4 +122,9 @@
        }
        return sb.toString();
    }

    public void createFeatureTypeOccurred(FeatureTypeEvent evt)
    {
        fireFeatureTypeEvent(evt);
    }
}

 xdgnjobs/ximple-spatialjob/src/main/java/com/ximple/eofms/filter/TypeIdDispatchableFilter.java

@@ -8,7 +8,7 @@
import com.ximple.io.dgn7.Element;
import com.ximple.io.dgn7.FrammeAttributeData;

public class TypeIdDispatchableFilter extends AbstractFLinkageDispatchableFilter
public class TypeIdDispatchableFilter extends AbstractFLinkageDispatchableFilter implements CreateFeatureTypeEventListener
{
    private int tid;
    private CreateFeatureTypeStrategy createStrategy;
@@ -24,6 +24,7 @@
        this.setName(fname);
        this.tid = tid;
        this.createStrategy = createStrategy;
        this.createStrategy.addCreateFeatureTypeEventListener(this);
    }

    public int getTid()
@@ -93,4 +94,9 @@
        }
        return sb.toString();
    }

    public void createFeatureTypeOccurred(FeatureTypeEvent evt)
    {
        fireFeatureTypeEvent(evt);
    }
}

 xdgnjobs/ximple-spatialjob/src/main/java/com/ximple/eofms/jobs/OracleConvertDgn2MySQLJob.java

@@ -622,6 +622,7 @@
                convertContext.setExecutionContext(context);
                String dgnPaths[] = StringUtils.splitToArray(dgnFile.toString(), File.separator);
                convertContext.setFilename(dgnPaths[dgnPaths.length - 1]);
                convertContext.startTransaction();

                FileInputStream fs = new FileInputStream(dgnFile);
                FileChannel fc = fs.getChannel();
@@ -754,6 +755,7 @@
                convertContext.setExecutionContext(context);
                String dgnPaths[] = StringUtils.splitToArray(dgnFile.toString(), File.separator);
                convertContext.setFilename(dgnPaths[dgnPaths.length - 1]);
                convertContext.startTransaction();

                FileInputStream fs = new FileInputStream(dgnFile);
                FileChannel fc = fs.getChannel();
@@ -930,6 +932,7 @@
                convertContext.setExecutionContext(context);
                String dgnPaths[] = StringUtils.splitToArray(dgnFile.toString(), File.separator);
                convertContext.setFilename(dgnPaths[dgnPaths.length - 1]);
                convertContext.startTransaction();

                FileInputStream fs = new FileInputStream(dgnFile);
                FileChannel fc = fs.getChannel();

 xdgnjobs/ximple-spatialjob/src/main/java/com/ximple/eofms/jobs/OracleConvertDgn2OraSDOJob.java

@@ -201,8 +201,7 @@
            throw new JobExecutionException("Cannot connect source postgreSQL database.");
        }

        Calendar cal = Calendar.getInstance();
        Date startTime = cal.getTime();
        long t1 = System.currentTimeMillis();
        try
        {
            logger.info("-- step:clearOutputDatabase --");
@@ -255,11 +254,10 @@
            }

            disconnect();
            Date endTime = cal.getTime();
            Date time = new Date(endTime.getTime() - startTime.getTime());
            long t2 = System.currentTimeMillis();
            // public static final String DATE_FORMAT_NOW = "yyyy-MM-dd HH:mm:ss";
            // SimpleDateFormat sdf = new SimpleDateFormat(DATE_FORMAT_NOW);
            logger.warn("use time = " + time);
            logger.warn("use time = " + ((t2 - t1) / 60000.0) + " min");
        } catch (SQLException e)
        {
            logger.warn(e.getMessage(), e);
@@ -624,6 +622,7 @@
                convertContext.setExecutionContext(context);
                String dgnPaths[] = StringUtils.splitToArray(dgnFile.toString(), File.separator);
                convertContext.setFilename(dgnPaths[dgnPaths.length - 1]);
                convertContext.startTransaction();

                FileInputStream fs = new FileInputStream(dgnFile);
                FileChannel fc = fs.getChannel();
@@ -756,6 +755,7 @@
                convertContext.setExecutionContext(context);
                String dgnPaths[] = StringUtils.splitToArray(dgnFile.toString(), File.separator);
                convertContext.setFilename(dgnPaths[dgnPaths.length - 1]);
                convertContext.startTransaction();

                FileInputStream fs = new FileInputStream(dgnFile);
                FileChannel fc = fs.getChannel();
@@ -932,6 +932,7 @@
                convertContext.setExecutionContext(context);
                String dgnPaths[] = StringUtils.splitToArray(dgnFile.toString(), File.separator);
                convertContext.setFilename(dgnPaths[dgnPaths.length - 1]);
                convertContext.startTransaction();

                FileInputStream fs = new FileInputStream(dgnFile);
                FileChannel fc = fs.getChannel();

 xdgnjobs/ximple-spatialjob/src/main/java/com/ximple/eofms/jobs/OracleConvertDgn2PostGISJob.java

@@ -71,7 +71,6 @@
    private static final String USEWKB = "USEWKB";

    private static final int FETCHSIZE = 30;
    private static final int BATCHSIZE = 25;
    private static final int COMMITSIZE = 20;

    class Pair
@@ -231,8 +230,7 @@
            throw new JobExecutionException("Cannot connect source postgreSQL database.");
        }

        Calendar cal = Calendar.getInstance();
        Date startTime = cal.getTime();
        long t1 = System.currentTimeMillis();
        try
        {
            logger.info("-- step:clearOutputDatabase --");
@@ -285,11 +283,11 @@
            }

            disconnect();
            Date endTime = cal.getTime();
            Date time = new Date(endTime.getTime() - startTime.getTime());
            long t2 = System.currentTimeMillis();
            // public static final String DATE_FORMAT_NOW = "yyyy-MM-dd HH:mm:ss";
            // SimpleDateFormat sdf = new SimpleDateFormat(DATE_FORMAT_NOW);
            logger.warn("use time = " + time);
            logger.warn("use time = " + ((int) ((t2 - t1) / 60000.0)) + " min - " +
            (((int) ((t2 - t1) % 60000.0)) / 1000) + " sec");
        } catch (SQLException e)
        {
            logger.warn(e.getMessage(), e);
@@ -651,9 +649,11 @@
            logger.debug("--- start dgnfile-" + dgnFile.toString() + " ---");
            try
            {
                convertContext.clearOutputDatabase();
                convertContext.setExecutionContext(context);
                String dgnPaths[] = StringUtils.splitToArray(dgnFile.toString(), File.separator);
                convertContext.setFilename(dgnPaths[dgnPaths.length - 1]);
                convertContext.startTransaction();

                FileInputStream fs = new FileInputStream(dgnFile);
                FileChannel fc = fs.getChannel();
@@ -786,6 +786,7 @@
                convertContext.setExecutionContext(context);
                String dgnPaths[] = StringUtils.splitToArray(dgnFile.toString(), File.separator);
                convertContext.setFilename(dgnPaths[dgnPaths.length - 1]);
                convertContext.startTransaction();

                FileInputStream fs = new FileInputStream(dgnFile);
                FileChannel fc = fs.getChannel();
@@ -962,6 +963,7 @@
                convertContext.setExecutionContext(context);
                String dgnPaths[] = StringUtils.splitToArray(dgnFile.toString(), File.separator);
                convertContext.setFilename(dgnPaths[dgnPaths.length - 1]);
                convertContext.startTransaction();

                FileInputStream fs = new FileInputStream(dgnFile);
                FileChannel fc = fs.getChannel();
@@ -1089,7 +1091,7 @@

        if (!pgProperties.containsKey(PostgisDataStoreFactory.MAXCONN.key))
        {
            pgProperties.put(PostgisDataStoreFactory.MAXCONN.key, "2");
            pgProperties.put(PostgisDataStoreFactory.MAXCONN.key, "10");
        }

        if (!pgProperties.containsKey(PostgisDataStoreFactory.MINCONN.key))
@@ -1116,4 +1118,5 @@
            throw new JobExecutionException(e.getMessage(), e);
        }
    }

}

 xdgnjobs/ximple-spatialjob/src/main/java/com/ximple/eofms/jobs/OracleConvertDgn2ShpJob.java

@@ -523,6 +523,7 @@
                convertContext.setExecutionContext(context);
                String dgnPaths[] = StringUtils.splitToArray(dgnFile.toString(), File.separator);
                convertContext.setFilename(dgnPaths[dgnPaths.length - 1]);
                convertContext.startTransaction();

                FileInputStream fs = new FileInputStream(dgnFile);
                FileChannel fc = fs.getChannel();
@@ -653,6 +654,7 @@
                convertContext.setExecutionContext(context);
                String dgnPaths[] = StringUtils.splitToArray(dgnFile.toString(), File.separator);
                convertContext.setFilename(dgnPaths[dgnPaths.length - 1]);
                convertContext.startTransaction();

                FileInputStream fs = new FileInputStream(dgnFile);
                FileChannel fc = fs.getChannel();
@@ -826,6 +828,7 @@
                convertContext.setExecutionContext(context);
                String dgnPaths[] = StringUtils.splitToArray(dgnFile.toString(), File.separator);
                convertContext.setFilename(dgnPaths[dgnPaths.length - 1]);
                convertContext.startTransaction();

                FileInputStream fs = new FileInputStream(dgnFile);
                FileChannel fc = fs.getChannel();

 xdgnjobs/ximple-spatialjob/src/main/java/com/ximple/eofms/jobs/context/postgis/AbstractDgnToPostGISJobContext.java

@@ -1,24 +1,133 @@
package com.ximple.eofms.jobs.context.postgis;

import java.io.IOException;
import java.math.BigDecimal;
import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

import org.geotools.data.DataSourceException;
import org.geotools.data.DataStore;
import org.geotools.data.Transaction;
import org.geotools.data.SchemaNotFoundException;
import org.geotools.data.Transaction;
import org.geotools.data.jdbc.JDBCUtils;
import org.geotools.data.postgis.PostgisDataStore;
import org.geotools.feature.AttributeType;
import org.geotools.feature.Feature;
import org.geotools.feature.FeatureType;
import org.geotools.feature.GeometryAttributeType;
import org.geotools.filter.LengthFunction;
import org.geotools.referencing.NamedIdentifier;
import org.geotools.referencing.crs.DefaultGeographicCRS;
import org.opengis.filter.BinaryComparisonOperator;
import org.opengis.filter.Filter;
import org.opengis.filter.PropertyIsLessThan;
import org.opengis.filter.PropertyIsLessThanOrEqualTo;
import org.opengis.filter.expression.Literal;
import org.opengis.referencing.crs.CoordinateReferenceSystem;

import com.vividsolutions.jts.geom.Geometry;
import com.vividsolutions.jts.geom.GeometryCollection;
import com.vividsolutions.jts.geom.LineString;
import com.vividsolutions.jts.geom.MultiLineString;
import com.vividsolutions.jts.geom.MultiPoint;
import com.vividsolutions.jts.geom.MultiPolygon;
import com.vividsolutions.jts.geom.Point;
import com.vividsolutions.jts.geom.Polygon;
import com.vividsolutions.jts.io.WKBWriter;
import com.vividsolutions.jts.io.WKTWriter;

import com.ximple.eofms.jobs.context.AbstractDgnFileJobContext;

public abstract class AbstractDgnToPostGISJobContext extends AbstractDgnFileJobContext
{
    private static Map<String, Class> GEOM_TYPE_MAP = new HashMap<String, Class>();

    static
    {
        GEOM_TYPE_MAP.put("GEOMETRY", Geometry.class);
        GEOM_TYPE_MAP.put("POINT", Point.class);
        GEOM_TYPE_MAP.put("POINTM", Point.class);
        GEOM_TYPE_MAP.put("LINESTRING", LineString.class);
        GEOM_TYPE_MAP.put("LINESTRINGM", LineString.class);
        GEOM_TYPE_MAP.put("POLYGON", Polygon.class);
        GEOM_TYPE_MAP.put("POLYGONM", Polygon.class);
        GEOM_TYPE_MAP.put("MULTIPOINT", MultiPoint.class);
        GEOM_TYPE_MAP.put("MULTIPOINTM", MultiPoint.class);
        GEOM_TYPE_MAP.put("MULTILINESTRING", MultiLineString.class);
        GEOM_TYPE_MAP.put("MULTILINESTRINGM", MultiLineString.class);
        GEOM_TYPE_MAP.put("MULTIPOLYGON", MultiPolygon.class);
        GEOM_TYPE_MAP.put("MULTIPOLYGONM", MultiPolygon.class);
        GEOM_TYPE_MAP.put("GEOMETRYCOLLECTION", GeometryCollection.class);
        GEOM_TYPE_MAP.put("GEOMETRYCOLLECTIONM", GeometryCollection.class);
    }

    private static Map<Class, String> CLASS_MAPPINGS = new HashMap<Class, String>();

    static
    {
        CLASS_MAPPINGS.put(String.class, "VARCHAR");

        CLASS_MAPPINGS.put(Boolean.class, "BOOLEAN");

        CLASS_MAPPINGS.put(Short.class, "SMALLINT");
        CLASS_MAPPINGS.put(Integer.class, "INTEGER");
        CLASS_MAPPINGS.put(Long.class, "BIGINT");

        CLASS_MAPPINGS.put(Float.class, "REAL");
        CLASS_MAPPINGS.put(Double.class, "DOUBLE PRECISION");

        CLASS_MAPPINGS.put(BigDecimal.class, "DECIMAL");

        CLASS_MAPPINGS.put(java.sql.Date.class, "DATE");
        CLASS_MAPPINGS.put(java.util.Date.class, "DATE");
        CLASS_MAPPINGS.put(java.sql.Time.class, "TIME");
        CLASS_MAPPINGS.put(java.sql.Timestamp.class, "TIMESTAMP");
    }

    private static Map<Class, String> GEOM_CLASS_MAPPINGS = new HashMap<Class, String>();

    //why don't we just stick this in with the non-geom class mappings?
    static
    {
        // init the inverse map
        Set keys = GEOM_TYPE_MAP.keySet();

        for (Object key : keys)
        {
            String name = (String) key;
            Class geomClass = GEOM_TYPE_MAP.get(name);
            GEOM_CLASS_MAPPINGS.put(geomClass, name);
        }
    }

    /**
     * Maximum string size for postgres
     */
    private static final int MAX_ALLOWED_VALUE = 10485760;

    protected static final int BATCHSIZE = 25;

    /**
     * Well Known Text writer (from JTS).
     */
    protected static WKTWriter geometryWriter = new WKTWriter();

    protected PostgisDataStore targetDataStore;
    private Connection connection;
    protected boolean schemaEnabled = true;

    public AbstractDgnToPostGISJobContext(String dataPath, DataStore targetDataStore)
    {
        super(dataPath);
        this.targetDataStore = (PostgisDataStore) targetDataStore;
        this.connection = null;
    }

    public PostgisDataStore getTargetDataStore()
@@ -33,26 +142,37 @@

    public Connection getConnection()
    {
        if (connection != null) return connection;

        if (targetDataStore != null)
        {
            try
            {
                return targetDataStore.getConnection(Transaction.AUTO_COMMIT);
            } catch (IOException e)
                connection = targetDataStore.getDataSource().getConnection();
            } catch (SQLException e)
            {
                getLogger().warn(e.getMessage(), e);
                return null;
            }
        }
        return null;
        return connection;
    }

    public void closeConnection()
    {
        if (connection == null)
        {
            JDBCUtils.close(connection, Transaction.AUTO_COMMIT, null);
            connection = null;
        }
    }

    protected boolean isExistFeature(FeatureType featureType)
    {
        try
        {
            FeatureType existFeatureType = targetDataStore.getSchema(featureType.getTypeName());
            return existFeatureType != null && existFeatureType.equals(featureType);
            return existFeatureType != null; // && existFeatureType.equals(featureType);
        } catch (SchemaNotFoundException e)
        {
            return false;
@@ -62,4 +182,594 @@
            return false;
        }
    }

    protected void deleteTable(Connection conn, String tableName) throws SQLException
    {
        Statement stmt = conn.createStatement();
        StringBuilder sb = new StringBuilder();
        sb.append("DELETE FROM \"");
        sb.append(targetDataStore.getDatabaseSchemaName());
        sb.append("\".\"");
        sb.append(tableName);
        sb.append('\"');
        getLogger().info("Execute-" + sb.toString());
        stmt.execute(sb.toString());
        stmt.close();
        conn.commit();
    }

    protected void dropTable(Connection conn, String tableName) throws SQLException
    {
        Statement stmt = conn.createStatement();
        StringBuilder sb = new StringBuilder();
        sb.append("DROP TABLE \"");
        sb.append(targetDataStore.getDatabaseSchemaName());
        sb.append("\".\"");
        sb.append(tableName);
        sb.append("\" CASCADE");
        getLogger().info("Execute-" + sb.toString());
        stmt.execute(sb.toString());
        stmt.close();
        conn.commit();
    }

    protected void dropGeometryColumn(Connection conn, String tableName, String geomField) throws SQLException
    {
        Statement stmt = conn.createStatement();
        StringBuilder sb = new StringBuilder();
        sb.append("SELECT DropGeometryColumn('','");
        sb.append(tableName);
        sb.append("','");
        sb.append(geomField);
        sb.append("')");
        getLogger().info("Execute-" + sb.toString());
        stmt.execute(sb.toString());
        stmt.close();
        conn.commit();
    }

    public ArrayList<String> createSchemaTexts(FeatureType featureType) throws IOException
    {
        String tableName = featureType.getTypeName();

        // String lcTableName = tableName.toLowerCase();
        ArrayList<String> result = new ArrayList<String>();

        AttributeType[] attributeType = featureType.getAttributeTypes();
        String dbSchema = targetDataStore.getDatabaseSchemaName();

        Connection con = getConnection();

        boolean shouldExecute = !tablePresent(tableName, con);

        try
        {
            StringBuffer sql = new StringBuffer("CREATE TABLE ");
            sql.append(encodeSchemaTableName(tableName));
            sql.append(" (");
            sql.append(makeSqlCreate(attributeType));
            sql.append(");");

            String sqlStr = sql.toString();
            getLogger().info(sqlStr);

            if (shouldExecute)
            {
                result.add(sqlStr);
            }

            //fix from pr: it may be that table existed and then was dropped
            //without removing its geometry info from GEOMETRY_COLUMNS.
            //To support this, try to delete before inserting.
            //Preserving case for table names gives problems,
            //so convert to lower case

            sql = new StringBuffer("DELETE FROM GEOMETRY_COLUMNS WHERE f_table_catalog=''");
            sql.append(" AND f_table_schema = '");
            sql.append(dbSchema);
            sql.append("'");
            sql.append("AND f_table_name = '");
            sql.append(tableName);
            sql.append("';");

            //prints statement for later reuse
            sqlStr = sql.toString();
            getLogger().info(sqlStr);

            if (shouldExecute)
            {
                result.add(sqlStr);
            }

            //Ok, so Paolo Rizzi suggested that we get rid of our hand-adding
            //of geometry column information and use AddGeometryColumn instead
            //as it is better (this is in GEOT-379, he attached an extended
            //datastore that does postgis fixes).  But I am pretty positive
            //the reason we are doing things this way is to preserve the order
            //of FeatureTypes.  I know this is fairly silly, from most
            //information perspectives, but from another perspective it seems
            //to make sense - if you were transfering a featureType from one
            //data store to another then it should have the same order, right?
            //And order is important in WFS.  There are a few caveats though
            //for one I don't even know if things work right.  I imagine the
            //proper constraints that a AddGeometryColumn operation does are
            //not set in our hand version, for one.  I would feel better about
            //ignoring the order and just doing things as we like if we had
            //views in place, if users could add the schema, and then be able
            //to get it back in exactly the order they wanted.  So for now
            //let's leave things as is, and maybe talk about it in an irc. -ch
            for (AttributeType anAttributeType : attributeType)
            {
                if (!(anAttributeType instanceof GeometryAttributeType))
                {
                    continue;
                }
                GeometryAttributeType geomAttribute = (GeometryAttributeType) anAttributeType;
                String columnName = anAttributeType.getLocalName();

                CoordinateReferenceSystem refSys = geomAttribute
                        .getCoordinateSystem();
                int SRID;

                if (refSys != null)
                {
                    try
                    {
                        Set ident = refSys.getIdentifiers();
                        if ((ident == null || ident.isEmpty()) && refSys == DefaultGeographicCRS.WGS84)
                        {
                            SRID = 4326;
                        } else
                        {
                            String code = ((NamedIdentifier) ident.toArray()[0]).getCode();
                            SRID = Integer.parseInt(code);
                        }
                    } catch (Exception e)
                    {
                        getLogger().warn("SRID could not be determined");
                        SRID = -1;
                    }
                } else
                {
                    SRID = -1;
                }

                String typeName;

                //this construct seems unnecessary, since we already would
                //pass over if this wasn't a geometry...
                Class type = geomAttribute.getType();

                if (geomAttribute instanceof GeometryAttributeType)
                {
                    typeName = getGeometrySQLTypeName(type);
                } else
                {
                    typeName = CLASS_MAPPINGS.get(type);
                }

                if (typeName != null)
                {
                    //add a row to the geometry_columns table
                    sql = new StringBuffer("INSERT INTO GEOMETRY_COLUMNS VALUES (");
                    sql.append("'','");
                    sql.append(dbSchema);
                    sql.append("','");
                    sql.append(tableName);
                    sql.append("','");
                    sql.append(columnName);
                    sql.append("',2,");
                    sql.append(SRID);
                    sql.append(",'");
                    sql.append(typeName);
                    sql.append("');");

                    sqlStr = sql.toString();
                    getLogger().info(sqlStr);

                    if (shouldExecute)
                    {
                        result.add(sqlStr);
                    }

                    //add geometry constaints to the table
                    if (SRID > -1)
                    {
                        sql = new StringBuffer("ALTER TABLE ");
                        sql.append(encodeSchemaTableName(tableName));
                        sql.append(" ADD CONSTRAINT enforce_srid_");
                        sql.append(columnName);
                        sql.append(" CHECK (SRID(");
                        sql.append(encodeSchemaColumnName(columnName));
                        sql.append(") = ");
                        sql.append(SRID);
                        sql.append(");");
                        sqlStr = sql.toString();
                        getLogger().info(sqlStr);
                        if (shouldExecute)
                        {
                            result.add(sqlStr);
                        }
                    }

                    sql = new StringBuffer("ALTER TABLE ");
                    sql.append(encodeSchemaTableName(tableName));
                    sql.append(" ADD CONSTRAINT enforce_dims_");
                    sql.append(columnName);
                    sql.append(" CHECK (ndims(");
                    sql.append(encodeSchemaColumnName(columnName));
                    sql.append(") = 2);");
                    sqlStr = sql.toString();
                    getLogger().info(sqlStr);
                    if (shouldExecute)
                    {
                        result.add(sqlStr);
                    }

                    if (!typeName.equals("GEOMETRY"))
                    {
                        sql = new StringBuffer("ALTER TABLE ");
                        sql.append(encodeSchemaTableName(tableName));
                        sql.append(" ADD CONSTRAINT enforce_geotype_");
                        sql.append(columnName);
                        sql.append(" CHECK (geometrytype(");
                        sql.append(encodeSchemaColumnName(columnName));
                        sql.append(") = '");
                        sql.append(typeName);
                        sql.append("'::text OR ");
                        sql.append(encodeSchemaColumnName(columnName));
                        sql.append(" IS NULL);");
                        sqlStr = sql.toString();
                        getLogger().info(sqlStr);
                        if (shouldExecute)
                        {
                            result.add(sqlStr);
                        }
                    }

                } else
                {
                    getLogger().warn("Error: " + geomAttribute.getLocalName() + " unknown type!!!");
                }

                //also build a spatial index on each geometry column.
                sql = new StringBuffer("CREATE INDEX spatial_");
                sql.append(tableName);
                sql.append("_");
                sql.append(anAttributeType.getLocalName().toLowerCase());
                sql.append(" ON ");
                sql.append(encodeSchemaTableName(tableName));
                sql.append(" USING GIST (");
                sql.append(encodeSchemaColumnName(anAttributeType.getLocalName()));
                sql.append(");");

                sqlStr = sql.toString();
                getLogger().info(sqlStr);

                if (shouldExecute)
                {
                    result.add(sqlStr);
                }
            }

            con.commit();

        } catch (SQLException e)
        {
            try
            {
                if (con != null)
                {
                    con.rollback();
                }
            } catch (SQLException sqle)
            {
                throw new IOException(sqle.getMessage());
            }

            throw (IOException) new IOException(e.getMessage()).initCause(e);
        } finally
        {
        }

        if (!shouldExecute)
        {
            throw new IOException("The table " + tableName + " already exists.");
        }

        return result;
    }

    private boolean tablePresent(String table, Connection conn) throws IOException
    {
        final int TABLE_NAME_COL = 3;

        try
        {
            conn = getConnection();

            DatabaseMetaData meta = conn.getMetaData();
            String[] tableType = {"TABLE"};
            ResultSet tables = meta.getTables(null,
                    targetDataStore.getDatabaseSchemaName(), "%", tableType);

            while (tables.next())
            {
                String tableName = tables.getString(TABLE_NAME_COL);

                if (allowTable(tableName) && (tableName != null)
                        && (tableName.equalsIgnoreCase(table)))
                {
                    return (true);
                }
            }

            return false;
        } catch (SQLException sqlException)
        {
            // JDBCUtils.close(conn, Transaction.AUTO_COMMIT, sqlException);
            // conn = null;

            String message = "Error querying database for list of tables:"
                    + sqlException.getMessage();
            throw new DataSourceException(message, sqlException);
        } finally
        {
            // JDBCUtils.close(conn, Transaction.AUTO_COMMIT, null);
        }
    }

    protected boolean allowTable(String tablename)
    {
        if (tablename.equals("geometry_columns"))
        {
            return false;
        } else if (tablename.startsWith("spatial_ref_sys"))
        {
            return false;
        }

        //others?
        return true;
    }


    private StringBuffer makeSqlCreate(AttributeType[] attributeType)
            throws IOException
    {
        StringBuffer buf = new StringBuffer("");

        for (AttributeType anAttributeType : attributeType)
        {
            String typeName;
            typeName = CLASS_MAPPINGS.get(anAttributeType.getBinding());
            if (typeName == null)
                typeName = GEOM_CLASS_MAPPINGS.get(anAttributeType.getBinding());

            if (typeName != null)
            {
                if (anAttributeType instanceof GeometryAttributeType)
                {
                    typeName = "GEOMETRY";
                } else if (typeName.equals("VARCHAR"))
                {
                    int length = -1;
                    Filter f = anAttributeType.getRestriction();
                    if (f != null && f != Filter.EXCLUDE && f != Filter.INCLUDE &&
                            (f instanceof PropertyIsLessThan || f instanceof PropertyIsLessThanOrEqualTo))
                    {
                        try
                        {
                            BinaryComparisonOperator cf = (BinaryComparisonOperator) f;
                            if (cf.getExpression1() instanceof LengthFunction)
                            {
                                length = Integer.parseInt(((Literal) cf.getExpression2()).getValue().toString());
                            } else
                            {
                                if (cf.getExpression2() instanceof LengthFunction)
                                {
                                    length = Integer.parseInt(((Literal) cf.getExpression1()).getValue().toString());
                                }
                            }
                        } catch (NumberFormatException e)
                        {
                            length = 256;
                        }
                    } else
                    {
                        length = 256;
                    }

                    if (length < 1)
                    {
                        getLogger().warn("FeatureType did not specify string length; defaulted to 256");
                        length = 256;
                    } else if (length > MAX_ALLOWED_VALUE)
                    {
                        length = MAX_ALLOWED_VALUE;
                    }
                    typeName = typeName + "(" + length + ")";
                }

                if (!anAttributeType.isNillable())
                {
                    typeName = typeName + " NOT NULL";
                }

                //TODO review!!! Is toString() always OK???
                Object defaultValue = anAttributeType.createDefaultValue();

                if (defaultValue != null)
                {
                    typeName = typeName + " DEFAULT '"
                            + defaultValue.toString() + "'";
                }

                buf.append(" \"").append(anAttributeType.getLocalName()).append("\" ").append(typeName).append(",");

            } else
            {
                String msg;
                if (anAttributeType == null)
                {
                    msg = "AttributeType was null!";
                } else
                {
                    msg = "Type '" + anAttributeType.getBinding() + "' not supported!";
                }
                throw (new IOException(msg));
            }
        }

        return buf.deleteCharAt(buf.length() - 1);
    }

    private String getGeometrySQLTypeName(Class type)
    {
        String res = GEOM_CLASS_MAPPINGS.get(type);

        if (res == null)
        {
            throw new RuntimeException("Unknown type name for class " + type
                    + " please update GEOMETRY_MAPPINGS");
        }

        return res;
    }

    protected String getGeometryInsertText(Geometry geom, int srid) // throws IOException
    {
        if (geom == null)
        {
            return "null";
        }

        if (targetDataStore.isWKBEnabled())
        {
            //String wkb = WKBEncoder.encodeGeometryHex(geom);
            String wkb = WKBWriter.bytesToHex(new WKBWriter().write(geom));

            if (targetDataStore.isByteaWKB())
            {
                return "setSRID('" + wkb + "'::geometry," + srid + ")";
            } else
            {
                return "GeomFromWKB('" + wkb + "', " + srid + ")";
            }
        }

        String geoText = geometryWriter.write(geom);

        return "GeometryFromText('" + geoText + "', " + srid + ")";
    }

    protected String makeInsertSql(Feature feature, int srid) // throws IOException
    {
        FeatureType featureType = feature.getFeatureType();

        String tableName = encodeSchemaTableName(featureType.getTypeName());
        AttributeType[] attributeTypes = featureType.getAttributeTypes();

        String attrValue;

        StringBuffer statementSQL = new StringBuffer("INSERT INTO " + tableName + " (");

        // encode insertion for attributes, but remember to avoid auto-increment ones,
        // they may be included in the feature type as well
        for (AttributeType attributeType : attributeTypes)
        {
            String attName = attributeType.getLocalName();

            if (feature.getAttribute(attName) != null)
            {
                String colName = encodeSchemaColumnName(attName);
                statementSQL.append(colName).append(",");
            }
        }

        statementSQL.setCharAt(statementSQL.length() - 1, ')');
        statementSQL.append(" VALUES (");

        Object[] attributes = feature.getAttributes(null);

        for (int i = 0; i < attributeTypes.length; i++)
        {
            attrValue = null;

            if (attributeTypes[i] instanceof GeometryAttributeType)
            {
                // String geomName = attributeTypes[i].getLocalName();
                // int srid = ftInfo.getSRID(geomName);
                Geometry geometry = (Geometry) attributes[i];

                if (geometry == null)
                {
                    attrValue = "NULL";
                } else
                {
                    attrValue = getGeometryInsertText(geometry, srid);
                }
            } else
            {
                if (attributes[i] != null)
                {
                    attrValue = addQuotes(attributes[i]);
                }
            }

            if (attrValue != null)
            {
                statementSQL.append(attrValue).append(",");
            }
        }

        statementSQL.setCharAt(statementSQL.length() - 1, ')');

        return (statementSQL.toString());
    }

    protected String addQuotes(Object value)
    {
        String retString;

        if (value != null)
        {
            if (value instanceof Number)
            {
                retString = value.toString();
            } else
            {
                retString = "'" + doubleQuote(value) + "'";
            }
        } else
        {
            retString = "null";
        }

        return retString;
    }

    String doubleQuote(Object obj)
    {
        return obj.toString().replaceAll("'", "''");
    }

    protected String encodeName(String tableName)
    {
        return tableName;
    }

    protected String encodeColumnName(String colName)
    {
        return encodeName(colName);
    }

    public String encodeSchemaTableName(String tableName) {
        return schemaEnabled ? ("\"" + targetDataStore.getDatabaseSchemaName() + "\".\"" + tableName + "\"")
                             : ("\"" + tableName + "\"");
    }

    public String encodeSchemaColumnName(String columnName) {
        return "\"" + columnName + "\"";
    }
}

 xdgnjobs/ximple-spatialjob/src/main/java/com/ximple/eofms/jobs/context/postgis/AbstractOracleToPostGISJobContext.java

@@ -2,18 +2,127 @@

import java.io.IOException;
import java.sql.Connection;
import java.sql.SQLException;
import java.sql.Statement;
import java.sql.DatabaseMetaData;
import java.sql.ResultSet;
import java.util.Map;
import java.util.HashMap;
import java.util.Set;
import java.util.ArrayList;
import java.math.BigDecimal;

import org.geotools.data.DataStore;
import org.geotools.data.Transaction;
import org.geotools.data.SchemaNotFoundException;
import org.geotools.data.DataSourceException;
import org.geotools.data.jdbc.JDBCUtils;
import org.geotools.data.postgis.PostgisDataStore;
import org.geotools.feature.FeatureType;
import org.geotools.feature.AttributeType;
import org.geotools.feature.GeometryAttributeType;
import org.geotools.feature.Feature;
import org.geotools.referencing.crs.DefaultGeographicCRS;
import org.geotools.referencing.NamedIdentifier;
import org.geotools.filter.LengthFunction;
import org.opengis.referencing.crs.CoordinateReferenceSystem;
import org.opengis.filter.Filter;
import org.opengis.filter.PropertyIsLessThan;
import org.opengis.filter.PropertyIsLessThanOrEqualTo;
import org.opengis.filter.BinaryComparisonOperator;
import org.opengis.filter.expression.Literal;

import com.vividsolutions.jts.geom.Geometry;
import com.vividsolutions.jts.geom.Point;
import com.vividsolutions.jts.geom.LineString;
import com.vividsolutions.jts.geom.Polygon;
import com.vividsolutions.jts.geom.MultiPoint;
import com.vividsolutions.jts.geom.MultiLineString;
import com.vividsolutions.jts.geom.MultiPolygon;
import com.vividsolutions.jts.geom.GeometryCollection;
import com.vividsolutions.jts.io.WKTWriter;
import com.vividsolutions.jts.io.WKBWriter;

import com.ximple.eofms.jobs.context.AbstractOracleJobContext;

public abstract class AbstractOracleToPostGISJobContext extends AbstractOracleJobContext
{
    private static Map<String, Class> GEOM_TYPE_MAP = new HashMap<String, Class>();

    static
    {
        GEOM_TYPE_MAP.put("GEOMETRY", Geometry.class);
        GEOM_TYPE_MAP.put("POINT", Point.class);
        GEOM_TYPE_MAP.put("POINTM", Point.class);
        GEOM_TYPE_MAP.put("LINESTRING", LineString.class);
        GEOM_TYPE_MAP.put("LINESTRINGM", LineString.class);
        GEOM_TYPE_MAP.put("POLYGON", Polygon.class);
        GEOM_TYPE_MAP.put("POLYGONM", Polygon.class);
        GEOM_TYPE_MAP.put("MULTIPOINT", MultiPoint.class);
        GEOM_TYPE_MAP.put("MULTIPOINTM", MultiPoint.class);
        GEOM_TYPE_MAP.put("MULTILINESTRING", MultiLineString.class);
        GEOM_TYPE_MAP.put("MULTILINESTRINGM", MultiLineString.class);
        GEOM_TYPE_MAP.put("MULTIPOLYGON", MultiPolygon.class);
        GEOM_TYPE_MAP.put("MULTIPOLYGONM", MultiPolygon.class);
        GEOM_TYPE_MAP.put("GEOMETRYCOLLECTION", GeometryCollection.class);
        GEOM_TYPE_MAP.put("GEOMETRYCOLLECTIONM", GeometryCollection.class);
    }

    private static Map<Class, String> CLASS_MAPPINGS = new HashMap<Class, String>();

    static
    {
        CLASS_MAPPINGS.put(String.class, "VARCHAR");

        CLASS_MAPPINGS.put(Boolean.class, "BOOLEAN");

        CLASS_MAPPINGS.put(Short.class, "SMALLINT");
        CLASS_MAPPINGS.put(Integer.class, "INTEGER");
        CLASS_MAPPINGS.put(Long.class, "BIGINT");

        CLASS_MAPPINGS.put(Float.class, "REAL");
        CLASS_MAPPINGS.put(Double.class, "DOUBLE PRECISION");

        CLASS_MAPPINGS.put(BigDecimal.class, "DECIMAL");

        CLASS_MAPPINGS.put(java.sql.Date.class, "DATE");
        CLASS_MAPPINGS.put(java.util.Date.class, "DATE");
        CLASS_MAPPINGS.put(java.sql.Time.class, "TIME");
        CLASS_MAPPINGS.put(java.sql.Timestamp.class, "TIMESTAMP");
    }

    private static Map<Class, String> GEOM_CLASS_MAPPINGS = new HashMap<Class, String>();

    //why don't we just stick this in with the non-geom class mappings?
    static
    {
        // init the inverse map
        Set keys = GEOM_TYPE_MAP.keySet();

        for (Object key : keys)
        {
            String name = (String) key;
            Class geomClass = GEOM_TYPE_MAP.get(name);
            GEOM_CLASS_MAPPINGS.put(geomClass, name);
        }
    }

    /**
     * Maximum string size for postgres
     */
    private static final int MAX_ALLOWED_VALUE = 10485760;

    protected static final int BATCHSIZE = 25;

    /**
     * Well Known Text writer (from JTS).
     */
    protected static WKTWriter geometryWriter = new WKTWriter();

    protected PostgisDataStore targetDataStore;

    private Connection connection;
    protected boolean schemaEnabled = true;

    public AbstractOracleToPostGISJobContext(String dataPath, DataStore targetDataStore)
    {
@@ -39,26 +148,37 @@

    public Connection getConnection()
    {
        if (connection != null) return connection;

        if (targetDataStore != null)
        {
            try
            {
                return targetDataStore.getConnection(Transaction.AUTO_COMMIT);
            } catch (IOException e)
                connection = targetDataStore.getDataSource().getConnection();
            } catch (SQLException e)
            {
                getLogger().warn(e.getMessage(), e);
                return null;
            }
        }
        return null;
        return connection;
    }

    public void closeConnection()
    {
        if (connection == null)
        {
            JDBCUtils.close(connection, Transaction.AUTO_COMMIT, null);
            connection = null;
        }
    }

    protected boolean isExistFeature(FeatureType featureType)
    {
        try
        {
            FeatureType existFeatureType = targetDataStore.getSchema(featureType.getTypeName());
            return existFeatureType != null && existFeatureType.equals(featureType);
            return existFeatureType != null; // && existFeatureType.equals(featureType);
        } catch (SchemaNotFoundException e)
        {
            return false;
@@ -68,4 +188,594 @@
            return false;
        }
    }

    protected void deleteTable(Connection conn, String tableName) throws SQLException
    {
        Statement stmt = conn.createStatement();
        StringBuilder sb = new StringBuilder();
        sb.append("DELETE FROM \"");
        sb.append(targetDataStore.getDatabaseSchemaName());
        sb.append("\".\"");
        sb.append(tableName);
        sb.append('\"');
        getLogger().info("Execute-" + sb.toString());
        stmt.execute(sb.toString());
        stmt.close();
        conn.commit();
    }

    protected void dropTable(Connection conn, String tableName) throws SQLException
    {
        Statement stmt = conn.createStatement();
        StringBuilder sb = new StringBuilder();
        sb.append("DROP TABLE \"");
        sb.append(targetDataStore.getDatabaseSchemaName());
        sb.append("\".\"");
        sb.append(tableName);
        sb.append("\" CASCADE");
        getLogger().info("Execute-" + sb.toString());
        stmt.execute(sb.toString());
        stmt.close();
        conn.commit();
    }

    protected void dropGeometryColumn(Connection conn, String tableName, String geomField) throws SQLException
    {
        Statement stmt = conn.createStatement();
        StringBuilder sb = new StringBuilder();
        sb.append("SELECT DropGeometryColumn('','");
        sb.append(tableName);
        sb.append("','");
        sb.append(geomField);
        sb.append("')");
        getLogger().info("Execute-" + sb.toString());
        stmt.execute(sb.toString());
        stmt.close();
        conn.commit();
    }

    public ArrayList<String> createSchemaTexts(FeatureType featureType) throws IOException
    {
        String tableName = featureType.getTypeName();

        // String lcTableName = tableName.toLowerCase();
        ArrayList<String> result = new ArrayList<String>();

        AttributeType[] attributeType = featureType.getAttributeTypes();
        String dbSchema = targetDataStore.getDatabaseSchemaName();

        Connection con = getConnection();

        boolean shouldExecute = !tablePresent(tableName, con);

        try
        {
            StringBuffer sql = new StringBuffer("CREATE TABLE ");
            sql.append(encodeSchemaTableName(tableName));
            sql.append(" (");
            sql.append(makeSqlCreate(attributeType));
            sql.append(");");

            String sqlStr = sql.toString();
            getLogger().info(sqlStr);

            if (shouldExecute)
            {
                result.add(sqlStr);
            }

            //fix from pr: it may be that table existed and then was dropped
            //without removing its geometry info from GEOMETRY_COLUMNS.
            //To support this, try to delete before inserting.
            //Preserving case for table names gives problems,
            //so convert to lower case

            sql = new StringBuffer("DELETE FROM GEOMETRY_COLUMNS WHERE f_table_catalog=''");
            sql.append(" AND f_table_schema = '");
            sql.append(dbSchema);
            sql.append("'");
            sql.append("AND f_table_name = '");
            sql.append(tableName);
            sql.append("';");

            //prints statement for later reuse
            sqlStr = sql.toString();
            getLogger().info(sqlStr);

            if (shouldExecute)
            {
                result.add(sqlStr);
            }

            //Ok, so Paolo Rizzi suggested that we get rid of our hand-adding
            //of geometry column information and use AddGeometryColumn instead
            //as it is better (this is in GEOT-379, he attached an extended
            //datastore that does postgis fixes).  But I am pretty positive
            //the reason we are doing things this way is to preserve the order
            //of FeatureTypes.  I know this is fairly silly, from most
            //information perspectives, but from another perspective it seems
            //to make sense - if you were transfering a featureType from one
            //data store to another then it should have the same order, right?
            //And order is important in WFS.  There are a few caveats though
            //for one I don't even know if things work right.  I imagine the
            //proper constraints that a AddGeometryColumn operation does are
            //not set in our hand version, for one.  I would feel better about
            //ignoring the order and just doing things as we like if we had
            //views in place, if users could add the schema, and then be able
            //to get it back in exactly the order they wanted.  So for now
            //let's leave things as is, and maybe talk about it in an irc. -ch
            for (AttributeType anAttributeType : attributeType)
            {
                if (!(anAttributeType instanceof GeometryAttributeType))
                {
                    continue;
                }
                GeometryAttributeType geomAttribute = (GeometryAttributeType) anAttributeType;
                String columnName = anAttributeType.getLocalName();

                CoordinateReferenceSystem refSys = geomAttribute
                        .getCoordinateSystem();
                int SRID;

                if (refSys != null)
                {
                    try
                    {
                        Set ident = refSys.getIdentifiers();
                        if ((ident == null || ident.isEmpty()) && refSys == DefaultGeographicCRS.WGS84)
                        {
                            SRID = 4326;
                        } else
                        {
                            String code = ((NamedIdentifier) ident.toArray()[0]).getCode();
                            SRID = Integer.parseInt(code);
                        }
                    } catch (Exception e)
                    {
                        getLogger().warn("SRID could not be determined");
                        SRID = -1;
                    }
                } else
                {
                    SRID = -1;
                }

                String typeName;

                //this construct seems unnecessary, since we already would
                //pass over if this wasn't a geometry...
                Class type = geomAttribute.getType();

                if (geomAttribute instanceof GeometryAttributeType)
                {
                    typeName = getGeometrySQLTypeName(type);
                } else
                {
                    typeName = CLASS_MAPPINGS.get(type);
                }

                if (typeName != null)
                {
                    //add a row to the geometry_columns table
                    sql = new StringBuffer("INSERT INTO GEOMETRY_COLUMNS VALUES (");
                    sql.append("'','");
                    sql.append(dbSchema);
                    sql.append("','");
                    sql.append(tableName);
                    sql.append("','");
                    sql.append(columnName);
                    sql.append("',2,");
                    sql.append(SRID);
                    sql.append(",'");
                    sql.append(typeName);
                    sql.append("');");

                    sqlStr = sql.toString();
                    getLogger().info(sqlStr);

                    if (shouldExecute)
                    {
                        result.add(sqlStr);
                    }

                    //add geometry constaints to the table
                    if (SRID > -1)
                    {
                        sql = new StringBuffer("ALTER TABLE ");
                        sql.append(encodeSchemaTableName(tableName));
                        sql.append(" ADD CONSTRAINT enforce_srid_");
                        sql.append(columnName);
                        sql.append(" CHECK (SRID(");
                        sql.append(encodeSchemaColumnName(columnName));
                        sql.append(") = ");
                        sql.append(SRID);
                        sql.append(");");
                        sqlStr = sql.toString();
                        getLogger().info(sqlStr);
                        if (shouldExecute)
                        {
                            result.add(sqlStr);
                        }
                    }

                    sql = new StringBuffer("ALTER TABLE ");
                    sql.append(encodeSchemaTableName(tableName));
                    sql.append(" ADD CONSTRAINT enforce_dims_");
                    sql.append(columnName);
                    sql.append(" CHECK (ndims(");
                    sql.append(encodeSchemaColumnName(columnName));
                    sql.append(") = 2);");
                    sqlStr = sql.toString();
                    getLogger().info(sqlStr);
                    if (shouldExecute)
                    {
                        result.add(sqlStr);
                    }

                    if (!typeName.equals("GEOMETRY"))
                    {
                        sql = new StringBuffer("ALTER TABLE ");
                        sql.append(encodeSchemaTableName(tableName));
                        sql.append(" ADD CONSTRAINT enforce_geotype_");
                        sql.append(columnName);
                        sql.append(" CHECK (geometrytype(");
                        sql.append(encodeSchemaColumnName(columnName));
                        sql.append(") = '");
                        sql.append(typeName);
                        sql.append("'::text OR ");
                        sql.append(encodeSchemaColumnName(columnName));
                        sql.append(" IS NULL);");
                        sqlStr = sql.toString();
                        getLogger().info(sqlStr);
                        if (shouldExecute)
                        {
                            result.add(sqlStr);
                        }
                    }

                } else
                {
                    getLogger().warn("Error: " + geomAttribute.getLocalName() + " unknown type!!!");
                }

                //also build a spatial index on each geometry column.
                sql = new StringBuffer("CREATE INDEX spatial_");
                sql.append(tableName);
                sql.append("_");
                sql.append(anAttributeType.getLocalName().toLowerCase());
                sql.append(" ON ");
                sql.append(encodeSchemaTableName(tableName));
                sql.append(" USING GIST (");
                sql.append(encodeSchemaColumnName(anAttributeType.getLocalName()));
                sql.append(");");

                sqlStr = sql.toString();
                getLogger().info(sqlStr);

                if (shouldExecute)
                {
                    result.add(sqlStr);
                }
            }

            con.commit();

        } catch (SQLException e)
        {
            try
            {
                if (con != null)
                {
                    con.rollback();
                }
            } catch (SQLException sqle)
            {
                throw new IOException(sqle.getMessage());
            }

            throw (IOException) new IOException(e.getMessage()).initCause(e);
        } finally
        {
        }

        if (!shouldExecute)
        {
            throw new IOException("The table " + tableName + " already exists.");
        }

        return result;
    }

    private boolean tablePresent(String table, Connection conn) throws IOException
    {
        final int TABLE_NAME_COL = 3;

        try
        {
            conn = getConnection();

            DatabaseMetaData meta = conn.getMetaData();
            String[] tableType = {"TABLE"};
            ResultSet tables = meta.getTables(null,
                    targetDataStore.getDatabaseSchemaName(), "%", tableType);

            while (tables.next())
            {
                String tableName = tables.getString(TABLE_NAME_COL);

                if (allowTable(tableName) && (tableName != null)
                        && (tableName.equalsIgnoreCase(table)))
                {
                    return (true);
                }
            }

            return false;
        } catch (SQLException sqlException)
        {
            // JDBCUtils.close(conn, Transaction.AUTO_COMMIT, sqlException);
            // conn = null;

            String message = "Error querying database for list of tables:"
                    + sqlException.getMessage();
            throw new DataSourceException(message, sqlException);
        } finally
        {
            // JDBCUtils.close(conn, Transaction.AUTO_COMMIT, null);
        }
    }

    protected boolean allowTable(String tablename)
    {
        if (tablename.equals("geometry_columns"))
        {
            return false;
        } else if (tablename.startsWith("spatial_ref_sys"))
        {
            return false;
        }

        //others?
        return true;
    }


    private StringBuffer makeSqlCreate(AttributeType[] attributeType)
            throws IOException
    {
        StringBuffer buf = new StringBuffer("");

        for (AttributeType anAttributeType : attributeType)
        {
            String typeName;
            typeName = CLASS_MAPPINGS.get(anAttributeType.getBinding());
            if (typeName == null)
                typeName = GEOM_CLASS_MAPPINGS.get(anAttributeType.getBinding());

            if (typeName != null)
            {
                if (anAttributeType instanceof GeometryAttributeType)
                {
                    typeName = "GEOMETRY";
                } else if (typeName.equals("VARCHAR"))
                {
                    int length = -1;
                    Filter f = anAttributeType.getRestriction();
                    if (f != null && f != Filter.EXCLUDE && f != Filter.INCLUDE &&
                            (f instanceof PropertyIsLessThan || f instanceof PropertyIsLessThanOrEqualTo))
                    {
                        try
                        {
                            BinaryComparisonOperator cf = (BinaryComparisonOperator) f;
                            if (cf.getExpression1() instanceof LengthFunction)
                            {
                                length = Integer.parseInt(((Literal) cf.getExpression2()).getValue().toString());
                            } else
                            {
                                if (cf.getExpression2() instanceof LengthFunction)
                                {
                                    length = Integer.parseInt(((Literal) cf.getExpression1()).getValue().toString());
                                }
                            }
                        } catch (NumberFormatException e)
                        {
                            length = 256;
                        }
                    } else
                    {
                        length = 256;
                    }

                    if (length < 1)
                    {
                        getLogger().warn("FeatureType did not specify string length; defaulted to 256");
                        length = 256;
                    } else if (length > MAX_ALLOWED_VALUE)
                    {
                        length = MAX_ALLOWED_VALUE;
                    }
                    typeName = typeName + "(" + length + ")";
                }

                if (!anAttributeType.isNillable())
                {
                    typeName = typeName + " NOT NULL";
                }

                //TODO review!!! Is toString() always OK???
                Object defaultValue = anAttributeType.createDefaultValue();

                if (defaultValue != null)
                {
                    typeName = typeName + " DEFAULT '"
                            + defaultValue.toString() + "'";
                }

                buf.append(" \"").append(anAttributeType.getLocalName()).append("\" ").append(typeName).append(",");

            } else
            {
                String msg;
                if (anAttributeType == null)
                {
                    msg = "AttributeType was null!";
                } else
                {
                    msg = "Type '" + anAttributeType.getBinding() + "' not supported!";
                }
                throw (new IOException(msg));
            }
        }

        return buf.deleteCharAt(buf.length() - 1);
    }

    private String getGeometrySQLTypeName(Class type)
    {
        String res = GEOM_CLASS_MAPPINGS.get(type);

        if (res == null)
        {
            throw new RuntimeException("Unknown type name for class " + type
                    + " please update GEOMETRY_MAPPINGS");
        }

        return res;
    }

    protected String getGeometryInsertText(Geometry geom, int srid) // throws IOException
    {
        if (geom == null)
        {
            return "null";
        }

        if (targetDataStore.isWKBEnabled())
        {
            //String wkb = WKBEncoder.encodeGeometryHex(geom);
            String wkb = WKBWriter.bytesToHex(new WKBWriter().write(geom));

            if (targetDataStore.isByteaWKB())
            {
                return "setSRID('" + wkb + "'::geometry," + srid + ")";
            } else
            {
                return "GeomFromWKB('" + wkb + "', " + srid + ")";
            }
        }

        String geoText = geometryWriter.write(geom);

        return "GeometryFromText('" + geoText + "', " + srid + ")";
    }

    protected String makeInsertSql(Feature feature, int srid) // throws IOException
    {
        FeatureType featureType = feature.getFeatureType();

        String tableName = encodeSchemaTableName(featureType.getTypeName());
        AttributeType[] attributeTypes = featureType.getAttributeTypes();

        String attrValue;

        StringBuffer statementSQL = new StringBuffer("INSERT INTO " + tableName + " (");

        // encode insertion for attributes, but remember to avoid auto-increment ones,
        // they may be included in the feature type as well
        for (AttributeType attributeType : attributeTypes)
        {
            String attName = attributeType.getLocalName();

            if (feature.getAttribute(attName) != null)
            {
                String colName = encodeSchemaColumnName(attName);
                statementSQL.append(colName).append(",");
            }
        }

        statementSQL.setCharAt(statementSQL.length() - 1, ')');
        statementSQL.append(" VALUES (");

        Object[] attributes = feature.getAttributes(null);

        for (int i = 0; i < attributeTypes.length; i++)
        {
            attrValue = null;

            if (attributeTypes[i] instanceof GeometryAttributeType)
            {
                // String geomName = attributeTypes[i].getLocalName();
                // int srid = ftInfo.getSRID(geomName);
                Geometry geometry = (Geometry) attributes[i];

                if (geometry == null)
                {
                    attrValue = "NULL";
                } else
                {
                    attrValue = getGeometryInsertText(geometry, srid);
                }
            } else
            {
                if (attributes[i] != null)
                {
                    attrValue = addQuotes(attributes[i]);
                }
            }

            if (attrValue != null)
            {
                statementSQL.append(attrValue).append(",");
            }
        }

        statementSQL.setCharAt(statementSQL.length() - 1, ')');

        return (statementSQL.toString());
    }

    protected String addQuotes(Object value)
    {
        String retString;

        if (value != null)
        {
            if (value instanceof Number)
            {
                retString = value.toString();
            } else
            {
                retString = "'" + doubleQuote(value) + "'";
            }
        } else
        {
            retString = "null";
        }

        return retString;
    }

    String doubleQuote(Object obj)
    {
        return obj.toString().replaceAll("'", "''");
    }

    protected String encodeName(String tableName)
    {
        return tableName;
    }

    protected String encodeColumnName(String colName)
    {
        return encodeName(colName);
    }

    public String encodeSchemaTableName(String tableName) {
        return schemaEnabled ? ("\"" + targetDataStore.getDatabaseSchemaName() + "\".\"" + tableName + "\"")
                             : ("\"" + tableName + "\"");
    }

    public String encodeSchemaColumnName(String columnName) {
        return "\"" + columnName + "\"";
    }
}

 xdgnjobs/ximple-spatialjob/src/main/java/com/ximple/eofms/jobs/context/postgis/GeneralDgnConvertPostGISJobContext.java

@@ -9,6 +9,9 @@
import java.util.Iterator;
import java.util.List;
import java.util.TreeMap;
import java.sql.Connection;
import java.sql.SQLException;
import java.sql.Statement;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
@@ -18,12 +21,18 @@
import org.geotools.data.DataStore;
import org.geotools.data.FeatureWriter;
import org.geotools.data.Transaction;
import org.geotools.data.DefaultTransaction;
import org.geotools.data.DataSourceException;
import org.geotools.data.FeatureStore;
import org.geotools.feature.Feature;
import org.geotools.feature.FeatureType;
import org.geotools.feature.FeatureTypeBuilder;
import org.geotools.feature.IllegalAttributeException;
import org.geotools.feature.SchemaException;
import org.geotools.feature.SimpleFeature;
import org.geotools.feature.FeatureCollection;
import org.geotools.feature.FeatureCollections;
import org.postgresql.util.PSQLException;

import com.vividsolutions.jts.geom.Geometry;
import com.vividsolutions.jts.geom.GeometryFactory;
@@ -49,23 +58,18 @@
    static final LoggerFacade sLogger = new CommonsLoggingLogger(logger);
    static final GeometryFactory geometryFactory = new GeometryFactory();

    private String dataOut = null;
    private HashMap<FeatureType, ArrayList<String>> txFeaturesContext = new HashMap<FeatureType, ArrayList<String>>();

    private HashMap<String, ArrayList<Feature>> featuresContext = new HashMap<String, ArrayList<Feature>>();
    private HashMap<String, FeatureWriter> featuresWriterContext = new HashMap<String, FeatureWriter>();

    private PessimisticMapWrapper txFeaturesContext;
    private TreeMap<String, FeatureTypeBuilder> typeBuilders = new TreeMap<String, FeatureTypeBuilder>();
    private TreeMap<String, FeatureType> featureTypes = new TreeMap<String, FeatureType>();

    private TWD97GeometryConverterDecorator convertDecorator = null;
    private String featureBaseName = null;
    private boolean withIndex = false;
    private boolean dropTableMode = true;

    public GeneralDgnConvertPostGISJobContext(String dataPath, DataStore targetDataStore)
    {
        super(dataPath, targetDataStore);
        txFeaturesContext = new PessimisticMapWrapper(featuresContext, sLogger);
        convertDecorator = new TWD97GeometryConverterDecorator();
    }

@@ -98,15 +102,18 @@

            if (!txFeaturesContext.containsKey(feature.getFeatureType()))
            {
                txFeaturesContext.put(feature.getFeatureType(), new ArrayList<Feature>());
                txFeaturesContext.put(feature.getFeatureType(), new ArrayList<String>());
            }
            ArrayList<Feature> arrayList = (ArrayList<Feature>) txFeaturesContext.get(feature.getFeatureType());
            arrayList.add(feature);
            ArrayList<String> arrayList = txFeaturesContext.get(feature.getFeatureType());
            if (feature.getDefaultGeometry() != null && !feature.getDefaultGeometry().isEmpty())
                arrayList.add(makeInsertSql(feature, -1));
        } else
        {
            logger.info("Unknown Element :" + element.getType() + ", lv=" + element.getLevelIndex());
        }
    }

    private Transaction transaction;

    public void startTransaction()
    {
@@ -123,69 +130,69 @@
            logger.debug("Transaction is empty.");
        }

        if (!featuresContext.isEmpty())
        if (!txFeaturesContext.isEmpty())
        {
            updateDataStore();
        }

        txFeaturesContext.clear();
    }

    public void rollbackTransaction()
    {
        //txFeaturesContext.rollbackTransaction();
        if (!featuresContext.isEmpty())
        {
            updateDataStore();
        }
        txFeaturesContext.clear();
    }

    private void updateDataStore()
    {
        Iterator it = featuresContext.keySet().iterator();

        Iterator<FeatureType> it = txFeaturesContext.keySet().iterator();
        String currentStmt = null;
        try
        {
            while (it.hasNext())
            {
                FeatureType featureType = (FeatureType) it.next();
                FeatureType featureType = it.next();
                logger.debug("Begin Save into PostGIS:" + featureType.getTypeName());

                FeatureWriter writer;
                if (featuresWriterContext.containsKey(featureType.getTypeName()))
                ArrayList<String> stmtTexts = txFeaturesContext.get(featureType);
                Connection conn = getConnection();
                boolean autoCommit = conn.getAutoCommit();
                conn.setAutoCommit(true);

                for (String stmtText : stmtTexts)
                {
                    writer = featuresWriterContext.get(featureType.getTypeName());
                } else
                {
                    if (!isExistFeature(featureType))
                    currentStmt = stmtText;
                    Statement stmt = conn.createStatement();
                    try
                    {
                        targetDataStore.createSchema(featureType);
                        writer = targetDataStore.getFeatureWriter(featureType.getTypeName(),
                                Transaction.AUTO_COMMIT);
                    } else
                        stmt.execute(stmtText);
                    } catch (PSQLException e)
                    {
                        writer = targetDataStore.getFeatureWriterAppend(featureType.getTypeName(),
                                Transaction.AUTO_COMMIT);
                        if (currentStmt != null)
                        {
                            logger.error("Execute:" + currentStmt);
                        }
                        logger.error(e.getServerErrorMessage());
                        logger.error(e.getMessage(), e);
                    } finally {
                        stmt.close();
                    }
                    featuresWriterContext.put(featureType.getTypeName(), writer);
                    /*
                    if ((i % BATCHSIZE) != 0)
                    {
                        stmt.addBatch(stmtText);
                    } else {
                        stmt.addBatch(stmtText);
                        stmt.executeBatch();
                    }
                    i++;
                    */
                }

                ArrayList<Feature> features = featuresContext.get(featureType);
                Iterator itFeature = features.iterator();
                while (itFeature.hasNext())
                {
                    Feature feature = (Feature) itFeature.next();
                    ((SimpleFeature) writer.next()).setAttributes(feature.getAttributes(null));
                }
                //writer.close();
                conn.setAutoCommit(autoCommit);
                logger.debug("End Save into PostGIS:" + featureType.getTypeName());
            }
            featuresContext.clear();
        } catch (MalformedURLException e)
        {
            logger.error(e.getMessage(), e);
        } catch (IllegalAttributeException e)
        {
            logger.error(e.getMessage(), e);
        } catch (IOException e)
        } catch (SQLException e)
        {
            logger.error(e.getMessage(), e);
        }
@@ -193,13 +200,14 @@

    public void closeFeatureWriter() throws IOException
    {

        /*
        for (FeatureWriter featureWriter : this.featuresWriterContext.values())
        {
            featureWriter.close();
        }

        this.featuresWriterContext.clear();
        */
    }

    public FeatureType createPointFeatureElement(String featureName) throws SchemaException
@@ -208,6 +216,7 @@
        {
            FeatureTypeBuilder typeBuilder = FeatureTypeBuilderUtil.createNormalPointFeatureTypeBuilder(featureName);
            typeBuilders.put(featureName, typeBuilder);
            clearFeatureData(typeBuilder);
        }
        return typeBuilders.get(featureName).getFeatureType();
    }
@@ -218,6 +227,7 @@
        {
            FeatureTypeBuilder typeBuilder = FeatureTypeBuilderUtil.createNormalLineFeatureTypeBuilder(featureName);
            typeBuilders.put(featureName, typeBuilder);
            clearFeatureData(typeBuilder);
        }
        return typeBuilders.get(featureName).getFeatureType();
    }
@@ -228,6 +238,7 @@
        {
            FeatureTypeBuilder typeBuilder = FeatureTypeBuilderUtil.createNormalArcFeatureTypeBuilder(featureName);
            typeBuilders.put(featureName, typeBuilder);
            clearFeatureData(typeBuilder);
        }
        return typeBuilders.get(featureName).getFeatureType();
    }
@@ -238,6 +249,7 @@
        {
            FeatureTypeBuilder typeBuilder = FeatureTypeBuilderUtil.createNormalEllipseFeatureTypeBuilder(featureName);
            typeBuilders.put(featureName, typeBuilder);
            clearFeatureData(typeBuilder);
        }
        return typeBuilders.get(featureName).getFeatureType();
    }
@@ -253,6 +265,7 @@
            Geometry geom = convertDecorator.toGeometry(geometryFactory);
            double angle = textElement.getRotationAngle();
            String content = textElement.getText();
            content = content.replace('\u0000', ' ');
            angle = BigDecimal.valueOf(angle).setScale(3, RoundingMode.HALF_UP).doubleValue();
            if (geom != null)
            {
@@ -285,7 +298,8 @@
            {
                if (sb.length() != 0)
                    sb.append("\n");
                sb.append(text);
                String content = text.replace('\u0000', ' ');
                sb.append(content);
            }

            if (geom != null)
@@ -503,19 +517,73 @@
        return null;
    }


    public boolean isWithIndex()
    {
        return withIndex;
    }

    public void setWithIndex(boolean withIndex)
    {
        this.withIndex = withIndex;
    }

    public Log getLogger()
    {
        return logger;
    }

    public boolean isDropTableMode()
    {
        return dropTableMode;
    }

    public void setDropTableMode(boolean dropTableMode)
    {
        this.dropTableMode = dropTableMode;
    }

    protected void clearFeatureData(FeatureTypeBuilder typeBuilder) throws SchemaException
    {
        String featureName = typeBuilder.getName();
        if (isExistFeature(typeBuilder.getFeatureType()))
        {
            try
            {
                Connection conn = targetDataStore.getConnection(Transaction.AUTO_COMMIT);
                if (dropTableMode)
                {
                    dropGeometryColumn(conn, featureName,
                            typeBuilder.getFeatureType().getDefaultGeometry().getLocalName());
                    dropTable(conn, featureName);

                    ArrayList<String> schemaTexts = createSchemaTexts(typeBuilder.getFeatureType());
                    for (String stmtText : schemaTexts)
                    {
                        Statement stmt = conn.createStatement();
                        stmt.execute(stmtText);
                        stmt.close();
                    }
                } else {
                    deleteTable(conn, featureName);
                }
                conn.close();
            } catch (IOException e)
            {
                logger.warn(e.getMessage(), e);
            } catch (SQLException e)
            {
                logger.warn(e.getMessage(), e);
            }
        } else
        {
            try
            {
                Connection conn = targetDataStore.getConnection(Transaction.AUTO_COMMIT);
                ArrayList<String> schemaTexts = createSchemaTexts(typeBuilder.getFeatureType());
                for (String stmtText : schemaTexts)
                {
                    Statement stmt = conn.createStatement();
                    stmt.execute(stmtText);
                    stmt.close();
                }
                conn.close();
            } catch (IOException e)
            {
                logger.warn(e.getMessage(), e);
            } catch (SQLException e)
            {
                logger.warn(e.getMessage(), e);
            }
        }
    }
}

 xdgnjobs/ximple-spatialjob/src/main/java/com/ximple/eofms/jobs/context/postgis/IndexDgnConvertPostGISJobContext.java

@@ -3,7 +3,9 @@
import java.io.IOException;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.net.MalformedURLException;
import java.sql.Connection;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
@@ -11,19 +13,16 @@

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.commons.transaction.memory.PessimisticMapWrapper;
import org.apache.commons.transaction.util.CommonsLoggingLogger;
import org.apache.commons.transaction.util.LoggerFacade;
import org.geotools.data.DataStore;
import org.geotools.data.FeatureWriter;
import org.geotools.data.Transaction;
import org.geotools.data.DefaultTransaction;
import org.geotools.feature.Feature;
import org.geotools.feature.FeatureType;
import org.geotools.feature.FeatureTypeBuilder;
import org.geotools.feature.IllegalAttributeException;
import org.geotools.feature.SchemaException;
import org.geotools.feature.SimpleFeature;
import org.postgresql.util.PSQLException;

import com.vividsolutions.jts.geom.Coordinate;
import com.vividsolutions.jts.geom.Envelope;
@@ -46,23 +45,19 @@
    static final LoggerFacade sLogger = new CommonsLoggingLogger(logger);
    static final GeometryFactory geometryFactory = new GeometryFactory();
    TWD97GeometryConverterDecorator convertDecorator = new TWD97GeometryConverterDecorator();
    public static final String SHPOUTPATH = "shpout";

    private String dataOut = null;
    private HashMap<FeatureType, ArrayList<String>> txFeaturesContext = new HashMap<FeatureType, ArrayList<String>>();

    private HashMap<String, ArrayList<Feature>> featuresContext = new HashMap<String, ArrayList<Feature>>();
    private HashMap<String, FeatureWriter> featuresWriterContext = new HashMap<String, FeatureWriter>();

    private PessimisticMapWrapper txFeaturesContext;
    private FeatureTypeBuilder typeBuilderPnt = null;
    private FeatureTypeBuilder typeBuilderRect = null;
    private FeatureType featureType = null;
    private FeatureType featureType2 = null;

    private boolean dropTableMode = true;

    public IndexDgnConvertPostGISJobContext(String dataPath, DataStore targetDataStore)
    {
        super(dataPath, targetDataStore);
        txFeaturesContext = new PessimisticMapWrapper(featuresContext, sLogger);
    }

    public void putFeatureCollection(Element element) throws IllegalAttributeException, SchemaException
@@ -82,10 +77,10 @@

        if (!txFeaturesContext.containsKey(feature.getFeatureType()))
        {
            txFeaturesContext.put(feature.getFeatureType(), new ArrayList());
            txFeaturesContext.put(feature.getFeatureType(), new ArrayList<String>());
        }
        ArrayList arrayList = (ArrayList) txFeaturesContext.get(feature.getFeatureType());
        arrayList.add(feature);
        ArrayList<String> arrayList = txFeaturesContext.get(feature.getFeatureType());
        arrayList.add(makeInsertSql(feature, -1));

        feature = createFeature2((TextElement) element);
        if (feature == null)
@@ -97,18 +92,14 @@

        if (!txFeaturesContext.containsKey(feature.getFeatureType()))
        {
            txFeaturesContext.put(feature.getFeatureType(), new ArrayList());
            txFeaturesContext.put(feature.getFeatureType(), new ArrayList<String>());
        }
        arrayList = (ArrayList) txFeaturesContext.get(feature.getFeatureType());
        arrayList.add(feature);
        arrayList = txFeaturesContext.get(feature.getFeatureType());
        arrayList.add(makeInsertSql(feature, -1));
    }

    private Transaction transaction;

    public void startTransaction()
    {
        if (transaction == null)
            transaction = new DefaultTransaction(getClass().getName());
    }

    public void commitTransaction()
@@ -116,97 +107,91 @@
        if (!txFeaturesContext.isEmpty())
        {
            logger.debug("Transaction size = " + txFeaturesContext.size());
            //txFeaturesContext.commitTransaction();
        } else
        {
            logger.debug("Transaction is empty.");
        }

        if (!featuresContext.isEmpty())
        if (!txFeaturesContext.isEmpty())
        {
            updateDataStore();
        }

        try
        {
            transaction.commit();
            transaction.close();
        } catch (IOException e)
        {
            logger.warn(e.getMessage(), e);
        } finally
        {
            transaction = null;
        }
        txFeaturesContext.clear();
    }

    public void rollbackTransaction()
    {
        //txFeaturesContext.rollbackTransaction();
        if (!featuresContext.isEmpty())
        {
            updateDataStore();
        }
        
        try
        {
            transaction.rollback();
            transaction.close();
        } catch (IOException e)
        {
            logger.warn(e.getMessage(), e);
        } finally
        {
            transaction = null;
        }
        txFeaturesContext.clear();
    }

    private void updateDataStore()
    {
        Iterator it = featuresContext.keySet().iterator();

        Iterator<FeatureType> it = txFeaturesContext.keySet().iterator();
        String currentStmt = null;
        try
        {
            while (it.hasNext())
            {
                FeatureType featureType = (FeatureType) it.next();
                FeatureType featureType = it.next();
                logger.debug("Begin Save PostGIS:" + featureType.getTypeName());

                FeatureWriter writer;
                if (featuresWriterContext.containsKey(featureType.getTypeName()))
                ArrayList<String> stmtTexts = txFeaturesContext.get(featureType);
                Connection conn = getConnection();
                boolean autoCommit = conn.getAutoCommit();
                conn.setAutoCommit(true);
                // conn.setAutoCommit(false);
                // Statement stmt = conn.createStatement();
                // int i = 0;
                for (String stmtText : stmtTexts)
                {
                    writer = featuresWriterContext.get(featureType.getTypeName());
                } else
                {
                    if (!isExistFeature(featureType))
                    currentStmt = stmtText;
                    Statement stmt = conn.createStatement();
                    try
                    {
                        targetDataStore.createSchema(featureType);
                        writer = targetDataStore.getFeatureWriter(featureType.getTypeName(), Transaction.AUTO_COMMIT);
                    } else
                        stmt.execute(stmtText);
                    } catch (PSQLException e)
                    {
                        writer = targetDataStore.getFeatureWriterAppend(featureType.getTypeName(), Transaction.AUTO_COMMIT);
                        if (currentStmt != null)
                        {
                            logger.error("Execute:" + currentStmt);
                        }
                        logger.error(e.getServerErrorMessage());
                        logger.error(e.getMessage(), e);
                    } finally {
                        stmt.close();
                    }
                    featuresWriterContext.put(featureType.getTypeName(), writer);
                    /*
                    if ((i % BATCHSIZE) != 0)
                    {
                        stmt.addBatch(stmtText);
                    } else {
                        stmt.addBatch(stmtText);
                        stmt.executeBatch();
                    }
                    i++;
                    */
                }

                ArrayList<Feature> features = featuresContext.get(featureType);
                for (Feature feature1 : features)
                /*
                if ((i % BATCHSIZE) != 0)
                {
                    ((SimpleFeature) writer.next()).setAttributes(feature1.getAttributes(null));
                    stmt.executeBatch();
                }
                //writer.close();
                writer.write();

                stmt.close();
                stmtTexts.clear();
                */
                conn.setAutoCommit(autoCommit);
                logger.debug("End Save PostGIS:" + featureType.getTypeName());
            }
            featuresContext.clear();
        } catch (MalformedURLException e)
        } catch (PSQLException e)
        {
            if (currentStmt != null)
            {
                logger.error("Execute:" + currentStmt);
            }
            logger.error(e.getServerErrorMessage());
            logger.error(e.getMessage(), e);
        } catch (IllegalAttributeException e)
        {
            logger.error(e.getMessage(), e);
        } catch (IOException e)
        } catch (SQLException e)
        {
            logger.error(e.getMessage(), e);
        }
@@ -214,13 +199,14 @@

    public void closeFeatureWriter() throws IOException
    {

        /*
        for (FeatureWriter featureWriter : this.featuresWriterContext.values())
        {
            featureWriter.close();
        }

        this.featuresWriterContext.clear();
        */
    }

    public FeatureType createFeatureElement(String featureName) throws SchemaException
@@ -228,6 +214,56 @@
        if (typeBuilderRect == null)
        {
            typeBuilderRect = FeatureTypeBuilderUtil.createNormalIndexFeatureTypeBuilder(featureName);
            if (isExistFeature(typeBuilderRect.getFeatureType()))
            {
                try
                {
                    Connection conn = targetDataStore.getConnection(Transaction.AUTO_COMMIT);
                    if (dropTableMode)
                    {
                        dropGeometryColumn(conn, featureName,
                                typeBuilderRect.getFeatureType().getDefaultGeometry().getLocalName());
                        dropTable(conn, featureName);
                        ArrayList<String> schemaTexts = createSchemaTexts(typeBuilderRect.getFeatureType());
                        for (String stmtText : schemaTexts)
                        {
                            Statement stmt = conn.createStatement();
                            stmt.execute(stmtText);
                            stmt.close();
                        }
                    } else
                    {
                        deleteTable(conn, featureName);
                    }
                    conn.close();
                } catch (IOException e)
                {
                    logger.warn(e.getMessage(), e);
                } catch (SQLException e)
                {
                    logger.warn(e.getMessage(), e);
                }
            } else
            {
                try
                {
                    Connection conn = targetDataStore.getConnection(Transaction.AUTO_COMMIT);
                    ArrayList<String> schemaTexts = createSchemaTexts(typeBuilderRect.getFeatureType());
                    for (String stmtText : schemaTexts)
                    {
                        Statement stmt = conn.createStatement();
                        stmt.execute(stmtText);
                        stmt.close();
                    }
                    conn.close();
                } catch (IOException e)
                {
                    logger.warn(e.getMessage(), e);
                } catch (SQLException e)
                {
                    logger.warn(e.getMessage(), e);
                }
            }
        }
        return typeBuilderRect.getFeatureType();
    }
@@ -237,6 +273,57 @@
        if (typeBuilderPnt == null)
        {
            typeBuilderPnt = FeatureTypeBuilderUtil.createNormalIndexTextFeatureTypeBuilder(featureName);
            if (isExistFeature(typeBuilderPnt.getFeatureType()))
            {
                try
                {
                    Connection conn = targetDataStore.getConnection(Transaction.AUTO_COMMIT);
                    if (dropTableMode)
                    {
                        dropGeometryColumn(conn, featureName,
                                typeBuilderPnt.getFeatureType().getDefaultGeometry().getLocalName());
                        dropTable(conn, featureName);

                        ArrayList<String> schemaTexts = createSchemaTexts(typeBuilderPnt.getFeatureType());
                        for (String stmtText : schemaTexts)
                        {
                            Statement stmt = conn.createStatement();
                            stmt.execute(stmtText);
                            stmt.close();
                        }
                    } else
                    {
                        deleteTable(conn, featureName);
                    }
                    conn.close();
                } catch (IOException e)
                {
                    logger.warn(e.getMessage(), e);
                } catch (SQLException e)
                {
                    logger.warn(e.getMessage(), e);
                }
            } else
            {
                try
                {
                    Connection conn = targetDataStore.getConnection(Transaction.AUTO_COMMIT);
                    ArrayList<String> schemaTexts = createSchemaTexts(typeBuilderPnt.getFeatureType());
                    for (String stmtText : schemaTexts)
                    {
                        Statement stmt = conn.createStatement();
                        stmt.execute(stmtText);
                        stmt.close();
                    }
                    conn.close();
                } catch (IOException e)
                {
                    logger.warn(e.getMessage(), e);
                } catch (SQLException e)
                {
                    logger.warn(e.getMessage(), e);
                }
            }
        }
        return typeBuilderPnt.getFeatureType();
    }
@@ -350,4 +437,18 @@
    {
        return logger;
    }

    public boolean isDropTableMode()
    {
        return dropTableMode;
    }

    public void setDropTableMode(boolean dropTableMode)
    {
        this.dropTableMode = dropTableMode;
    }

    public void clearOutputDatabase()
    {
    }
}

 xdgnjobs/ximple-spatialjob/src/main/java/com/ximple/eofms/util/FeatureTypeBuilderUtil.java

@@ -4,30 +4,34 @@
import org.geotools.feature.FeatureTypeBuilder;

import com.vividsolutions.jts.geom.Geometry;
import com.vividsolutions.jts.geom.GeometryFactory;
import com.vividsolutions.jts.geom.Coordinate;

public final class FeatureTypeBuilderUtil
{
    protected static GeometryFactory _geomFactory = new GeometryFactory();

    public static FeatureTypeBuilder createNormalPointFeatureTypeBuilder(String featureName)
    {
        FeatureTypeBuilder typeBuilder = FeatureTypeBuilder.newInstance(featureName);
        typeBuilder.addType(AttributeTypeFactory.newAttributeType("geom", Geometry.class, false));
        typeBuilder.addType(AttributeTypeFactory.newAttributeType("symcolor", String.class, false, 12));
        typeBuilder.addType(AttributeTypeFactory.newAttributeType("font", Short.class, false));
        typeBuilder.addType(AttributeTypeFactory.newAttributeType("just", Short.class, false));
        typeBuilder.addType(AttributeTypeFactory.newAttributeType("height", Float.class, false));
        typeBuilder.addType(AttributeTypeFactory.newAttributeType("width", Float.class, false));
        typeBuilder.addType(AttributeTypeFactory.newAttributeType("angle", Float.class, false));
        typeBuilder.addType(AttributeTypeFactory.newAttributeType("context", String.class, true, 254));
        typeBuilder.addType(AttributeTypeFactory.newAttributeType("geom", Geometry.class, true));
        typeBuilder.addType(AttributeTypeFactory.newAttributeType("symcolor", String.class, false, 12, ""));
        typeBuilder.addType(AttributeTypeFactory.newAttributeType("font", Short.class, false, 1, (short) 0));
        typeBuilder.addType(AttributeTypeFactory.newAttributeType("just", Short.class, false, 1, (short) 0));
        typeBuilder.addType(AttributeTypeFactory.newAttributeType("height", Float.class, false, 1, (float) 1.0));
        typeBuilder.addType(AttributeTypeFactory.newAttributeType("width", Float.class, false, 1, (float) 1.0));
        typeBuilder.addType(AttributeTypeFactory.newAttributeType("angle", Float.class, false, 1, (float) 0.0));
        typeBuilder.addType(AttributeTypeFactory.newAttributeType("context", String.class, false, 254, ""));
        return typeBuilder;
    }

    public static FeatureTypeBuilder createNormalLineFeatureTypeBuilder(String featureName)
    {
        FeatureTypeBuilder typeBuilder = FeatureTypeBuilder.newInstance(featureName);
        typeBuilder.addType(AttributeTypeFactory.newAttributeType("geom", Geometry.class, false));
        typeBuilder.addType(AttributeTypeFactory.newAttributeType("symcolor", String.class, false, 12));
        typeBuilder.addType(AttributeTypeFactory.newAttributeType("symweight", Short.class, false));
        typeBuilder.addType(AttributeTypeFactory.newAttributeType("symstyle", Short.class, false));
        typeBuilder.addType(AttributeTypeFactory.newAttributeType("geom", Geometry.class, true));
        typeBuilder.addType(AttributeTypeFactory.newAttributeType("symcolor", String.class, false, 12, ""));
        typeBuilder.addType(AttributeTypeFactory.newAttributeType("symweight", Short.class, false, 1, (short) 0));
        typeBuilder.addType(AttributeTypeFactory.newAttributeType("symstyle", Short.class, false, 1, (short) 0));
        return typeBuilder;
    }

@@ -60,15 +64,15 @@
    public static FeatureTypeBuilder createNormalIndexFeatureTypeBuilder(String featureName)
    {
        FeatureTypeBuilder typeBuilder = FeatureTypeBuilder.newInstance(featureName);
        typeBuilder.addType(AttributeTypeFactory.newAttributeType("geom", Geometry.class, false));
        typeBuilder.addType(AttributeTypeFactory.newAttributeType("x1", Double.class, false));
        typeBuilder.addType(AttributeTypeFactory.newAttributeType("y1", Double.class, false));
        typeBuilder.addType(AttributeTypeFactory.newAttributeType("x2", Double.class, false));
        typeBuilder.addType(AttributeTypeFactory.newAttributeType("y2", Double.class, false));
        typeBuilder.addType(AttributeTypeFactory.newAttributeType("tpclid", String.class, false, 12));
        typeBuilder.addType(AttributeTypeFactory.newAttributeType("symcolor", String.class, false, 12));
        typeBuilder.addType(AttributeTypeFactory.newAttributeType("symweight", Short.class, false));
        typeBuilder.addType(AttributeTypeFactory.newAttributeType("symstyle", Short.class, false));
        typeBuilder.addType(AttributeTypeFactory.newAttributeType("geom", Geometry.class, true));
        typeBuilder.addType(AttributeTypeFactory.newAttributeType("x1", Double.class, false, 1, 0.0));
        typeBuilder.addType(AttributeTypeFactory.newAttributeType("y1", Double.class, false, 1, 0.0));
        typeBuilder.addType(AttributeTypeFactory.newAttributeType("x2", Double.class, false, 1, 0.0));
        typeBuilder.addType(AttributeTypeFactory.newAttributeType("y2", Double.class, false, 1, 0.0));
        typeBuilder.addType(AttributeTypeFactory.newAttributeType("tpclid", String.class, false, 12, ""));
        typeBuilder.addType(AttributeTypeFactory.newAttributeType("symcolor", String.class, false, 12, ""));
        typeBuilder.addType(AttributeTypeFactory.newAttributeType("symweight", Short.class, false, 1, (short) 0));
        typeBuilder.addType(AttributeTypeFactory.newAttributeType("symstyle", Short.class, false, 1, (short) 0));
        return typeBuilder;
    }

@@ -76,15 +80,15 @@
    {
        FeatureTypeBuilder typeBuilder = FeatureTypeBuilder.newInstance(featureName);
        typeBuilder = FeatureTypeBuilder.newInstance(featureName);
        typeBuilder.addType(AttributeTypeFactory.newAttributeType("geom", Geometry.class, false));
        typeBuilder.addType(AttributeTypeFactory.newAttributeType("symcolor", String.class, false, 12));
        typeBuilder.addType(AttributeTypeFactory.newAttributeType("symweight", Short.class, false));
        typeBuilder.addType(AttributeTypeFactory.newAttributeType("symstyle", Short.class, false));
        typeBuilder.addType(AttributeTypeFactory.newAttributeType("just", Short.class, false));
        typeBuilder.addType(AttributeTypeFactory.newAttributeType("height", Float.class, false));
        typeBuilder.addType(AttributeTypeFactory.newAttributeType("width", Float.class, false));
        typeBuilder.addType(AttributeTypeFactory.newAttributeType("angle", Float.class, false));
        typeBuilder.addType(AttributeTypeFactory.newAttributeType("tpclid", String.class, false, 12));
        typeBuilder.addType(AttributeTypeFactory.newAttributeType("geom", Geometry.class, true));
        typeBuilder.addType(AttributeTypeFactory.newAttributeType("symcolor", String.class, false, 12, ""));
        typeBuilder.addType(AttributeTypeFactory.newAttributeType("symweight", Short.class, false, 1, (short) 0));
        typeBuilder.addType(AttributeTypeFactory.newAttributeType("symstyle", Short.class, false, 1, (short) 0));
        typeBuilder.addType(AttributeTypeFactory.newAttributeType("just", Short.class, false, 1, (short) 0));
        typeBuilder.addType(AttributeTypeFactory.newAttributeType("height", Float.class, false, 1, (float) 0.0));
        typeBuilder.addType(AttributeTypeFactory.newAttributeType("width", Float.class, false, 1, (float) 0.0));
        typeBuilder.addType(AttributeTypeFactory.newAttributeType("angle", Float.class, false, 1, (float) 0.0));
        typeBuilder.addType(AttributeTypeFactory.newAttributeType("tpclid", String.class, false, 12, ""));
        return typeBuilder;
    }