gvSIG data provider for Sqlite

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

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">

    <modelVersion>4.0.0</modelVersion>

    <artifactId>org.gvsig.spatialite</artifactId>

    <version>1.0.40</version>

    <packaging>pom</packaging>

    <name>${project.artifactId}</name>

    <description>SpatiaLite support for DAL and gvSIG</description>

    <parent>

        <groupId>org.gvsig</groupId>

        <artifactId>org.gvsig.desktop</artifactId>

        <version>2.0.259</version>

    </parent>

    <url>https://devel.gvsig.org/redmine/projects/gvsig-sqlite</url>

    <scm>

        <connection>scm:svn:https://devel.gvsig.org/svn/gvsig-sqlite/tags/org.gvsig.spatialite-1.0.40</connection>

        <developerConnection>scm:svn:https://devel.gvsig.org/svn/gvsig-sqlite/tags/org.gvsig.spatialite-1.0.40</developerConnection>

        <url>https://devel.gvsig.org/redmine/projects/gvsig-sqlite/repository/show/tags/org.gvsig.spatialite-1.0.40</url>

    </scm>

    <repositories>

        <repository>

            <id>gvsig-public-http-repository</id>

            <name>gvSIG maven public HTTP repository</name>

            <url>http://devel.gvsig.org/m2repo/j2se</url>

            <releases>

                <enabled>true</enabled>

                <updatePolicy>daily</updatePolicy>

                <checksumPolicy>warn</checksumPolicy>

            </releases>

            <snapshots>

                <enabled>true</enabled>

                <updatePolicy>daily</updatePolicy>

                <checksumPolicy>warn</checksumPolicy>

            </snapshots>

        </repository>

    </repositories>

    <build>

        <plugins>

            <plugin>

                <groupId>org.apache.maven.plugins</groupId>

                <artifactId>maven-release-plugin</artifactId>

                <configuration>

                    <tagBase>https://devel.gvsig.org/svn/gvsig-sqlite/tags/</tagBase>

                </configuration>

            </plugin>                     

        </plugins>

    </build>

    <dependencyManagement>

        <dependencies>

            <dependency>

                <groupId>org.gvsig</groupId>

                <artifactId>org.gvsig.spatialite.provider</artifactId>

                <version>1.0.40</version>

            </dependency>

            <dependency>

                <groupId>org.gvsig</groupId>

                <artifactId>org.gvsig.spatialite.app.mainplugin.common</artifactId>

                <version>1.0.40</version>

                <type>zip</type>

            </dependency>

            <dependency>

                <groupId>org.xerial</groupId>

                <artifactId>sqlite-jdbc</artifactId>

                <version>3.21.0</version>

            </dependency>

        </dependencies>

    </dependencyManagement>

    <modules>

        <module>org.gvsig.spatialite.app</module>

        <module>org.gvsig.spatialite.provider</module>

    </modules>

</project>

org.gvsig.spatialite.dal.SpatiaLiteLibrary

<?xml version="1.0"?>

<definitions>

  <version>1.0.0</version>

  <classes>

    <class name="SpatiaLite" namespace="Metadata">

      <extends>

      	<class name="JDBC2" namespace="Metadata"/>

      </extends>

      <description>Metadata for SpatiaLite</description>

      <fields>

      </fields>

    </class>

  </classes>

</definitions>  

<?xml version="1.0"?>

<definitions>

  <version>1.0.0</version>

  <classes>

    <class name="SpatiaLiteResourceParameters">

      <extends>

        <class>JDBC2ResourceParameters</class>

      </extends>

      <fields>

        <field name="JDBCDriverClass" type="string" mandatory="true"

          defaultValue="org.sqlite.JDBC" group="Advanced">

          <description>JDBC driver class for SpatiaLite</description>

        </field>        

        <field name="url_format" type="string" mandatory="true"

          defaultValue="jdbc:sqlite:%s" group="Advanced">

          <description></description>

        </field>

        <field name="port" type="integer" mandatory="false"

          defaultValue="0" group="Connection" hidden="true">

          <description></description>

        </field>

        <field name="host" type="string" mandatory="false" 

            defaultValue="" group="Connection" hidden="true">

          <description></description>

        </field>

        <field name="dbname" type="string" mandatory="false" hidden="true" defaultValue="" group="Basic">

          <description></description>

        </field>

        <field name="schema" type="string" mandatory="false" hidden="true" defaultValue="" group="Basic">

          <description></description>

        </field>

        <field name="catalog" type="string" mandatory="false" hidden="true" defaultValue="" group="Basic">

          <description></description>

        </field>

        <field name="url" type="string" mandatory="false" hidden="true" defaultValue="" group="Basic">

          <description></description>

        </field>

        <field name="dbuser" type="string" mandatory="false" defaultValue="" group="Basic">

          <description></description>

        </field>

        <field name="password" type="string" mandatory="false" defaultValue="" group="Basic">

          <description></description>

        </field>           

        <field name="database_file" label="Database file" type="file" mandatory="true" defaultValue="" group="Basic">

          <description></description>

        </field>            

        <field name="enable_shared_cache" label="Enable shared cache" type="boolean" mandatory="false" defaultValue="true" group="Advanced">

          <description></description>

        </field>

        <field name="enable_load_extension" label="Enable load extension" type="boolean" mandatory="false" defaultValue="true" group="Advanced">

          <description></description>

        </field>

        <field name="enable_spatialite" label="Enable spatialite" type="boolean" mandatory="false" defaultValue="true" group="Advanced">

          <description></description>

        </field>

      </fields>

    </class>

    <class name="SpatiaLiteStoreParameters">

      <extends>

        <class>JDBC2StoreParameters</class>

        <class>SpatiaLiteResourceParameters</class>

      </extends>

      <fields/>

    </class>

    <class name="SpatiaLiteNewStoreParameters">

      <extends>

        <class>JDBC2NewStoreParameters</class>

        <class>SpatiaLiteResourceParameters</class>

      </extends>

      <fields/>

    </class>

    <class name="SpatiaLiteServerExplorerParameters">

      <extends>

        <class>SpatiaLiteResourceParameters</class>

        <class>JDBC2ServerExplorerParameters</class>

      </extends>

      <fields/>

    </class>

  </classes>

</definitions>  

<?xml version="1.0"?>

