class MergeColumnChange extends AbstractChange {

    private String catalogName;
    private String schemaName;
    private String tableName;
    private String column1Name;
    private String joinString;
    private String column2Name;
    private String finalColumnName;
    private String finalColumnType;

    @Override
    public boolean supports(Database database) {
        return super.supports(database) && !(database instanceof DerbyDatabase) && !(database instanceof Db2zDatabase);
    }

    @DatabaseChangeProperty(description = "Name of the database catalog")
    public String getCatalogName() {
        return catalogName;
    }

    public void setCatalogName(String catalogName) {
        this.catalogName = catalogName;
    }

    @DatabaseChangeProperty(description = "Name of the database schema")
    public String getSchemaName() {
        return schemaName;
    }

    public void setSchemaName(String schemaName) {
        this.schemaName = schemaName;
    }

    @DatabaseChangeProperty(description = "Name of the table containing the columns to join")
    public String getTableName() {
        return tableName;
    }

    public void setTableName(String tableName) {
        this.tableName = tableName;
    }

    @DatabaseChangeProperty(description = "Name of the column containing the first half of the data", exampleValue = "first_name")
    public String getColumn1Name() {
        return column1Name;
    }

    public void setColumn1Name(String column1Name) {
        this.column1Name = column1Name;
    }

    @DatabaseChangeProperty(description = "Name of the column containing the second half of the data", exampleValue = "last_name")
    public String getColumn2Name() {
        return column2Name;
    }

    public void setColumn2Name(String column2Name) {
        this.column2Name = column2Name;
    }

    @DatabaseChangeProperty(description = "String to place between the values from column1 and column2 (may be empty)",
        exampleValue = " ")
    public String getJoinString() {
        return joinString;
    }

    public void setJoinString(String joinString) {
        this.joinString = joinString;
    }

    @DatabaseChangeProperty(description = "Name of the column to create", exampleValue = "full_name")
    public String getFinalColumnName() {
        return finalColumnName;
    }

    public void setFinalColumnName(String finalColumnName) {
        this.finalColumnName = finalColumnName;
    }

    @DatabaseChangeProperty(description = "Data type of the column to create", exampleValue = "varchar(255)")
    public String getFinalColumnType() {
        return finalColumnType;
    }

    public void setFinalColumnType(String finalColumnType) {
        this.finalColumnType = finalColumnType;
    }

    @Override
    public boolean generateStatementsVolatile(Database database) {
        return database instanceof SQLiteDatabase;
    }

    @Override
    public SqlStatement[] generateStatements(final Database database) {<FILL_FUNCTION_BODY>}

    @Override
    public String getConfirmationMessage() {
        return "Columns "+getTableName()+"."+getColumn1Name()+" and "+getTableName()+"."+getColumn2Name()+" merged";
    }

