Application: gvSIG desktop » gvSIG data provider for PostgreSQL

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright (C) 2007-2013 gvSIG Association.

 *

 * 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 3

 * 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.

 *

 * For any additional information, do not hesitate to contact us

 * at info AT gvsig.com, or visit our website www.gvsig.com.

 */

package org.gvsig.postgresql.dal;

import java.sql.Connection;

import java.sql.DatabaseMetaData;

import java.text.MessageFormat;

import java.util.ArrayList;

import java.util.List;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.expressionevaluator.Formatter;

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

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

import org.gvsig.postgresql.dal.expressionbuilderformatter.PostgreSQLFormatter;

@SuppressWarnings("UseSpecificCatch")

public class PostgreSQLBuilder extends JDBCSQLBuilderBase {

    protected Formatter formatter = null;

    public static class Version {

        private final int major;

        private final int minor;

        public Version(int major, int minor) {

            this.major = major;

            this.minor = minor;

        }

        public int getMajor() {

            return major;

        }

        public int getMinor() {

            return minor;

        }

    }

    private Version databaseVersion = null;

    public Version getDatabaseVersion() {

        if( databaseVersion == null ) {

            Connection conn = null;

            try {

                conn = this.getHelper().getConnection();

                DatabaseMetaData metadata = conn.getMetaData();

                databaseVersion = new Version(

                    metadata.getDatabaseMajorVersion(),

                    metadata.getDatabaseMinorVersion()

                );

            } catch (Exception ex) {

                databaseVersion = new Version(0,0);

            } finally {

                this.getHelper().closeConnectionQuietly(conn);

            }

        }

        return databaseVersion;

    }

    public PostgreSQLBuilder(JDBCHelper helper) {

        super(helper);

        this.defaultSchema = "public";

        this.supportSchemas = true;

        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 = "ANALYZE {0}";

//        config.set(SQLConfig.ST_GeomFromEWKB, "ST_GeomFromEWKB({0}, {1})");

//        config.set(SQLConfig.ST_AsEWKB, "ST_AsEWKB(({0}))");        

//        config.set(SQLConfig.ST_ExtentAggregate, "ST_Extent({0})");        

//        config.set(SQLConfig.ST_UnionAggregate, "ST_Union({0})");

//        config.set(SQLConfig.isNull, "( ({0}) ISNULL )");

//        config.set(SQLConfig.notIsNull, "( ({0}) NOT NULL )");

    }

    public class PostgreSQLUpdateTableStatisticsBuilderBase extends UpdateTableStatisticsBuilderBase {

        @Override

        public List<String> toStrings() {

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

            if( !StringUtils.isBlank(STMT_UPDATE_TABLE_STATISTICS_table) ) {

                // In postGIS, UpdateLayerStatistics function, don't allow to 

                // use the database name in the table name.

                String name = as_identifier(this.table.getName());

                if( table.has_schema()) {

                    name = as_identifier(this.table.getSchema()) + "." + name;

                }

                String sql = MessageFormat.format(

                        STMT_UPDATE_TABLE_STATISTICS_table,

                        name

                    );

                if( !StringUtils.isEmpty(sql) ) {

                    sqls.add(sql);

                }

            }

            return sqls;

        }        

    }

    protected class PostgreSQLCreateIndexBuilder extends CreateIndexBuilderBase {

        @Override

        public List<String> toStrings(Formatter formatter) {

            StringBuilder builder = new StringBuilder();

            builder.append("CREATE ");

//            if( this.isUnique ) {

//                builder.append("UNIQUE ");

//            }

            builder.append("INDEX ");

            if( this.ifNotExist ) {

                Version version = getDatabaseVersion();

                if( version.getMajor()>=9 && version.getMinor()>=5 ) {

                    builder.append("IF NOT EXISTS ");

                }

            }

            builder.append(as_identifier(this.indexName));

            builder.append(" ON ");

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

            if( this.isSpatial ) {

                builder.append(" USING GIST ");

            }

            builder.append(" ( ");

            boolean is_first_column = true;

            for( String column : this.columns) {

                if( is_first_column ) {

                    is_first_column = false;

                } else {

                    builder.append(", ");

                }

                builder.append(as_identifier(column));

            }

            builder.append(" )");

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

            sqls.add(builder.toString());

            return sqls;

        }

    }

    protected class PostgreSQLCreateTableBuilder extends CreateTableBuilderBase {

        @Override