<definitions>

  <version>1.0.0</version>

  <classes>

    <class name="JDBC2">

      <extends>

      </extends>

      <fields>

        <field name="function_ST_AsWKB" type="string" group="functions" 

          defaultValue="ST_AsWKB({0})" >

          <description></description>

        </field>

        <field name="function_ST_envelope" type="string" group="functions" 

          defaultValue="ST_envelope({0})" >

          <description></description>

        </field>

        <field name="function_ST_Extent" type="string" group="functions" 

          defaultValue="ST_Extent({0})" >

          <description></description>

        </field>

        <field name="function_ST_intersects" type="string" group="functions" 

          defaultValue="ST_intersects({0}, {1})" >

          <description></description>

        </field>

        <field name="function_ST_GeomFromText" type="string" group="functions" 

          defaultValue="ST_GeomFromText({0}, {1})" >

          <description></description>

        </field>

        <field name="function_ST_GeomFromWKB" type="string" group="functions" 

          defaultValue="ST_GeomFromWKB({0}, {1})" >

          <description></description>

        </field>

        <field name="function_ST_GeomFromEWKB" type="string" group="functions" 

          defaultValue="ST_GeomFromEWKB({0}, {1})" >

          <description></description>

        </field>

        <field name="function_current_schema" type="string" group="functions" 

          defaultValue="current_schema()" >

          <description></description>

        </field>

        <field name="function_lcase" type="string" group="functions" 

          defaultValue="LCASE({0})" >

          <description></description>

        </field>

        <field name="function_count" type="string" group="functions" 

          defaultValue="count({0})" >

          <description></description>

        </field>

        <field name="function_crs" type="string" group="functions" 

          defaultValue="{0}" >

          <description>Use {0} for the abbreviature, {1} for the autority name and {2} for the autority code</description>

        </field>

        <!-- operators -->

        <field name="operator_isnull" type="string" group="operators" 

          defaultValue="{0} is null" >

          <description></description>

        </field>

        <field name="operator_eq" type="string" group="operators" 

          defaultValue="{0} = {1}" >

          <description></description>

        </field>

        <field name="operator_neq" type="string" group="operators" 

          defaultValue="{0} <> {1}" >

          <description></description>

        </field>

        <field name="operator_lt" type="string" group="operators" 

          defaultValue="{0} < {1}" >

          <description></description>

        </field>

        <field name="operator_le" type="string" group="operators" 

          defaultValue="{0} <= {1}" >

          <description></description>

        </field>

        <field name="operator_gt" type="string" group="operators" 

          defaultValue="{0} > {1}" >

          <description></description>

        </field>

        <field name="operator_ge" type="string" group="operators" 

          defaultValue="{0} >= {1}" >

          <description></description>

        </field>

        <field name="operator_and" type="string" group="operators" 

          defaultValue="{0} AND {1}" >

          <description></description>

        </field>

        <field name="operator_or" type="string" group="operators" 

          defaultValue="{0} OR {1}" >

          <description></description>

        </field>

        <field name="operator_like" type="string" group="operators" 

          defaultValue="{0} LIKE {1}" >

          <description></description>

        </field>

        <field name="operator_ilike" type="string" group="operators" 

          defaultValue="{0} ILIKE {1}" >

          <description></description>

        </field>

        <!-- properties -->

        <field name="AllowAutomaticValues" type="boolean" group="properties" 

          defaultValue="true" >

          <description></description>

        </field>

        <field name="QuoteForStrings" type="string" group="properties" 

          defaultValue="'" >

          <description></description>

        </field>

        <field name="QuoteForIdentifiers" type="string" group="properties" 

          defaultValue="" >

          <description></description>

        </field>

        <field name="GeometrySupportType" type="string" group="properties" 

            defaultValue="WKB" >

            <description></description>

            <availableValues>

                <value label="WKT">WKT</value>

                <value label="WKB">WKB</value>

                <value label="EWKB">EWKB</value>

            </availableValues>          

        </field>

      </fields>

    </class>

    <class name="SpatiaLite">

      <extends>

          <class>JDBC2</class>

      </extends>

      <fields>

        <field name="function_ST_AsWKB" type="string" group="functions" 

          defaultValue="({0}).STAsWKB" >

          <description></description>

        </field>

        <field name="function_ST_envelope" type="string" group="functions" 

          defaultValue="({0}).STEnvelope" >

          <description></description>

        </field>

        <field name="function_ST_Extent" type="string" group="functions" 

          defaultValue="({0}).STEnvelope" >

          <description></description>

        </field>

        <field name="function_ST_intersects" type="string" group="functions" 

          defaultValue="({0}).STIntersects({1})" >

          <description></description>

        </field>

        <field name="function_ST_GeomFromText" type="string" group="functions" 

          defaultValue="geometry::STGeomFromText({0}, {1})" >

          <description></description>

        </field>

        <field name="function_ST_GeomFromWKB" type="string" group="functions" 

          defaultValue="geometry::STGeomFromWKB({0}, {1})" >

          <description></description>

        </field>

        <field name="function_ST_GeomFromEWKB" type="string" group="functions" 

          defaultValue="geometry::STGeomFromWKB({0}, {1})" >

          <description></description>

        </field>

        <field name="function_current_schema" type="string" group="functions" 

          defaultValue="current_schema()" >

          <description></description>

        </field>

        <field name="function_crs" type="string" group="functions" 

          defaultValue="{2}" >

          <description>Use {0} for the abbreviature, {1} for the autority name and {2} for the autority code</description>

        </field>

        <field name="function_lcase" type="string" group="functions" 

          defaultValue="LOWER({0})" >

          <description></description>

        </field>

        <!-- operators -->

        <field name="operator_ilike" type="string" group="operators" 

          defaultValue="{0} ILIKE {1}" >

          <description></description>

        </field>

  </classes>

</definitions>  

package org.gvsig.spatialite.dal;

import org.apache.commons.io.FilenameUtils;

import org.gvsig.fmap.dal.DataStore;

import org.gvsig.fmap.dal.exception.InitializeException;

import org.gvsig.fmap.dal.spi.DataServerExplorerProviderServices;

import org.gvsig.fmap.dal.spi.ZipResourcesStorage;

import org.gvsig.fmap.dal.store.jdbc.JDBCServerExplorerParameters;

import org.gvsig.fmap.dal.store.jdbc2.JDBCHelper;

import org.gvsig.fmap.dal.store.jdbc2.spi.JDBCServerExplorerBase;

import org.gvsig.tools.resourcesstorage.EmptyResourcesStorage;

import org.gvsig.tools.resourcesstorage.ResourcesStorage;

/**

 *

 * @author jjdelcerro

 */

