Add generated for ColumnMetaData (#4888)

* refactor GeneratedKey

* add generated for ColumnMetaData

* refactor tableRule.getGenerateKeyColumn()

* Add todo

* remove useless test case

encrypt-core/encrypt-core-common/src/main/java/org/apache/shardingsphere/encrypt/metadata/EncryptColumnMetaData.java

@@ -38,7 +38,7 @@ public final class EncryptColumnMetaData extends ColumnMetaData {
     
     public EncryptColumnMetaData(final String name, final String dataType, final boolean primaryKey, 
                                  final String cipherColumnName, final String plainColumnName, final String assistedQueryColumnName) {
-        super(name, dataType, primaryKey);
+        super(name, dataType, primaryKey, false);
         this.cipherColumnName = cipherColumnName;
         this.plainColumnName = plainColumnName;
         this.assistedQueryColumnName = assistedQueryColumnName;

sharding-core/sharding-core-common/src/main/java/org/apache/shardingsphere/core/metadata/ShardingTableMetaDataDecorator.java

@@ -20,12 +20,14 @@ package org.apache.shardingsphere.core.metadata;
 import org.apache.shardingsphere.core.rule.DataNode;
 import org.apache.shardingsphere.core.rule.ShardingRule;
 import org.apache.shardingsphere.core.rule.TableRule;
+import org.apache.shardingsphere.sql.parser.binder.metadata.column.ColumnMetaData;
 import org.apache.shardingsphere.sql.parser.binder.metadata.index.IndexMetaData;
 import org.apache.shardingsphere.sql.parser.binder.metadata.table.TableMetaData;
 import org.apache.shardingsphere.underlying.common.metadata.decorator.TableMetaDataDecorator;
 
 import java.util.Collection;
 import java.util.HashSet;
+import java.util.LinkedList;
 import java.util.Map.Entry;
 import java.util.Optional;
 
@@ -36,17 +38,30 @@ public final class ShardingTableMetaDataDecorator implements TableMetaDataDecora
     
     @Override
     public TableMetaData decorate(final TableMetaData tableMetaData, final String tableName, final ShardingRule shardingRule) {
-        return new TableMetaData(tableMetaData.getColumns().values(), getIndexMetaDataList(tableMetaData, tableName, shardingRule));
+        return shardingRule.findTableRule(tableName).map(
+            tableRule -> new TableMetaData(getColumnMetaDataList(tableMetaData, tableRule), getIndexMetaDataList(tableMetaData, tableRule))).orElse(tableMetaData);
     }
     
-    private Collection<IndexMetaData> getIndexMetaDataList(final TableMetaData tableMetaData, final String tableName, final ShardingRule shardingRule) {
-        Optional<TableRule> tableRule = shardingRule.findTableRule(tableName);
-        if (!tableRule.isPresent()) {
-            return tableMetaData.getIndexes().values();
+    private Collection<ColumnMetaData> getColumnMetaDataList(final TableMetaData tableMetaData, final TableRule tableRule) {
+        Optional<String> generateKeyColumn = tableRule.getGenerateKeyColumn();
+        if (!generateKeyColumn.isPresent()) {
+            return tableMetaData.getColumns().values();
         }
+        Collection<ColumnMetaData> result = new LinkedList<>();
+        for (Entry<String, ColumnMetaData> entry : tableMetaData.getColumns().entrySet()) {
+            if (entry.getKey().equalsIgnoreCase(generateKeyColumn.get())) {
+                result.add(new ColumnMetaData(entry.getValue().getName(), entry.getValue().getDataType(), entry.getValue().isPrimaryKey(), true));
+            } else {
+                result.add(entry.getValue());
+            }
+        }
+        return result;
+    }
+    
+    private Collection<IndexMetaData> getIndexMetaDataList(final TableMetaData tableMetaData, final TableRule tableRule) {
         Collection<IndexMetaData> result = new HashSet<>();
         for (Entry<String, IndexMetaData> entry : tableMetaData.getIndexes().entrySet()) {
-            for (DataNode each : tableRule.get().getActualDataNodes()) {
+            for (DataNode each : tableRule.getActualDataNodes()) {
                 getLogicIndex(entry.getKey(), each.getTableName()).ifPresent(logicIndex -> result.add(new IndexMetaData(logicIndex)));
             }
         }

sharding-core/sharding-core-common/src/main/java/org/apache/shardingsphere/core/rule/ShardingRule.java

@@ -344,8 +344,8 @@ public class ShardingRule implements BaseRule {
      */
     public Optional<String> findGenerateKeyColumnName(final String logicTableName) {
         for (TableRule each : tableRules) {
-            if (each.getLogicTable().equalsIgnoreCase(logicTableName) && null != each.getGenerateKeyColumn()) {
-                return Optional.of(each.getGenerateKeyColumn());
+            if (each.getLogicTable().equalsIgnoreCase(logicTableName) && each.getGenerateKeyColumn().isPresent()) {
+                return each.getGenerateKeyColumn();
             }
         }
         return Optional.empty();

sharding-core/sharding-core-common/src/main/java/org/apache/shardingsphere/core/rule/TableRule.java

@@ -41,6 +41,7 @@ import java.util.LinkedHashSet;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;
+import java.util.Optional;
 import java.util.Set;
 
 /**
@@ -64,6 +65,7 @@ public final class TableRule {
     
     private final ShardingStrategy tableShardingStrategy;
     
+    @Getter(AccessLevel.NONE)
     private final String generateKeyColumn;
     
     private final ShardingKeyGenerator shardingKeyGenerator;
@@ -104,7 +106,8 @@ public final class TableRule {
         actualTables = getActualTables();
         databaseShardingStrategy = null == tableRuleConfig.getDatabaseShardingStrategyConfig() ? null : ShardingStrategyFactory.newInstance(tableRuleConfig.getDatabaseShardingStrategyConfig());
         tableShardingStrategy = null == tableRuleConfig.getTableShardingStrategyConfig() ? null : ShardingStrategyFactory.newInstance(tableRuleConfig.getTableShardingStrategyConfig());
-        generateKeyColumn = getGenerateKeyColumn(tableRuleConfig.getKeyGeneratorConfig(), defaultGenerateKeyColumn);
+        final KeyGeneratorConfiguration keyGeneratorConfiguration = tableRuleConfig.getKeyGeneratorConfig();
+        generateKeyColumn = null != keyGeneratorConfiguration && !Strings.isNullOrEmpty(keyGeneratorConfiguration.getColumn()) ? keyGeneratorConfiguration.getColumn() : defaultGenerateKeyColumn;
         shardingKeyGenerator = containsKeyGeneratorConfiguration(tableRuleConfig)
                 ? new ShardingKeyGeneratorServiceLoader().newService(tableRuleConfig.getKeyGeneratorConfig().getType(), tableRuleConfig.getKeyGeneratorConfig().getProperties()) : null;
         checkRule(dataNodes);
@@ -133,13 +136,6 @@ public final class TableRule {
         return null != tableRuleConfiguration.getKeyGeneratorConfig() && !Strings.isNullOrEmpty(tableRuleConfiguration.getKeyGeneratorConfig().getType());
     }
     
-    private String getGenerateKeyColumn(final KeyGeneratorConfiguration keyGeneratorConfiguration, final String defaultGenerateKeyColumn) {
-        if (null != keyGeneratorConfiguration && !Strings.isNullOrEmpty(keyGeneratorConfiguration.getColumn())) {
-            return keyGeneratorConfiguration.getColumn();
-        }
-        return defaultGenerateKeyColumn;
-    }
-    
     private boolean isEmptyDataNodes(final List<String> dataNodes) {
         return null == dataNodes || dataNodes.isEmpty();
     }
@@ -228,4 +224,13 @@ public final class TableRule {
             throw new ShardingSphereConfigurationException("ActualDataNodes must be configured if want to shard tables for logicTable [%s]", logicTable);
         }
     }
+    
+    /**
+     * Get generate key column.
+     * 
+     * @return generate key column
+     */
+    public Optional<String> getGenerateKeyColumn() {
+        return Optional.ofNullable(generateKeyColumn);
+    }
 }

sharding-core/sharding-core-common/src/test/java/org/apache/shardingsphere/core/rule/TableRuleTest.java

@@ -70,7 +70,8 @@ public final class TableRuleTest {
         assertTrue(actual.getActualDataNodes().contains(new DataNode("ds1", "table_2")));
         assertNotNull(actual.getDatabaseShardingStrategy());
         assertNotNull(actual.getTableShardingStrategy());
-        assertThat(actual.getGenerateKeyColumn(), is("col_1"));
+        assertTrue(actual.getGenerateKeyColumn().isPresent());
+        assertThat(actual.getGenerateKeyColumn().get(), is("col_1"));
         assertThat(actual.getShardingKeyGenerator(), instanceOf(IncrementShardingKeyGenerator.class));
     }
     
@@ -119,15 +120,6 @@ public final class TableRuleTest {
         new TableRule(tableRuleConfiguration, createShardingDataSourceNames(), null);
     }
     
-    @Test
-    public void assertToString() {
-        TableRule actual = new TableRule(new TableRuleConfiguration("LOGIC_TABLE", "ds${0..1}.table_${0..2}"), createShardingDataSourceNames(), null);
-        String actualString = "TableRule(logicTable=logic_table, actualDataNodes=[DataNode(dataSourceName=ds0, tableName=table_0), DataNode(dataSourceName=ds0, tableName=table_1), "
-                + "DataNode(dataSourceName=ds0, tableName=table_2), DataNode(dataSourceName=ds1, tableName=table_0), DataNode(dataSourceName=ds1, tableName=table_1), "
-                + "DataNode(dataSourceName=ds1, tableName=table_2)], databaseShardingStrategy=null, tableShardingStrategy=null, generateKeyColumn=null, shardingKeyGenerator=null)";
-        assertThat(actual.toString(), is(actualString));
-    }
-    
     private ShardingDataSourceNames createShardingDataSourceNames() {
         return new ShardingDataSourceNames(new ShardingRuleConfiguration(), Arrays.asList("ds0", "ds1"));
     }

sharding-core/sharding-core-route/src/main/java/org/apache/shardingsphere/sharding/route/engine/keygen/GeneratedKey.java

@@ -56,8 +56,8 @@ public final class GeneratedKey {
      * @return generate key
      */
     public static Optional<GeneratedKey> getGenerateKey(final ShardingRule shardingRule, final SchemaMetaData schemaMetaData, final List<Object> parameters, final InsertStatement insertStatement) {
-        Optional<String> generateKeyColumnNameOptional = shardingRule.findGenerateKeyColumnName(insertStatement.getTable().getTableName().getIdentifier().getValue());
-        return generateKeyColumnNameOptional.map(generateKeyColumnName -> containsGenerateKey(schemaMetaData, insertStatement, generateKeyColumnName)
+        String tableName = insertStatement.getTable().getTableName().getIdentifier().getValue();
+        return shardingRule.findGenerateKeyColumnName(tableName).map(generateKeyColumnName -> containsGenerateKey(schemaMetaData, insertStatement, generateKeyColumnName)
                 ? findGeneratedKey(schemaMetaData, parameters, insertStatement, generateKeyColumnName) : createGeneratedKey(shardingRule, insertStatement, generateKeyColumnName));
     }
     

sharding-core/sharding-core-route/src/test/java/org/apache/shardingsphere/sharding/route/DatabaseTest.java

@@ -88,8 +88,8 @@ public final class DatabaseTest {
     private ShardingSphereMetaData getMetaDataForAllRoutingSQL() {
         DataSourceMetas dataSourceMetas = mock(DataSourceMetas.class);
         when(dataSourceMetas.getDataSourceMetaData("ds_0")).thenReturn(mock(DataSourceMetaData.class));
-        ColumnMetaData idColumnMetaData = new ColumnMetaData("id", "int", true);
-        ColumnMetaData nameColumnMetaData = new ColumnMetaData("user_id", "int", false);
+        ColumnMetaData idColumnMetaData = new ColumnMetaData("id", "int", true, false);
+        ColumnMetaData nameColumnMetaData = new ColumnMetaData("user_id", "int", false, false);
         SchemaMetaData schemaMetaData = mock(SchemaMetaData.class);
         when(schemaMetaData.get("tesT")).thenReturn(new TableMetaData(Arrays.asList(idColumnMetaData, nameColumnMetaData), Arrays.asList(new IndexMetaData("id"), new IndexMetaData("user_id"))));
         when(schemaMetaData.containsTable("tesT")).thenReturn(true);
@@ -115,8 +115,8 @@ public final class DatabaseTest {
     }
     
     private ShardingSphereMetaData getMetaDataForPagination() {
-        ColumnMetaData idColumnMetaData = new ColumnMetaData("id", "int", true);
-        ColumnMetaData nameColumnMetaData = new ColumnMetaData("user_id", "int", false);
+        ColumnMetaData idColumnMetaData = new ColumnMetaData("id", "int", true, false);
+        ColumnMetaData nameColumnMetaData = new ColumnMetaData("user_id", "int", false, false);
         SchemaMetaData schemaMetaData = mock(SchemaMetaData.class);
         when(schemaMetaData.get("tbl_pagination")).thenReturn(
                 new TableMetaData(Arrays.asList(idColumnMetaData, nameColumnMetaData), Arrays.asList(new IndexMetaData("id"), new IndexMetaData("user_id"))));

sharding-core/sharding-core-route/src/test/java/org/apache/shardingsphere/sharding/route/engine/type/standard/AbstractSQLRouteTest.java

@@ -71,16 +71,16 @@ public abstract class AbstractSQLRouteTest extends AbstractRoutingEngineTest {
     
     private SchemaMetaData buildSchemaMetaData() {
         Map<String, TableMetaData> tableMetaDataMap = new HashMap<>(3, 1);
-        tableMetaDataMap.put("t_order", new TableMetaData(Arrays.asList(new ColumnMetaData("order_id", "int", true), 
-                new ColumnMetaData("user_id", "int", false), 
-                new ColumnMetaData("status", "int", false)), Collections.emptySet()));
-        tableMetaDataMap.put("t_order_item", new TableMetaData(Arrays.asList(new ColumnMetaData("item_id", "int", true), 
-                new ColumnMetaData("order_id", "int", false),
-                new ColumnMetaData("user_id", "int", false), 
-                new ColumnMetaData("status", "varchar", false), 
-                new ColumnMetaData("c_date", "timestamp", false)), Collections.emptySet()));
-        tableMetaDataMap.put("t_other", new TableMetaData(Collections.singletonList(new ColumnMetaData("order_id", "int", true)), Collections.emptySet()));
-        tableMetaDataMap.put("t_category", new TableMetaData(Collections.singletonList(new ColumnMetaData("order_id", "int", true)), Collections.emptySet()));
+        tableMetaDataMap.put("t_order", new TableMetaData(Arrays.asList(new ColumnMetaData("order_id", "int", true, false), 
+                new ColumnMetaData("user_id", "int", false, false), 
+                new ColumnMetaData("status", "int", false, false)), Collections.emptySet()));
+        tableMetaDataMap.put("t_order_item", new TableMetaData(Arrays.asList(new ColumnMetaData("item_id", "int", true, false), 
+                new ColumnMetaData("order_id", "int", false, false),
+                new ColumnMetaData("user_id", "int", false, false), 
+                new ColumnMetaData("status", "varchar", false, false), 
+                new ColumnMetaData("c_date", "timestamp", false, false)), Collections.emptySet()));
+        tableMetaDataMap.put("t_other", new TableMetaData(Collections.singletonList(new ColumnMetaData("order_id", "int", true, false)), Collections.emptySet()));
+        tableMetaDataMap.put("t_category", new TableMetaData(Collections.singletonList(new ColumnMetaData("order_id", "int", true, false)), Collections.emptySet()));
         return new SchemaMetaData(tableMetaDataMap);
     }
 }

sharding-proxy/sharding-proxy-backend/src/test/java/org/apache/shardingsphere/shardingproxy/backend/response/query/QueryHeaderTest.java

@@ -126,7 +126,7 @@ public final class QueryHeaderTest {
     @SneakyThrows
     private ShardingSchema getShardingSchema() {
         ShardingSchema result = mock(ShardingSchema.class);
-        ColumnMetaData columnMetaData = new ColumnMetaData("order_id", "int", true);
+        ColumnMetaData columnMetaData = new ColumnMetaData("order_id", "int", true, false);
         SchemaMetaData schemaMetaData = mock(SchemaMetaData.class);
         when(schemaMetaData.get("t_logic_order")).thenReturn(new TableMetaData(Collections.singletonList(columnMetaData), Collections.singletonList(new IndexMetaData("order_id"))));
         ShardingSphereMetaData metaData = mock(ShardingSphereMetaData.class);

sharding-spring/sharding-jdbc-orchestration-spring/sharding-jdbc-orchestration-spring-boot-starter/src/test/java/org/apache/shardingsphere/shardingjdbc/orchestration/spring/boot/type/OrchestrationSpringBootRegistryShardingTest.java

@@ -158,7 +158,8 @@ public class OrchestrationSpringBootRegistryShardingTest {
         assertTrue(orderRule.getActualDataNodes().contains(new DataNode("ds_0", "t_order_1")));
         assertTrue(orderRule.getActualDataNodes().contains(new DataNode("ds_1", "t_order_0")));
         assertTrue(orderRule.getActualDataNodes().contains(new DataNode("ds_1", "t_order_1")));
-        assertThat(orderRule.getGenerateKeyColumn(), is("order_id"));
+        assertTrue(orderRule.getGenerateKeyColumn().isPresent());
+        assertThat(orderRule.getGenerateKeyColumn().get(), is("order_id"));
         TableRule itemRule = shardingRule.getTableRule("t_order_item");
         assertThat(itemRule.getLogicTable(), is("t_order_item"));
         assertThat(itemRule.getActualDataNodes().size(), is(4));
@@ -168,7 +169,8 @@ public class OrchestrationSpringBootRegistryShardingTest {
         assertTrue(itemRule.getActualDataNodes().contains(new DataNode("ds_1", "t_order_item_1")));
         assertThat(itemRule.getTableShardingStrategy(), instanceOf(InlineShardingStrategy.class));
         assertThat(itemRule.getTableShardingStrategy().getShardingColumns().iterator().next(), is("order_id"));
-        assertThat(itemRule.getGenerateKeyColumn(), is("order_item_id"));
+        assertTrue(itemRule.getGenerateKeyColumn().isPresent());
+        assertThat(itemRule.getGenerateKeyColumn().get(), is("order_item_id"));
         assertThat(itemRule.getTableShardingStrategy(), instanceOf(InlineShardingStrategy.class));
         assertThat(itemRule.getTableShardingStrategy().getShardingColumns().iterator().next(), is("order_id"));
         
@@ -196,10 +198,12 @@ public class OrchestrationSpringBootRegistryShardingTest {
         assertTrue(itemRule.getActualDataNodes().contains(new DataNode("ds_1", "t_order_item_1")));
         assertThat(itemRule.getTableShardingStrategy(), instanceOf(InlineShardingStrategy.class));
         assertThat(itemRule.getTableShardingStrategy().getShardingColumns().iterator().next(), is("order_id"));
-        assertThat(itemRule.getGenerateKeyColumn(), is("order_item_id"));
+        assertTrue(itemRule.getGenerateKeyColumn().isPresent());
+        assertThat(itemRule.getGenerateKeyColumn().get(), is("order_item_id"));
         assertThat(itemRule.getTableShardingStrategy(), instanceOf(InlineShardingStrategy.class));
         assertThat(itemRule.getTableShardingStrategy().getShardingColumns().iterator().next(), is("order_id"));
-        assertThat(orderRule.getGenerateKeyColumn(), is("order_id"));
+        assertTrue(orderRule.getGenerateKeyColumn().isPresent());
+        assertThat(orderRule.getGenerateKeyColumn().get(), is("order_id"));
         
     }
     

sharding-spring/sharding-jdbc-orchestration-spring/sharding-jdbc-orchestration-spring-boot-starter/src/test/java/org/apache/shardingsphere/shardingjdbc/orchestration/spring/boot/type/OrchestrationSpringBootShardingTest.java

@@ -98,7 +98,8 @@ public class OrchestrationSpringBootShardingTest {
         assertTrue(orderRule.getActualDataNodes().contains(new DataNode("ds_0", "t_order_1")));
         assertTrue(orderRule.getActualDataNodes().contains(new DataNode("ds_1", "t_order_0")));
         assertTrue(orderRule.getActualDataNodes().contains(new DataNode("ds_1", "t_order_1")));
-        assertThat(orderRule.getGenerateKeyColumn(), is("order_id"));
+        assertTrue(orderRule.getGenerateKeyColumn().isPresent());
+        assertThat(orderRule.getGenerateKeyColumn().get(), is("order_id"));
         TableRule itemRule = shardingRule.getTableRule("t_order_item");
         assertThat(itemRule.getLogicTable(), is("t_order_item"));
         assertThat(itemRule.getActualDataNodes().size(), is(4));
@@ -108,7 +109,8 @@ public class OrchestrationSpringBootShardingTest {
         assertTrue(itemRule.getActualDataNodes().contains(new DataNode("ds_1", "t_order_item_1")));
         assertThat(itemRule.getTableShardingStrategy(), instanceOf(InlineShardingStrategy.class));
         assertThat(itemRule.getTableShardingStrategy().getShardingColumns().iterator().next(), is("order_id"));
-        assertThat(itemRule.getGenerateKeyColumn(), is("order_item_id"));
+        assertTrue(itemRule.getGenerateKeyColumn().isPresent());
+        assertThat(itemRule.getGenerateKeyColumn().get(), is("order_item_id"));
         assertThat(itemRule.getTableShardingStrategy(), instanceOf(InlineShardingStrategy.class));
         assertThat(itemRule.getTableShardingStrategy().getShardingColumns().iterator().next(), is("order_id"));
         
@@ -136,11 +138,12 @@ public class OrchestrationSpringBootShardingTest {
         assertTrue(itemRule.getActualDataNodes().contains(new DataNode("ds_1", "t_order_item_1")));
         assertThat(itemRule.getTableShardingStrategy(), instanceOf(InlineShardingStrategy.class));
         assertThat(itemRule.getTableShardingStrategy().getShardingColumns().iterator().next(), is("order_id"));
-        assertThat(itemRule.getGenerateKeyColumn(), is("order_item_id"));
+        assertTrue(itemRule.getGenerateKeyColumn().isPresent());
+        assertThat(itemRule.getGenerateKeyColumn().get(), is("order_item_id"));
         assertThat(itemRule.getTableShardingStrategy(), instanceOf(InlineShardingStrategy.class));
         assertThat(itemRule.getTableShardingStrategy().getShardingColumns().iterator().next(), is("order_id"));
-        assertThat(orderRule.getGenerateKeyColumn(), is("order_id"));
-        
+        assertTrue(orderRule.getGenerateKeyColumn().isPresent());
+        assertThat(orderRule.getGenerateKeyColumn().get(), is("order_id"));
     }
     
     @Test

sharding-spring/sharding-jdbc-orchestration-spring/sharding-jdbc-orchestration-spring-namespace/src/test/java/org/apache/shardingsphere/shardingjdbc/orchestration/spring/OrchestrationShardingNamespaceTest.java

@@ -96,7 +96,8 @@ public class OrchestrationShardingNamespaceTest extends AbstractJUnit4SpringCont
                 new String[]{applicationContext.getBean("standardStrategy", StandardShardingStrategyConfiguration.class).getShardingColumn()}));
         assertTrue(Arrays.equals(tableRule.getTableShardingStrategy().getShardingColumns().toArray(new String[]{}),
                 new String[]{applicationContext.getBean("inlineStrategy", InlineShardingStrategyConfiguration.class).getShardingColumn()}));
-        assertThat(tableRule.getGenerateKeyColumn(), is("order_id"));
+        assertTrue(tableRule.getGenerateKeyColumn().isPresent());
+        assertThat(tableRule.getGenerateKeyColumn().get(), is("order_id"));
         assertThat(tableRule.getShardingKeyGenerator().getClass().getName(), is(IncrementKeyGenerator.class.getCanonicalName()));
     }
     

sharding-spring/sharding-jdbc-spring/sharding-jdbc-spring-boot-starter/src/test/java/org/apache/shardingsphere/shardingjdbc/spring/boot/type/SpringBootShardingTest.java

@@ -105,7 +105,8 @@ public class SpringBootShardingTest {
         assertTrue(tableRule1.getActualDataNodes().contains(new DataNode("ds_1", "t_order_1")));
         assertThat(tableRule1.getTableShardingStrategy(), instanceOf(InlineShardingStrategy.class));
         assertThat(tableRule1.getTableShardingStrategy().getShardingColumns().iterator().next(), is("order_id"));
-        assertThat(tableRule1.getGenerateKeyColumn(), is("order_id"));
+        assertTrue(tableRule1.getGenerateKeyColumn().isPresent());
+        assertThat(tableRule1.getGenerateKeyColumn().get(), is("order_id"));
         TableRule tableRule2 = shardingRule.getTableRule("t_order_item");
         assertThat(tableRule2.getActualDataNodes().size(), is(4));
         assertTrue(tableRule2.getActualDataNodes().contains(new DataNode("ds_0", "t_order_item_0")));
@@ -114,7 +115,8 @@ public class SpringBootShardingTest {
         assertTrue(tableRule2.getActualDataNodes().contains(new DataNode("ds_1", "t_order_item_1")));
         assertThat(tableRule1.getTableShardingStrategy(), instanceOf(InlineShardingStrategy.class));
         assertThat(tableRule1.getTableShardingStrategy().getShardingColumns().iterator().next(), is("order_id"));
-        assertThat(tableRule2.getGenerateKeyColumn(), is("order_item_id"));
+        assertTrue(tableRule2.getGenerateKeyColumn().isPresent());
+        assertThat(tableRule2.getGenerateKeyColumn().get(), is("order_item_id"));
     }
     
     @Test
@@ -131,7 +133,8 @@ public class SpringBootShardingTest {
         assertTrue(tableRule1.getActualDataNodes().contains(new DataNode("ds_1", "t_order_1")));
         assertThat(tableRule1.getTableShardingStrategy(), instanceOf(InlineShardingStrategy.class));
         assertThat(tableRule1.getTableShardingStrategy().getShardingColumns().iterator().next(), is("order_id"));
-        assertThat(tableRule1.getGenerateKeyColumn(), is("order_id"));
+        assertTrue(tableRule1.getGenerateKeyColumn().isPresent());
+        assertThat(tableRule1.getGenerateKeyColumn().get(), is("order_id"));
         TableRule tableRule2 = shardingRule.getTableRule("t_order_item");
         assertThat(tableRule2.getLogicTable(), is("t_order_item"));
         assertThat(tableRule2.getActualDataNodes().size(), is(4));
@@ -141,7 +144,8 @@ public class SpringBootShardingTest {
         assertTrue(tableRule2.getActualDataNodes().contains(new DataNode("ds_1", "t_order_item_1")));
         assertThat(tableRule1.getTableShardingStrategy(), instanceOf(InlineShardingStrategy.class));
         assertThat(tableRule1.getTableShardingStrategy().getShardingColumns().iterator().next(), is("order_id"));
-        assertThat(tableRule2.getGenerateKeyColumn(), is("order_item_id"));
+        assertTrue(tableRule2.getGenerateKeyColumn().isPresent());
+        assertThat(tableRule2.getGenerateKeyColumn().get(), is("order_item_id"));
     }
     
     @Test

sharding-spring/sharding-jdbc-spring/sharding-jdbc-spring-namespace/src/test/java/org/apache/shardingsphere/shardingjdbc/spring/GenerateKeyJUnitTest.java

@@ -77,9 +77,11 @@ public class GenerateKeyJUnitTest extends AbstractSpringJUnitTest {
         assertThat(((Collection<TableRule>) tableRules).size(), is(2));
         Iterator<TableRule> tableRuleIterator = ((Collection<TableRule>) tableRules).iterator();
         TableRule orderRule = tableRuleIterator.next();
-        assertThat(orderRule.getGenerateKeyColumn(), is("order_id"));
+        assertTrue(orderRule.getGenerateKeyColumn().isPresent());
+        assertThat(orderRule.getGenerateKeyColumn().get(), is("order_id"));
         TableRule orderItemRule = tableRuleIterator.next();
-        assertThat(orderItemRule.getGenerateKeyColumn(), is("order_item_id"));
+        assertTrue(orderItemRule.getGenerateKeyColumn().isPresent());
+        assertThat(orderItemRule.getGenerateKeyColumn().get(), is("order_item_id"));
         assertTrue(orderItemRule.getShardingKeyGenerator() instanceof DecrementKeyGenerator);
     }
 }

sharding-spring/sharding-jdbc-spring/sharding-jdbc-spring-namespace/src/test/java/org/apache/shardingsphere/shardingjdbc/spring/ShardingNamespaceTest.java

@@ -175,7 +175,8 @@ public class ShardingNamespaceTest extends AbstractJUnit4SpringContextTests {
                 new String[]{applicationContext.getBean("standardStrategy", StandardShardingStrategyConfiguration.class).getShardingColumn()}));
         assertTrue(Arrays.equals(tableRule.getTableShardingStrategy().getShardingColumns().toArray(new String[]{}), 
                 new String[]{applicationContext.getBean("inlineStrategy", InlineShardingStrategyConfiguration.class).getShardingColumn()}));
-        assertThat(tableRule.getGenerateKeyColumn(), is("order_id"));
+        assertTrue(tableRule.getGenerateKeyColumn().isPresent());
+        assertThat(tableRule.getGenerateKeyColumn().get(), is("order_id"));
         assertThat(tableRule.getShardingKeyGenerator(), instanceOf(IncrementKeyGenerator.class));
     }
     

shardingsphere-sql-parser/shardingsphere-sql-parser-binder/src/main/java/org/apache/shardingsphere/sql/parser/binder/metadata/column/ColumnMetaData.java

@@ -36,4 +36,6 @@ public class ColumnMetaData {
     private final String dataType;
     
     private final boolean primaryKey;
+    
+    private final boolean generated;
 }

shardingsphere-sql-parser/shardingsphere-sql-parser-binder/src/main/java/org/apache/shardingsphere/sql/parser/binder/metadata/column/ColumnMetaDataLoader.java

@@ -57,7 +57,8 @@ public final class ColumnMetaDataLoader {
                 String columnName = resultSet.getString(COLUMN_NAME);
                 String columnType = resultSet.getString(TYPE_NAME);
                 boolean isPrimaryKey = primaryKeys.contains(columnName);
-                result.add(new ColumnMetaData(columnName, columnType, isPrimaryKey));
+                // TODO load auto generated from database meta data
+                result.add(new ColumnMetaData(columnName, columnType, isPrimaryKey, false));
             }
         }
         return result;

shardingsphere-sql-parser/shardingsphere-sql-parser-binder/src/test/java/org/apache/shardingsphere/sql/parser/binder/metadata/table/SchemaMetaDataTest.java

@@ -74,19 +74,19 @@ public final class SchemaMetaDataTest {
     
     @Test
     public void assertContainsColumn() {
-        TableMetaData tableMetaData = new TableMetaData(Collections.singletonList(new ColumnMetaData("col", "dataType", false)), Collections.emptyList());
+        TableMetaData tableMetaData = new TableMetaData(Collections.singletonList(new ColumnMetaData("col", "dataType", false, false)), Collections.emptyList());
         assertTrue(new SchemaMetaData(ImmutableMap.of("tbl", tableMetaData)).containsColumn("tbl", "col"));
     }
     
     @Test
     public void assertGetAllColumnNamesWhenContainsKey() {
-        TableMetaData tableMetaData = new TableMetaData(Collections.singletonList(new ColumnMetaData("col", "dataType", false)), Collections.emptyList());
+        TableMetaData tableMetaData = new TableMetaData(Collections.singletonList(new ColumnMetaData("col", "dataType", false, false)), Collections.emptyList());
         assertThat(new SchemaMetaData(ImmutableMap.of("tbl", tableMetaData)).getAllColumnNames("tbl"), is(Collections.singletonList("col")));
     }
     
     @Test
     public void assertGetAllColumnNamesWhenNotContainsKey() {
-        TableMetaData tableMetaData = new TableMetaData(Collections.singletonList(new ColumnMetaData("col", "dataType", false)), Collections.emptyList());
+        TableMetaData tableMetaData = new TableMetaData(Collections.singletonList(new ColumnMetaData("col", "dataType", false, false)), Collections.emptyList());
         assertThat(new SchemaMetaData(ImmutableMap.of("tbl1", tableMetaData)).getAllColumnNames("tbl2"), is(Collections.<String>emptyList()));
     }
 }