       public List<String> toStrings(Formatter formatter) {

           // 

           // https://www.postgresql.org/docs/9.1/static/sql-createtable.html

           //

            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(" ");

                if( column.isAutomatic() ) {

                    builder.append(" SERIAL");

                } else {

                    builder.append(sqltype(

                            column.getType(), 

                            column.getSize(),

                            column.getPrecision(), 

                            column.getScale(), 

                            column.getGeometryType(),

                            column.getGeometrySubtype()

                    ));

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

                        if (column.allowNulls()) {

                            builder.append(" DEFAULT NULL");

                        }

                    } else {

                        builder.append(" DEFAULT '");

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

                        builder.append("'");

                    }

                    if (column.allowNulls()) {

                        builder.append(" NULL");

                    } else {

                        builder.append(" NOT NULL");

                    }

                }

                if (column.isPrimaryKey()) {

                    builder.append(" PRIMARY KEY");

                }

            }

            builder.append(" )");

            sqls.add(builder.toString());

            String AddGeometryColumn = "SELECT AddGeometryColumn({0} , {1} , {2}, {3,number,#######} , {4} , {5}, {6})";

            for (ColumnDescriptor column : columns) {

                if( column.isGeometry() ) {

                    String sql = MessageFormat.format(

                        AddGeometryColumn,

                        as_string(this.table.has_schema()?this.table.getSchema():"public"),

                        as_string(this.table.getName()),

                        as_string(column.getName()),

                        column.getGeometrySRSId(),

                        as_string(sqlgeometrytype(column.getGeometryType(), column.getGeometrySubtype())),

                        as_string(sqlgeometrydimension(column.getGeometryType(), column.getGeometrySubtype())),

                        as_string(column.allowNulls())

                    );

                    sqls.add(sql);

                }

            }

            return sqls;

        }

    }

    public class PostgreSQLSelectBuilderBase extends SelectBuilderBase {

        @Override

        protected boolean isValid(StringBuilder message) {

            if( message == null ) {

                message = new StringBuilder();

            }

            if( this.has_offset() && !this.has_order_by() ) {

                // Algunos gestores de BBDD requieren que se especifique un

                // orden para poder usar OFFSET. Como eso parece buena idea para

                // asegurar que siempre tengamos los mismo resultados, lo exijimos

                // siempre.

                message.append("Can't use OFFSET without an ORDER BY.");

                return false;

            }

            return true;

        }        

        @Override

        public String toString(Formatter formatter) {

            //

            // https://www.postgresql.org/docs/9.1/static/sql-select.html

            //

            StringBuilder builder = new StringBuilder();

            if( !isValid(builder) ) {

                throw new IllegalStateException(builder.toString());

            }

            builder.append("SELECT ");

            if( this.distinct ) {

                builder.append("DISTINCT ");

            }

            boolean first = true;

            for (SelectColumnBuilder column : columns) {

                if (first) {

                    first = false;

                } else {

                    builder.append(", ");

                }

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

            }

            if ( this.has_from() ) {

                builder.append(" FROM ");

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

            }

            if ( this.has_where() ) {

                builder.append(" WHERE ");

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

            }

            if( this.has_group_by() ) {

                builder.append(" GROUP BY ");

                builder.append(this.groupColumn.get(0).toString(formatter));

                for (int i = 1; i < groupColumn.size(); i++) {

                    builder.append(", ");

                    builder.append(this.groupColumn.get(i).toString(formatter));

                }

            } 

            if( this.has_order_by() ) {

                builder.append(" ORDER BY ");

                first = true;

                for (OrderByBuilder item : this.order_by) {

                    if (first) {

                        first = false;

                    } else {

                        builder.append(", ");

                    }

                    builder.append(item.toString(formatter));

                }   

            }

            if ( this.has_limit() && this.has_offset() ) {

                builder.append(" OFFSET ");

                builder.append(this.offset);

                builder.append(" FETCH NEXT ");

                builder.append(this.limit);

                builder.append(" ROWS ONLY");

            } else if ( this.has_limit()) {

                builder.append(" LIMIT ");

                builder.append(this.limit);

            } else if ( this.has_offset() ) {

                builder.append(" LIMIT ALL OFFSET ");

                builder.append(this.offset);    

            }

            return builder.toString();

        }

    }

    @Override

    public Formatter formatter() {

        if( this.formatter==null ) {

            this.formatter = new PostgreSQLFormatter(this);

        }

        return this.formatter;

    }

    @Override

    public PostgreSQLHelper getHelper() {

        return (PostgreSQLHelper) helper;

    }

    @Override

    protected CreateTableBuilder createCreateTableBuilder() {

        return new PostgreSQLCreateTableBuilder();

    }

    @Override

    protected CreateIndexBuilder createCreateIndexBuilder() {

        return new PostgreSQLCreateIndexBuilder();

    }

    @Override

    protected SelectBuilder createSelectBuilder() {

        return new PostgreSQLSelectBuilderBase();

    }

    @Override

    protected UpdateTableStatisticsBuilder createUpdateTableStatisticsBuilder() {

        return new PostgreSQLUpdateTableStatisticsBuilderBase();

    }       

}