@SuppressWarnings("UseSpecificCatch")

public class SpatiaLiteExplorer extends JDBCServerExplorerBase {

    public SpatiaLiteExplorer(JDBCServerExplorerParameters parameters, DataServerExplorerProviderServices services, JDBCHelper helper) throws InitializeException {

        super(parameters, services, helper);

    }

    @Override

    public SpatiaLiteExplorerParameters getParameters() {

        return (SpatiaLiteExplorerParameters) super.getParameters(); 

    }

    @Override

    public ResourcesStorage getResourcesStorage(DataStore dataStore) {

        ResourcesStorage ress = super.getResourcesStorage(dataStore);

        if( ress instanceof EmptyResourcesStorage ) {

            String zipPath = this.getParameters().getFile().getAbsolutePath();

            String zipPathName = FilenameUtils.removeExtension(zipPath);

            ress = new ZipResourcesStorage(zipPathName, dataStore.getName());

        }

        return ress;

    }

}

/* gvSIG. Geographic Information System of the Valencian Government

*

* Copyright (C) 2007-2008 Infrastructures and Transports Department

* of the Valencian Government (CIT)

*

* This program is free software; you can redistribute it and/or

* modify it under the terms of the GNU General Public License

* as published by the Free Software Foundation; either version 2

* of the License, or (at your option) any later version.

*

* This program is distributed in the hope that it will be useful,

* but WITHOUT ANY WARRANTY; without even the implied warranty of

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

* GNU General Public License for more details.

*

* You should have received a copy of the GNU General Public License

* along with this program; if not, write to the Free Software

* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

* MA  02110-1301, USA.

*

 */

package org.gvsig.spatialite.dal;

import java.io.File;

import java.util.Properties;

import org.gvsig.fmap.dal.exception.ValidateDataParametersException;

import org.gvsig.fmap.dal.store.jdbc.JDBCStoreParameters;

public class SpatiaLiteStoreParameters extends JDBCStoreParameters implements SpatiaLiteConnectionParameters {

    private final SpatiaLiteConnectionParametersHelper helper;

    public SpatiaLiteStoreParameters() {

        super(

                SpatiaLiteLibrary.NAME + "StoreParameters",

                SpatiaLiteLibrary.NAME

        );

        this.helper = new SpatiaLiteConnectionParametersHelper(this);

    }

    @Override

    public String getUrl() {

        return this.helper.getUrl();

    }

    @Override

    public void validate() throws ValidateDataParametersException {

        this.helper.validate();

        super.validate();

    }

    @Override

    public boolean getEnableSpatiaLite() {

        return this.helper.getEnableSpatiaLite();

    }

    @Override

    public boolean getEnableLoadExtension() {

        return this.helper.getEnableLoadExtension();

    }

    @Override

    public boolean getEnableSharedCache() {

        return this.helper.getEnableSharedCache();

    }

    @Override

    public void setEnableSpatiaLite(boolean v) {

        this.helper.setEnableSpatiaLite(v);

    }

    @Override

    public void setEnableLoadExtension(boolean v) {

        this.helper.setEnableLoadExtension(v);

    }

    @Override

    public void setEnableSharedCache(boolean v) {

        this.helper.setEnableSharedCache(v);

    }

    @Override

    public Properties getProperties() {

        return this.helper.getProperties();

    }

    @Override

    public File getFile() {

        return this.helper.getFile();

    }

    @Override

    public void setFile(File database) {

        this.helper.setFile(database);

    }

    @Override

    public String getURLFormat() {

        return this.helper.getURLFormat();

    }

}

package org.gvsig.spatialite.dal;

import java.io.File;

import java.sql.Connection;

import java.sql.DriverManager;

import java.sql.SQLException;

import java.sql.Statement;

import java.util.HashMap;

import java.util.Map;

import org.apache.commons.io.FilenameUtils;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.fmap.dal.store.jdbc2.JDBCUtils;

import static org.gvsig.spatialite.dal.SpatiaLiteHelper.LOGGER;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.sqlite.SQLiteConfig;

/**

 *

 * @author jjdelcerro

 */

@SuppressWarnings("UseSpecificCatch")

public class SpatiaLiteConnections {

    private static final Logger LOGGER = LoggerFactory.getLogger(SpatiaLiteConnections.class);

    public static final String SPATIALITE_JDBC_DRIVER = "org.sqlite.JDBC";

    public static final String URL_FORMAT = "jdbc:sqlite:%s";

    private static class ConnectionEntry {

        public ConnectionEntry(File f) {

            this.f = f;

            this.refCount = 1;

            this.metadataInitialized = false;

        }

        private Connection conn;

        private File f;

        private int refCount;

        private boolean metadataInitialized;

    }

    private static Map<File, ConnectionEntry> CONNECTIONS;

    public static synchronized Connection getConnection(File f) {

        if (f == null) {

            LOGGER.warn("Can't get connection for null file.");

            return null;

        }

        if (CONNECTIONS == null) {

            registerDriver();

        }

        try {

            ConnectionEntry entry = CONNECTIONS.get(f);

            if (entry == null) {

                entry = new ConnectionEntry(f);

            } else {

                if( entry.conn==null ) {

                    entry.refCount = 1;

                } else if( !entry.conn.isClosed()) {

                    entry.refCount += 1;

                    LOGGER.debug("Reuse connection "+ entry.conn.hashCode() + " (refs "+entry.refCount+", "+entry.conn.toString()+")");

                    return entry.conn;

                }

            }

            SQLiteConfig config = new SQLiteConfig();

            config.setSharedCache(true);

            config.enableLoadExtension(true);

            config.setTransactionMode(SQLiteConfig.TransactionMode.IMMEDIATE);

            entry.conn = DriverManager.getConnection(

                    getConnectionURL(entry.f),

                    config.toProperties()

            );

            loadExtension(entry);

            if( !entry.metadataInitialized ) {

                initSpatialMetadata(entry);

                entry.metadataInitialized = true;

            }

            CONNECTIONS.put(f, entry);

            LOGGER.debug("Open connection "+ entry.conn.hashCode() + " (refs "+entry.refCount+", "+entry.conn.toString()+")");

            return entry.conn;

        } catch (SQLException ex) {

            LOGGER.warn("Can't get connection for file '" + f + "'.");

            return null;

        }

    }

