use CreateTableStatement refresh proxy

package io.shardingsphere.shardingproxy.backend.jdbc;

import java.sql.SQLException;

import java.util.ArrayList;

import java.util.Collection;

import java.util.List;

import com.google.common.base.Function;

import com.google.common.collect.Lists;

import io.shardingsphere.api.config.rule.ShardingRuleConfiguration;

import io.shardingsphere.core.constant.DatabaseType;

import io.shardingsphere.core.constant.SQLType;

import io.shardingsphere.core.merger.MergeEngineFactory;

import io.shardingsphere.core.merger.MergedResult;

import io.shardingsphere.core.merger.dal.show.ShowTablesMergedResult;

import io.shardingsphere.core.metadata.table.ColumnMetaData;

import io.shardingsphere.core.metadata.table.TableMetaData;

import io.shardingsphere.core.metadata.table.executor.TableMetaDataLoader;

import io.shardingsphere.core.parsing.antlr.sql.statement.ddl.ColumnDefinition;

import io.shardingsphere.core.parsing.antlr.sql.statement.ddl.CreateTableStatement;

import io.shardingsphere.core.parsing.parser.constant.DerivedColumn;

import io.shardingsphere.core.parsing.parser.sql.SQLStatement;

import io.shardingsphere.core.routing.SQLRouteResult;

import io.shardingsphere.transaction.api.TransactionType;

import lombok.RequiredArgsConstructor;

import java.sql.SQLException;

import java.util.ArrayList;

import java.util.Collection;

import java.util.List;

/**

 * Backend handler via JDBC to connect databases.

 *

        executeResponse = executeEngine.execute(routeResult);

        if (logicSchema instanceof ShardingSchema && SQLType.DDL == sqlStatement.getType() && !sqlStatement.getTables().isEmpty()) {

            String logicTableName = sqlStatement.getTables().getSingleTableName();

            if (routeResult.getSqlStatement() instanceof CreateTableStatement) {

                createTable(logicTableName, logicSchema, (CreateTableStatement) routeResult.getSqlStatement());

            }else {

                // TODO refresh table meta data by SQL parse result

                TableMetaDataLoader tableMetaDataLoader = new TableMetaDataLoader(logicSchema.getMetaData().getDataSource(), BackendExecutorContext.getInstance().getExecuteEngine(),

                        new ProxyTableMetaDataConnectionManager(logicSchema.getBackendDataSource()), 

                        GLOBAL_REGISTRY.getShardingProperties().<Integer>getValue(ShardingPropertiesConstant.MAX_CONNECTIONS_SIZE_PER_QUERY));

                logicSchema.getMetaData().getTable().put(logicTableName, tableMetaDataLoader.load(logicTableName, ((ShardingSchema) logicSchema).getShardingRule()));

            }

        }

        return merge(sqlStatement);

    }

    private void createTable(final String logicTableName, final LogicSchema logicSchema, final CreateTableStatement createTableStatement) {

        TableMetaData tableMetaData = new TableMetaData(Lists.transform(createTableStatement.getColumnDefinitions(), new Function<ColumnDefinition, ColumnMetaData>() {

            @Override

            public ColumnMetaData apply(final ColumnDefinition input) {

                return new ColumnMetaData(input.getName(), input.getType(), input.isPrimaryKey());

            }

        }));

        logicSchema.getMetaData().getTable().put(logicTableName, tableMetaData);

    }

    private boolean isUnsupportedXA(final SQLType sqlType) {

        BackendConnection connection = executeEngine.getBackendConnection();

        return TransactionType.XA == connection.getTransactionType() && SQLType.DDL == sqlType && ConnectionStatus.TRANSACTION == connection.getStateHandler().getStatus();