class SQLiteAlterTableVisitor implements AlterTableVisitor {
        @Override
        public ColumnConfig[] getColumnsToAdd() {
            return new ColumnConfig[0];
        }

        @Override
        public boolean copyThisColumn(ColumnConfig column) {
            return true;
        }

        @Override
        public boolean createThisColumn(ColumnConfig column) {
            if (column.getName().equals(getColumnName())) {
                column.getConstraints().setNullable(false);
            }
            return true;
        }

        @Override
        public boolean createThisIndex(Index index) {
            return true;
        }

    }


    private String catalogName;
    private String schemaName;
    private String tableName;
    private String columnName;
    private String defaultNullValue;
    private String columnDataType;
    private String constraintName;
    private Boolean shouldValidate;

    @DatabaseChangeProperty(since = "3.0", mustEqualExisting ="column.relation.catalog", description = "Name of the database catalog")
    public String getCatalogName() {
        return catalogName;
    }

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

    @DatabaseChangeProperty(mustEqualExisting ="column.relation.schema", 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 to add a NOT NULL constraint to.",
        mustEqualExisting = "column.relation")
    public String getTableName() {
        return tableName;
    }

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

    @DatabaseChangeProperty(description = "Name of the column to add the constraint to",
        mustEqualExisting = "column.relation.column")
    public String getColumnName() {
        return columnName;
    }

    public void setColumnName(String columnName) {
        this.columnName = columnName;
    }

    @DatabaseChangeProperty(description = "Value to set all currently null values to. " +
        "If defaultNullValue is not set and null values exist, the change fails")
    public String getDefaultNullValue() {
        return defaultNullValue;
    }

    public void setDefaultNullValue(String defaultNullValue) {
        this.defaultNullValue = defaultNullValue;
    }

    @DatabaseChangeProperty(description = "Current data type of the column")
    public String getColumnDataType() {
        return columnDataType;
    }

    public void setColumnDataType(String columnDataType) {
        this.columnDataType = columnDataType;
    }

    @DatabaseChangeProperty(description = "Name of the constraint to add (if database supports names for NOT NULL constraints)")
    public String getConstraintName() {
        return constraintName;
    }

    public void setConstraintName(String constraintName) {
        this.constraintName = constraintName;
    }

    @Override
    public SqlStatement[] generateStatements(Database database) {
        List<SqlStatement> statements = new ArrayList<>();

        if (defaultNullValue != null && !defaultNullValue.equalsIgnoreCase("null")) {
            final String columnDataType = this.getColumnDataType();

            Object finalDefaultNullValue = defaultNullValue;
            if (columnDataType != null) {
                final LiquibaseDataType datatype = DataTypeFactory.getInstance().fromDescription(columnDataType, database);
                if (datatype instanceof BooleanType) {
                    //need to detect a boolean or bit type and handle it correctly sometimes or it is not converted to the correct datatype
                    finalDefaultNullValue = datatype.objectToSql(finalDefaultNullValue, database);
                    if (finalDefaultNullValue.equals("0")) {
                        finalDefaultNullValue = 0;
                    } else if (finalDefaultNullValue.equals("1")) {
                        finalDefaultNullValue = 1;
                    }

                    if (columnDataType.toLowerCase().contains("bit")) {
                        if (BooleanUtil.parseBoolean(finalDefaultNullValue.toString())) {
                            finalDefaultNullValue = 1;
                        } else {
                            finalDefaultNullValue = 0;
                        }
                    }

                    if (database instanceof PostgresDatabase) {
                        if (finalDefaultNullValue.equals(0)) {
                            finalDefaultNullValue = new DatabaseFunction( "B'0'");
                        } else if (finalDefaultNullValue.equals(1)) {
                            finalDefaultNullValue = new DatabaseFunction( "B'1'");
                        }
                    }
                }
            }

            statements.add(new UpdateStatement(getCatalogName(), getSchemaName(), getTableName())
                                   .addNewColumnValue(getColumnName(), finalDefaultNullValue)
                                   .setWhereClause(database.escapeObjectName(getColumnName(), Column.class) +
                                   " IS NULL"));
        }

        statements.add(new SetNullableStatement(getCatalogName(), getSchemaName(), getTableName(),
                getColumnName(),
            getColumnDataType(), false, getConstraintName(),shouldValidate));
        if (database instanceof DB2Database) {
            statements.add(new ReorganizeTableStatement(getCatalogName(), getSchemaName(), getTableName()));
        }
        
        return statements.toArray(EMPTY_SQL_STATEMENT);
    }

    @Override
    protected Change[] createInverses() {<FILL_FUNCTION_BODY>

        DropNotNullConstraintChange inverse = new DropNotNullConstraintChange();
        inverse.setColumnName(getColumnName());
        inverse.setSchemaName(getSchemaName());
        inverse.setTableName(getTableName());
        inverse.setColumnDataType(getColumnDataType());

        return new Change[]{
                inverse
        };
    
<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