    public static synchronized void close(Connection conn) {

        for (ConnectionEntry entry : CONNECTIONS.values()) {

            if (conn == entry.conn) {

                entry.refCount -= 1;

                if (entry.refCount < 1) {

                    JDBCUtils.closeQuietly(entry.conn);

                    entry.conn = null;

                    entry.refCount = 0;

                    return;

                }

                LOGGER.debug("Skip close connection "+ entry.conn.hashCode() + " (refs "+entry.refCount+", "+entry.conn.toString()+")");

                break;

            }

        }

    }

    public static String getConnectionURL(File f) {

        String fname = f.getAbsolutePath().replace("\\", "/");

        if (StringUtils.isEmpty(FilenameUtils.getExtension(fname))) {

            fname = fname + ".sqlite";

        }

        String connectionURL = String.format(URL_FORMAT, fname);

        LOGGER.debug("connectionURL: {}", connectionURL);

        return connectionURL;

    }

    public static void registerDriver() {

        Class theClass = null;

        try {

            theClass = Class.forName(SPATIALITE_JDBC_DRIVER);

        } catch (Exception e) {

            LOGGER.warn("Can't register JDBC driver '" + SPATIALITE_JDBC_DRIVER + "'.", e);

            throw new SpatiaLiteDriverNotFound(e);

        }

        if (theClass == null) {

            LOGGER.warn("Can't register JDBC driver '" + SPATIALITE_JDBC_DRIVER + "'.");

            throw new SpatiaLiteDriverNotFound();

        }

        if (CONNECTIONS == null) {

            CONNECTIONS = new HashMap<>();

        }

    }

    private static void loadExtension(ConnectionEntry entry) {

        Statement st = null;

        try {

            st = entry.conn.createStatement();

            JDBCUtils.execute(st, "SELECT load_extension('mod_spatialite')");

        } catch (Exception ex) {

            LOGGER.warn("Can't load mod_spatialite extension module for SQLite (" +

                    entry.f.getAbsolutePath() + ").", ex);

        } finally {

            JDBCUtils.closeQuietly(st);

        }

    }

    private static void initSpatialMetadata(ConnectionEntry entry) {

        Statement st = null;

        try {

            st = entry.conn.createStatement();

            JDBCUtils.execute(st, "SELECT InitSpatialMetaData(1)");

        } catch (Exception ex) {

            LOGGER.warn("Can't initialize spatial metatada in SQLite database (" + 

                    entry.f.getAbsolutePath() + ").", ex);

        } finally {

            JDBCUtils.closeQuietly(st);

        }

    }

    private static class SpatiaLiteDriverNotFound extends RuntimeException {

        public SpatiaLiteDriverNotFound() {

            super("Can't locate the SpatiaLite JDBC driver '" + SPATIALITE_JDBC_DRIVER + "'.");

        }

        public SpatiaLiteDriverNotFound(Throwable cause) {

            this();

            this.initCause(cause);

        }

    }

}

package org.gvsig.spatialite.dal;

import java.util.Properties;

import org.gvsig.fmap.dal.serverexplorer.filesystem.FilesystemStoreParameters;

import org.gvsig.fmap.dal.store.jdbc.JDBCConnectionParameters;

public interface SpatiaLiteConnectionParameters extends JDBCConnectionParameters, FilesystemStoreParameters {

    public boolean getEnableSpatiaLite();

    public boolean getEnableLoadExtension();

    public boolean getEnableSharedCache();

    public void setEnableSpatiaLite(boolean v);

    public void setEnableLoadExtension(boolean v);

    public void setEnableSharedCache(boolean v);

    public Properties getProperties();

    public String getURLFormat();

}

package org.gvsig.spatialite.dal;

import java.io.File;

import java.util.Properties;

import org.apache.commons.io.FilenameUtils;

import org.apache.commons.lang3.BooleanUtils;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.fmap.dal.DataParameters;

import org.gvsig.fmap.dal.exception.ValidateDataParametersException;

import org.gvsig.fmap.dal.resource.db.DBParameters;

import org.gvsig.fmap.dal.store.jdbc.JDBCConnectionParameters;

public class SpatiaLiteConnectionParametersHelper {

    private final JDBCConnectionParameters parameters;

    private static final String ENABLE_SHARED_CACHE = "enable_shared_cache";

    private static final String ENABLE_LOAD_EXTENSION = "enable_load_extension";

    private static final String ENABLE_SPATIALITE = "enable_spatialite";

    private static final String DATABASE_FILE = "database_file";

    private static final String URLFORMAT = "url_format";

    public SpatiaLiteConnectionParametersHelper(JDBCConnectionParameters parameters) {

        this.parameters = parameters;

    }

    public String getUrl() {

        String url = (String) this.getDynValue(JDBCConnectionParameters.URL_PARAMTER_NAME);

        if( StringUtils.isEmpty(url) ) {

//            url = SpatiaLiteHelper.getConnectionURL((SpatiaLiteConnectionParameters) this.parameters);

            url = SpatiaLiteConnections.getConnectionURL(((SpatiaLiteConnectionParameters)this.parameters).getFile());

            this.setDynValue(JDBCConnectionParameters.URL_PARAMTER_NAME,url);

        }

        return url;

    }

    public void validate() throws ValidateDataParametersException {

        if (this.getDynValue(JDBCConnectionParameters.JDBC_DRIVER_CLASS_PARAMTER_NAME) == null) {

            this.setDynValue(JDBCConnectionParameters.JDBC_DRIVER_CLASS_PARAMTER_NAME,

                SpatiaLiteConnections.SPATIALITE_JDBC_DRIVER

            );

        }

        if (getFile() == null) {

            throw new ValidateDataParametersException();

        }

    }

    private Object getDynValue(String name) {

        return ((DataParameters)this.parameters).getDynValue(name);

    }

    private void setDynValue(String name, Object value) {

        ((DataParameters)this.parameters).setDynValue(name,value);

    }

    public boolean getEnableSpatiaLite() {

        return (boolean) this.getDynValue(ENABLE_SPATIALITE);

    }

    public boolean getEnableLoadExtension() {

        return (boolean) this.getDynValue(ENABLE_LOAD_EXTENSION);

    }

    public boolean getEnableSharedCache() {

        return (boolean) this.getDynValue(ENABLE_SHARED_CACHE);

    }

    public void setEnableSpatiaLite(boolean v) {

        this.setDynValue(ENABLE_SPATIALITE, v);

    }

    public void setEnableLoadExtension(boolean v) {

        this.setDynValue(ENABLE_LOAD_EXTENSION, v);

    }