    @Override
    public String getSerializedObjectNamespace() {
        return STANDARD_CHANGELOG_NAMESPACE;
    }
}


        AddColumnChange addNewColumnChange = new AddColumnChange();
        addNewColumnChange.setSchemaName(schemaName);
        addNewColumnChange.setTableName(getTableName());
        final AddColumnConfig columnConfig = new AddColumnConfig();
        columnConfig.setName(getFinalColumnName());
        columnConfig.setType(getFinalColumnType());
        addNewColumnChange.addColumn(columnConfig);
        List<SqlStatement> statements = new ArrayList<>(Arrays.asList(addNewColumnChange.generateStatements(database)));

        String updateStatement = "";
        if (database instanceof MySQLDatabase || database instanceof MariaDBDatabase) {
            updateStatement = "UPDATE " + database.escapeTableName(getCatalogName(), getSchemaName(), getTableName()) +
                    " SET " + database.escapeObjectName(getFinalColumnName(), Column.class)
                    + " = " + database.getConcatSql("'" + getJoinString() + "'"
                    , database.escapeObjectName(getColumn1Name(), Column.class), database.escapeObjectName(getColumn2Name(), Column.class));
        } else {
            updateStatement = "UPDATE " + database.escapeTableName(getCatalogName(), getSchemaName(), getTableName()) +
                    " SET " + database.escapeObjectName(getFinalColumnName(), Column.class)
                    + " = " + database.getConcatSql(database.escapeObjectName(getColumn1Name(), Column.class)
                    , "'" + getJoinString() + "'", database.escapeObjectName(getColumn2Name(), Column.class));
        }
        statements.add(new RawSqlStatement(updateStatement));
        
        if (database instanceof SQLiteDatabase) {
           /* nolgpl: implement */

            // Since SQLite does not support a Merge column statement,
            SQLiteDatabase.AlterTableVisitor alterTableVisitor = new SQLiteDatabase.AlterTableVisitor() {
                @Override
                public ColumnConfig[] getColumnsToAdd() {
                    // This gets called after
                    ColumnConfig[] columnConfigs = new ColumnConfig[1];
                    ColumnConfig mergedColumn = new ColumnConfig();
                    mergedColumn.setName(getFinalColumnName());
                    mergedColumn.setType(getFinalColumnType());
                    columnConfigs[0] = mergedColumn;
                    return columnConfigs;
                }

                @Override
                public boolean copyThisColumn(ColumnConfig column) {
                    // don't create columns that are merged
                    return !column.getName().equals(getColumn1Name())
                            && !column.getName().equals(getColumn2Name());
                }

                @Override
                public boolean createThisColumn(ColumnConfig column) {
                    // don't copy columns that are merged
                    return !column.getName().equals(getColumn1Name())
                            && !column.getName().equals(getColumn2Name());
                }

                @Override
                public boolean createThisIndex(Index index) {
                    // skip the index if it has old columns
                    for (Column column : index.getColumns()) {
                        if (column.getName().equals(getColumn1Name())
                                || column.getName().equals(getColumn2Name())) {
                            return false;
                        }
                    }
                    return true;
                }
            };
            List<SqlStatement> workAroundStatements;
            try {
                workAroundStatements = SQLiteDatabase.getAlterTableStatements(alterTableVisitor, database, getCatalogName(), getSchemaName(), getTableName());
                statements.addAll(workAroundStatements);
            } catch (DatabaseException e) {
                throw new UnexpectedLiquibaseException(e);
            }

        } else {
        	// ...if it is not a SQLite database 
        	
	        DropColumnChange dropColumn1Change = new DropColumnChange();
	        dropColumn1Change.setSchemaName(schemaName);
	        dropColumn1Change.setTableName(getTableName());
	        dropColumn1Change.setColumnName(getColumn1Name());
	        statements.addAll(Arrays.asList(dropColumn1Change.generateStatements(database)));
	
	        DropColumnChange dropColumn2Change = new DropColumnChange();
	        dropColumn2Change.setSchemaName(schemaName);
	        dropColumn2Change.setTableName(getTableName());
	        dropColumn2Change.setColumnName(getColumn2Name());
	        statements.addAll(Arrays.asList(dropColumn2Change.generateStatements(database)));
        
        }
        return statements.toArray(SqlStatement.EMPTY_SQL_STATEMENT);

    
<methods>public void <init>() ,public liquibase.change.ChangeStatus checkStatus(liquibase.database.Database) ,public liquibase.change.ChangeMetaData createChangeMetaData() ,public boolean equals(java.lang.Object) ,public void finishInitialization() throws liquibase.exception.SetupException,public liquibase.change.CheckSum generateCheckSum() ,public liquibase.statement.SqlStatement[] generateRollbackStatements(liquibase.database.Database) throws liquibase.exception.RollbackImpossibleException,public boolean generateRollbackStatementsVolatile(liquibase.database.Database) ,public boolean generateStatementsVolatile(liquibase.database.Database) ,public Set<liquibase.structure.DatabaseObject> getAffectedDatabaseObjects(liquibase.database.Database) ,public liquibase.changelog.ChangeSet getChangeSet() ,public java.lang.String getDescription() ,public java.lang.String[] getExcludedFieldFilters(liquibase.ChecksumVersion) ,public liquibase.resource.ResourceAccessor getResourceAccessor() ,public java.lang.String getSerializableFieldNamespace(java.lang.String) ,public liquibase.serializer.LiquibaseSerializable.SerializationType getSerializableFieldType(java.lang.String) ,public java.lang.Object getSerializableFieldValue(java.lang.String) ,public Set<java.lang.String> getSerializableFields() ,public java.lang.String getSerializedObjectName() ,public java.lang.String getSerializedObjectNamespace() ,public int hashCode() ,public void load(liquibase.parser.core.ParsedNode, liquibase.resource.ResourceAccessor) throws liquibase.parser.core.ParsedNodeException,public void modify(liquibase.change.visitor.ChangeVisitor) throws liquibase.parser.core.ParsedNodeException,public liquibase.parser.core.ParsedNode serialize() throws liquibase.parser.core.ParsedNodeException,public void setChangeSet(liquibase.changelog.ChangeSet) ,public void setResourceAccessor(liquibase.resource.ResourceAccessor) ,public boolean shouldExecuteChange(liquibase.database.Database) ,public boolean supports(liquibase.database.Database) ,public boolean supportsRollback(liquibase.database.Database) ,public java.lang.String toString() ,public liquibase.exception.ValidationErrors validate(liquibase.database.Database) ,public liquibase.exception.Warnings warn(liquibase.database.Database) <variables>private static final java.util.regex.Pattern ALPHABET,protected static final java.lang.String NODENAME_COLUMN,private liquibase.changelog.ChangeSet changeSet