    public void setEnableSharedCache(boolean v) {

        this.setDynValue(ENABLE_SHARED_CACHE, v);

    }

    public String getURLFormat() {

        return (String) this.getDynValue(URLFORMAT);

    }

    public File getFile() {

        File f = (File) this.getDynValue(DATABASE_FILE);

        if( this.getDynValue(DBParameters.DBNAME_PARAMTER_NAME)==null &&

            f != null ) {

            String dbname = FilenameUtils.getBaseName(f.getName());

            this.setDynValue(DBParameters.DBNAME_PARAMTER_NAME, dbname);

        }

        return f;

    }

    public void setFile(File database) {

        this.setDynValue(DATABASE_FILE, database);

        if( this.getDynValue(DBParameters.DBNAME_PARAMTER_NAME)==null &&

            database != null ) {

            String dbname = FilenameUtils.getBaseName(database.getName());

            this.setDynValue(DBParameters.DBNAME_PARAMTER_NAME, dbname);

        }

    }

    public Properties getProperties() {

        Properties props = new Properties();

        props.setProperty("enable_shared_cache", BooleanUtils.toStringTrueFalse(getEnableSharedCache()));

        props.setProperty("enable_load_extension", BooleanUtils.toStringTrueFalse(getEnableLoadExtension()));

        props.setProperty("enable_spatialite", BooleanUtils.toStringTrueFalse(getEnableSpatiaLite()));

        return props;

    }    

}

package org.gvsig.spatialite.dal.operations;

import java.sql.Connection;

import java.sql.ResultSet;

import java.sql.ResultSetMetaData;

import java.sql.SQLException;

import java.sql.Statement;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import org.apache.commons.lang3.StringUtils;

import org.cresques.cts.IProjection;

import org.gvsig.expressionevaluator.ExpressionBuilder;

import org.gvsig.fmap.dal.DataTypes;

import org.gvsig.fmap.dal.exception.DataException;

import org.gvsig.fmap.dal.feature.EditableFeatureAttributeDescriptor;

import org.gvsig.fmap.dal.feature.EditableFeatureType;

import org.gvsig.fmap.dal.store.jdbc2.JDBCHelper;

import org.gvsig.fmap.dal.store.jdbc2.JDBCUtils;

import org.gvsig.fmap.dal.store.jdbc2.OperationsFactory.TableReference;

import org.gvsig.fmap.dal.store.jdbc2.spi.JDBCSQLBuilderBase;

import org.gvsig.fmap.dal.store.jdbc2.spi.operations.FetchFeatureTypeOperation;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

import org.gvsig.fmap.geom.type.GeometryType;

@SuppressWarnings("UseSpecificCatch")

public class SpatiaLiteFetchFeatureTypeOperation extends FetchFeatureTypeOperation {

    private static Map<String,GeometryType>spatialiteGeometryTypes = null;

    private Map<String,String> columns_def;

    public SpatiaLiteFetchFeatureTypeOperation(

            JDBCHelper helper

        ) {

        super(helper);

    }

    private GeometryType getGT(

            GeometryManager manager, 

            int type, 

            int subtype

        ) {

        try {

            return manager.getGeometryType(type, subtype);

        } catch (Exception ex) {

            return null;

        }

    }

    public SpatiaLiteFetchFeatureTypeOperation(

            JDBCHelper helper,

            EditableFeatureType featureType,

            TableReference table,

            List<String> primaryKeys,

            String defaultGeometryColumn,

            IProjection crs

        ) {

        super(helper, featureType, table, primaryKeys, defaultGeometryColumn, crs);

    }            

    @Override

    public void fetch(EditableFeatureType featureType, Connection conn, TableReference table, List<String> pks, String defaultGeometryColumn, IProjection crs) throws DataException {

        columns_def = new HashMap<>();

        try {

            ResultSet dbmetadata = this.getConnection().getMetaData().getColumns(null, null, table.getTable(), null);

            while( dbmetadata.next() ) {

                columns_def.put(dbmetadata.getString("COLUMN_NAME"), StringUtils.defaultString(dbmetadata.getString("COLUMN_DEF")));

            }

        } catch (SQLException ex) {

            LOGGER.warn("Can't read metadata from table '"+table+"'.",ex);

        }

        super.fetch(featureType, conn, table, pks, defaultGeometryColumn, crs);

    }

    @Override

    protected boolean isInPrimaryKeys(List<String> pks, EditableFeatureAttributeDescriptor attr) {

        // En SpatiaLite, los nombres obtenidos de las pks de los metadados no 

        // coinciden conlos nombres de los campos ya que unos estan en mayusculas 

        // y otros en minusculas, asi que comparamos con IgnoreCase.

        for (String pk : pks) {

            if( StringUtils.equalsIgnoreCase(pk, attr.getName()) ) {

                return true;

            }

        }

        return false;

    }

    @Override

    protected int getDataTypeFromMetadata(

            ResultSetMetaData rsMetadata,

            int colIndex

        ) throws SQLException {

        // En SpatiaLite no existe el tipo de dato Geometria, las geometrias

        // se guardan en un BLOB, y en getColumnTypeName se indica el tipo

        // de la geometria.

        String columnTypeName = rsMetadata.getColumnTypeName(colIndex);

        GeometryType gt = getGeometryTypeFromSpatiaLiteTypeName(columnTypeName);

        if( gt!=null ) {

            return DataTypes.GEOMETRY;

        }

        int columnType = rsMetadata.getColumnType(colIndex);

        String columnName = rsMetadata.getColumnName(colIndex);

        String column_def = this.columns_def.getOrDefault(columnName,"").trim();

        if( columnType == java.sql.Types.INTEGER && (

            StringUtils.startsWithIgnoreCase(column_def, "date(") || 

            StringUtils.startsWithIgnoreCase(column_def, "datetime(") || 

            StringUtils.startsWithIgnoreCase(column_def, "strftime(") )

            ) {

            return DataTypes.DATE;

        }

        return super.getDataTypeFromMetadata(rsMetadata, colIndex);

    }

    @Override

    protected void fetchGeometryTypeAndSRS(

            EditableFeatureAttributeDescriptor attr,

            ResultSetMetaData rsMetadata,

            int colIndex

        ) {

        if( attr.getType()!=DataTypes.GEOMETRY ) {

            return;

        }

        try {

            String typeName = rsMetadata.getColumnTypeName(colIndex);

            GeometryType gt = getGeometryTypeFromSpatiaLiteTypeName(typeName);

            if( gt != null ) {

                attr.setGeometryType(gt);

                JDBCSQLBuilderBase sqlbuilder = this.createSQLBuilder();

                ExpressionBuilder expbuilder = sqlbuilder.expression();

                sqlbuilder.select().column().name("geometry_type");

                sqlbuilder.select().column().name("coord_dimension");

                sqlbuilder.select().column().name("srid");

                sqlbuilder.select().column().name("spatial_index_enabled");

                sqlbuilder.select().where().set(

                        expbuilder.eq(

                                expbuilder.column("f_table_name"),

                                expbuilder.constant(this.getTable().getTable().toLowerCase()) // geometry_columns always stores lowercase names

                        )

                );                

                sqlbuilder.select().where().and(

                        expbuilder.eq(

                                expbuilder.column("f_geometry_column"),

                                expbuilder.constant(attr.getName().toLowerCase()) // geometry_columns always stores lowercase names

                        )

                );         

                sqlbuilder.select().from().table().name("geometry_columns");

                Statement st = null;

                ResultSet rs = null;

                int srsid = -1;

                boolean indexed = false;

                try {

                    st = this.getConnection().createStatement();

                    rs = JDBCUtils.executeQuery(st, sqlbuilder.toString());

                    if (rs.next()) {

                        srsid = rs.getInt("srid");

                        indexed = (rs.getInt("spatial_index_enabled")==1);

                    }

                } finally {

                    JDBCUtils.closeQuietly(rs);

                    JDBCUtils.closeQuietly(st);

                }

                attr.setIsIndexed(indexed);

                if( srsid > 0 ) {

                    attr.setSRS(this.helper.getSRSSolver().getProjection(conn, srsid));

                }

            }

        } catch (Exception ex) {

            LOGGER.warn("Can't get geometry type and srs from column '"+attr.getName()+"'.",ex);

        }

    }

    private GeometryType getGeometryTypeFromSpatiaLiteTypeName(String typeName) {

        if( spatialiteGeometryTypes==null ) {

            GeometryManager manager = GeometryLocator.getGeometryManager();

            spatialiteGeometryTypes = new HashMap<>();

            spatialiteGeometryTypes.put("POINT", getGT(manager, Geometry.TYPES.POINT,Geometry.SUBTYPES.GEOM2D));

            spatialiteGeometryTypes.put("POINTZ", getGT(manager, Geometry.TYPES.POINT,Geometry.SUBTYPES.GEOM3D));

            spatialiteGeometryTypes.put("POINTM", getGT(manager, Geometry.TYPES.POINT,Geometry.SUBTYPES.GEOM2DM));

            spatialiteGeometryTypes.put("POINTZM", getGT(manager, Geometry.TYPES.POINT,Geometry.SUBTYPES.GEOM3DM));

            spatialiteGeometryTypes.put("LINESTRING", getGT(manager, Geometry.TYPES.LINE,Geometry.SUBTYPES.GEOM2D));

            spatialiteGeometryTypes.put("LINESTRINGZ", getGT(manager, Geometry.TYPES.LINE,Geometry.SUBTYPES.GEOM3D));

            spatialiteGeometryTypes.put("LINESTRINGM", getGT(manager, Geometry.TYPES.LINE,Geometry.SUBTYPES.GEOM2DM));

            spatialiteGeometryTypes.put("LINESTRINGZM", getGT(manager, Geometry.TYPES.LINE,Geometry.SUBTYPES.GEOM3DM));

            spatialiteGeometryTypes.put("POLYGON", getGT(manager, Geometry.TYPES.POLYGON,Geometry.SUBTYPES.GEOM2D));

            spatialiteGeometryTypes.put("POLYGONZ", getGT(manager, Geometry.TYPES.POLYGON,Geometry.SUBTYPES.GEOM3D));

            spatialiteGeometryTypes.put("POLYGONM", getGT(manager, Geometry.TYPES.POLYGON,Geometry.SUBTYPES.GEOM2DM));

            spatialiteGeometryTypes.put("POLYGONZM", getGT(manager, Geometry.TYPES.POLYGON,Geometry.SUBTYPES.GEOM3DM));

            spatialiteGeometryTypes.put("MULTIPOINT", getGT(manager, Geometry.TYPES.MULTIPOINT,Geometry.SUBTYPES.GEOM2D));

            spatialiteGeometryTypes.put("MULTIPOINTZ", getGT(manager, Geometry.TYPES.MULTIPOINT,Geometry.SUBTYPES.GEOM3D));

            spatialiteGeometryTypes.put("MULTIPOINTM", getGT(manager, Geometry.TYPES.MULTIPOINT,Geometry.SUBTYPES.GEOM2DM));

            spatialiteGeometryTypes.put("MULTIPOINTZM", getGT(manager, Geometry.TYPES.MULTIPOINT,Geometry.SUBTYPES.GEOM3DM));

            spatialiteGeometryTypes.put("MULTILINESTRING", getGT(manager, Geometry.TYPES.MULTILINE,Geometry.SUBTYPES.GEOM2D));

            spatialiteGeometryTypes.put("MULTILINESTRINGZ", getGT(manager, Geometry.TYPES.MULTILINE,Geometry.SUBTYPES.GEOM3D));

            spatialiteGeometryTypes.put("MULTILINESTRINGM", getGT(manager, Geometry.TYPES.MULTILINE,Geometry.SUBTYPES.GEOM2DM));

            spatialiteGeometryTypes.put("MULTILINESTRINGZM", getGT(manager, Geometry.TYPES.MULTILINE,Geometry.SUBTYPES.GEOM3DM));

            spatialiteGeometryTypes.put("MULTIPOLYGON", getGT(manager, Geometry.TYPES.MULTIPOLYGON,Geometry.SUBTYPES.GEOM2D));

            spatialiteGeometryTypes.put("MULTIPOLYGONZ", getGT(manager, Geometry.TYPES.MULTIPOLYGON,Geometry.SUBTYPES.GEOM3D));

            spatialiteGeometryTypes.put("MULTIPOLYGONM", getGT(manager, Geometry.TYPES.MULTIPOLYGON,Geometry.SUBTYPES.GEOM2DM));

            spatialiteGeometryTypes.put("MULTIPOLYGONZM", getGT(manager, Geometry.TYPES.MULTIPOLYGON,Geometry.SUBTYPES.GEOM3DM));

            spatialiteGeometryTypes.put("GEOMETRY", getGT(manager, Geometry.TYPES.GEOMETRY,Geometry.SUBTYPES.GEOM2D));

            spatialiteGeometryTypes.put("GEOMETRYZ", getGT(manager, Geometry.TYPES.GEOMETRY,Geometry.SUBTYPES.GEOM3D));

            spatialiteGeometryTypes.put("GEOMETRYM", getGT(manager, Geometry.TYPES.GEOMETRY,Geometry.SUBTYPES.GEOM2DM));

            spatialiteGeometryTypes.put("GEOMETRYZM", getGT(manager, Geometry.TYPES.GEOMETRY,Geometry.SUBTYPES.GEOM3DM));

        }

        return spatialiteGeometryTypes.get(typeName);

    }

}

package org.gvsig.spatialite.dal.operations;

import java.util.List;

import org.cresques.cts.IProjection;

import org.gvsig.fmap.dal.feature.EditableFeatureType;

import org.gvsig.fmap.dal.store.jdbc2.JDBCHelper;

import org.gvsig.fmap.dal.store.jdbc2.spi.operations.FetchFeatureTypeOperation;

import org.gvsig.fmap.dal.store.jdbc2.spi.operations.OperationsFactoryBase;

public class SpatiaLiteOperationsFactory extends OperationsFactoryBase {

    public SpatiaLiteOperationsFactory(JDBCHelper helper) {

        super(helper);

    }

    @Override

    public FetchFeatureTypeOperation createFetchFeatureType(EditableFeatureType type, TableReference table, List<String> primaryKeys, String defaultGeometryField, IProjection crs) {

        return new SpatiaLiteFetchFeatureTypeOperation(

                helper, type, table, primaryKeys, 

                defaultGeometryField, crs

        );

    }  

}

/* gvSIG. Geographic Information System of the Valencian Government

*

* Copyright (C) 2007-2008 Infrastructures and Transports Department

* of the Valencian Government (CIT)

*

* This program is free software; you can redistribute it and/or

* modify it under the terms of the GNU General Public License

* as published by the Free Software Foundation; either version 2

* of the License, or (at your option) any later version.

*

* This program is distributed in the hope that it will be useful,

* but WITHOUT ANY WARRANTY; without even the implied warranty of

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

* GNU General Public License for more details.

*

* You should have received a copy of the GNU General Public License

* along with this program; if not, write to the Free Software

* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

* MA  02110-1301, USA.

*

 */

/**

 *

 */

package org.gvsig.spatialite.dal;

import java.io.File;

import java.util.Properties;

import org.gvsig.fmap.dal.exception.ValidateDataParametersException;

import org.gvsig.fmap.dal.store.jdbc.JDBCServerExplorerParameters;

public class SpatiaLiteExplorerParameters extends

        JDBCServerExplorerParameters 

    implements

        SpatiaLiteConnectionParameters

    {

    private final SpatiaLiteConnectionParametersHelper helper;

    public SpatiaLiteExplorerParameters() {

        super(

                SpatiaLiteLibrary.NAME + "ServerExplorerParameters",

                SpatiaLiteLibrary.NAME

        );

        this.helper = new SpatiaLiteConnectionParametersHelper(this);

    }

    @Override

    public String getUrl() {

        return this.helper.getUrl();

    }

    @Override

    public void validate() throws ValidateDataParametersException {

        this.helper.validate();

        super.validate();

    }

    @Override

    public boolean getEnableSpatiaLite() {

        return this.helper.getEnableSpatiaLite();

    }

    @Override

    public boolean getEnableLoadExtension() {

        return this.helper.getEnableLoadExtension();

    }

    @Override

    public boolean getEnableSharedCache() {

        return this.helper.getEnableSharedCache();

    }

    @Override

    public void setEnableSpatiaLite(boolean v) {

        this.helper.setEnableSpatiaLite(v);

    }

    @Override

    public void setEnableLoadExtension(boolean v) {

        this.helper.setEnableLoadExtension(v);

    }

    @Override

    public void setEnableSharedCache(boolean v) {

        this.helper.setEnableSharedCache(v);

    }

    @Override

    public Properties getProperties() {

        return this.helper.getProperties();

    }

    @Override

    public File getFile() {

        return this.helper.getFile();

    }

    @Override

    public void setFile(File database) {

        this.helper.setFile(database);

    }

    @Override

    public String getURLFormat() {

        return this.helper.getURLFormat();

    }

}

/* gvSIG. Geographic Information System of the Valencian Government

 *

 * Copyright (C) 2007-2008 Infrastructures and Transports Department

 * of the Valencian Government (CIT)

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 */

package org.gvsig.spatialite.dal;

import org.gvsig.fmap.dal.DALLibrary;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.spi.DataManagerProviderServices;

import org.gvsig.fmap.dal.store.db.DBHelper;

import org.gvsig.fmap.dal.store.jdbc2.JDBCLibrary;

import org.gvsig.fmap.dal.store.jdbc2.spi.JDBCStoreProviderBase;

import org.gvsig.metadata.exceptions.MetadataException;

import org.gvsig.tools.library.AbstractLibrary;

import org.gvsig.tools.library.LibraryException;

public class SpatiaLiteLibrary extends AbstractLibrary {

    public static final String NAME = "SpatiaLite";

    @Override

    public void doRegistration() {

        registerAsServiceOf(DALLibrary.class);

        require(JDBCLibrary.class);

    }

    @Override

    protected void doInitialize() throws LibraryException {

    }

    @Override

    protected void doPostInitialize() throws LibraryException {

        LibraryException ex = null;

        DataManagerProviderServices dataman = 

                (DataManagerProviderServices) DALLocator.getDataManager();

        SpatiaLiteConnections.registerDriver();

//        try {

//            Class.forName(SpatiaLiteHelper.SPATIALITE_JDBC_DRIVER);

//        } catch(Throwable th) {

//            SpatiaLiteHelper.LOGGER.warn("Can't load SpatiaLite JDBC Driver.",th);

//        }

        DBHelper.registerParametersDefinition(

                NAME + "StoreParameters",

                SpatiaLiteStoreParameters.class,

                dataman.getResourceAsStream(this, NAME + "Parameters.xml")

        );

        DBHelper.registerParametersDefinition(

                NAME + "NewStoreParameters",

                SpatiaLiteNewStoreParameters.class,

                dataman.getResourceAsStream(this, NAME + "Parameters.xml")

        );

        DBHelper.registerParametersDefinition(

                NAME + "ServerExplorerParameters",

                SpatiaLiteExplorerParameters.class,

                dataman.getResourceAsStream(this, NAME + "Parameters.xml")

        );

//        DBHelper.registerParametersDefinition(

//                NAME + "ResourceParameters",

//                SpatiaLiteResourceParameters.class,

//                dataman.getResourceAsStream(this, NAME + "Parameters.xml")

//        );

        try {

            DBHelper.registerMetadataDefinition(

                NAME,

                JDBCStoreProviderBase.class,

                dataman.getResourceAsStream(this, NAME + "Metadata.xml")

            );

        } catch (MetadataException e) {

            ex = new LibraryException(this.getClass(), e);

        }

//        ResourceManagerProviderServices resman = (ResourceManagerProviderServices) DALLocator

//                .getResourceManager();

//

//        if (!resman.getResourceProviders().contains(NAME)) {

//            resman.register(NAME,

//                "Resource for " + NAME,

//                SpatiaLiteResource.class,

//                SpatiaLiteResourceParameters.class

//            );

//        }

        if (!dataman.getStoreProviderRegister().exits(NAME)) {

            dataman.registerStoreProviderFactory(new SpatiaLiteStoreProviderFactory());

        }

        if (!dataman.getServerExplorerRegister().exits(NAME)) {

            dataman.registerServerExplorerFactory(new SpatiaLiteExplorerFactory());

        }

        if (ex != null) {

            throw ex;

        }

    }

}

package org.gvsig.spatialite.dal;

import java.sql.PreparedStatement;

import java.text.MessageFormat;

import java.util.ArrayList;

import java.util.Date;

import java.util.List;

import org.gvsig.fmap.dal.DataTypes;

import org.gvsig.fmap.dal.feature.FeatureAttributeDescriptor;

import org.gvsig.fmap.dal.feature.FeatureType;

import org.gvsig.fmap.dal.feature.spi.FeatureProvider;

import org.gvsig.fmap.dal.store.jdbc2.spi.JDBCSQLBuilderBase;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.tools.dispose.Disposable;

import org.apache.commons.lang3.tuple.Pair;

import org.gvsig.expressionevaluator.ExpressionBuilder.Parameter;

import org.gvsig.expressionevaluator.Formatter;

import org.gvsig.fmap.dal.SQLBuilder.ColumnDescriptor;

import org.gvsig.spatialite.dal.expressionbuilderformatter.SpatiaLiteFormatter;

@SuppressWarnings("UseSpecificCatch")

public class SpatiaLiteSQLBuilder extends JDBCSQLBuilderBase {

    protected Formatter formatter = null;

    public SpatiaLiteSQLBuilder(SpatiaLiteHelper helper) {

        super(helper);

        //

        // SpatiaLite 4.3.0, SQL functions reference list

        //

        // http://www.gaia-gis.it/gaia-sins/spatialite-sql-4.3.0.html

        //

        // https://sqlite.org/lang.html

        //

        this.defaultSchema = "";

        this.supportSchemas = false;

        this.allowAutomaticValues = true;

        this.geometrySupportType = this.helper.getGeometrySupportType();

        this.hasSpatialFunctions = this.helper.hasSpatialFunctions();

        this.STMT_DELETE_GEOMETRY_COLUMN_FROM_TABLE_schema_table = null;

        this.STMT_DELETE_GEOMETRY_COLUMN_FROM_TABLE_table = null;

        this.STMT_UPDATE_TABLE_STATISTICS_table = "SELECT UpdateLayerStatistics({0})";

        this.type_boolean = "INTEGER";

        this.type_byte = "INTEGER";

        this.type_bytearray = "";

        this.type_geometry = "BLOB";

        this.type_char = "TEXT";

        this.type_date = "INTEGER";

        this.type_double = "REAL";

        this.type_numeric_p = "REAL";

        this.type_numeric_ps = "REAL";

        this.type_bigdecimal = "REAL";

        this.type_float = "REAL";

        this.type_int = "INTEGER";

        this.type_long = "INTEGER";

        this.type_string = "TEXT";

        this.type_string_p = "TEXT";

        this.type_time = "INTEGER";

        this.type_timestamp = "INTEGER";

        this.type_version = "TEXT";

        this.type_URI = "TEXT";

        this.type_URL = "TEXT";

        this.type_FILE = "TEXT";

        this.type_FOLDER = "TEXT";

    }

    @Override

    protected Formatter formatter() {

        if (this.formatter == null) {

            this.formatter = new SpatiaLiteFormatter(this);

        }

        return this.formatter;

    }

    public class SpatiaLiteTableNameBuilderBase extends TableNameBuilderBase {

        @Override

        public boolean has_schema() {

            return false;

        }

        @Override

        public boolean has_database() {

            return false;

        }

    }

    protected class SpatiaLiteCreateTableBuilder extends CreateTableBuilderBase {

        @Override

        public List<String> toStrings(Formatter formatter) {

            //

            // Respecto al base cambia la declaracion de campo automaticos:

            // - Los campos se crean autom?ticamente como SERIAL si son INTEGER PRIMARY KEY.

            // - Existe la palabra clave AUTOINCREMENT que se puede usar

            // en los campos INTEGER PRIMARY KEY, pero no se recomienda su uso (penaliza el rendimiento).

            // - Spatialite no permite definir SERIALs para el resto de campos.

            // - Hay que usar la funcion AddGeometryColumn para a?adir las columnas de tipo geometria

            // - El orden en el que hay que declarar las constrains tambien cambia

            // respecto al que hay por defecto.

            //

            List<String> sqls = new ArrayList<>();

            StringBuilder builder = new StringBuilder();

            builder.append("CREATE TABLE ");

            builder.append(this.table.toString(formatter));

            builder.append(" (");

            boolean first = true;

            for (ColumnDescriptor column : columns) {

                if (column.isGeometry()) {

                    continue;

                }

                if (first) {

                    first = false;

                } else {

                    builder.append(", ");

                }

                builder.append(as_identifier(column.getName()));

                builder.append(" ");

                builder.append(sqltype(column.getType(), column.getPrecision(), column.getSize(), column.getGeometryType(), column.getGeometrySubtype()));

                if (column.isPrimaryKey()) {

                    builder.append(" PRIMARY KEY");

                }

                if (column.getDefaultValue() == null) {

                    if (column.allowNulls()) {

                        builder.append(" DEFAULT NULL");

                    }

                } else {

                    if (column.getType() == DataTypes.DATE) {

                        builder.append(" DEFAULT ( date('");

                        builder.append(column.getDefaultValue().toString());