refactor dbo build

.idea/kotlinc.xml

+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="KotlinCommonCompilerArguments">
+    <option name="languageVersion" value="1.1" />
+    <option name="apiVersion" value="1.1" />
+  </component>
+</project>

.idea/misc.xml

   <component name="EntryPointsManager">
     <entry_points version="2.0" />
   </component>
-  <component name="ProjectLevelVcsManager" settingsEditedManually="false">
-    <OptionsSetting value="true" id="Add" />
-    <OptionsSetting value="true" id="Remove" />
-    <OptionsSetting value="true" id="Checkout" />
-    <OptionsSetting value="true" id="Update" />
-    <OptionsSetting value="true" id="Status" />
-    <OptionsSetting value="true" id="Edit" />
-    <ConfirmationsSetting value="0" id="Add" />
-    <ConfirmationsSetting value="0" id="Remove" />
-  </component>
-  <component name="ProjectRootManager" version="2" languageLevel="JDK_1_8" default="false" assert-keyword="true" jdk-15="true" project-jdk-name="IntelliJ IDEA IU-162.2032.8" project-jdk-type="IDEA JDK">
+  <component name="ProjectRootManager" version="2" languageLevel="JDK_1_8" default="false" project-jdk-name="IntelliJ IDEA IU-162.2032.8" project-jdk-type="IDEA JDK">
     <output url="file://$PROJECT_DIR$/out" />
   </component>
 </project>

src/com/rthoni/intellij/codefromds/DataAccess/DataSourcesDataAccess.java

+package com.rthoni.intellij.codefromds.DataAccess;
+
+import com.intellij.database.psi.*;
+import com.intellij.database.util.DasUtil;
+import com.rthoni.intellij.codefromds.business.Helper;
+import com.rthoni.intellij.codefromds.dbo.template.*;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+/**
+ * Created by robin on 4/13/17.
+ */
+public class DataSourcesDataAccess {
+
+    public static List<DataSourceDbo> getDataSourcesDbo()
+    {
+        return Helper.getDataSources().stream()
+                .map(DataSourcesDataAccess::dataSourceToDbo)
+                .collect(Collectors.toList());
+    }
+
+    public static DataSourceDbo getDataSourceDbo(String name)
+    {
+        return Helper.getDataSources().stream()
+                .filter(dataSource -> dataSource.getName().equals(name))
+                .map(DataSourcesDataAccess::dataSourceToDbo)
+                .findFirst().orElse(null);
+    }
+
+    private static DataSourceDbo dataSourceToDbo(DbDataSource dataSource)
+    {
+        DataSourceDbo dataSourceDbo = new DataSourceDbo();
+        dataSourceDbo.setName(dataSource.getName());
+
+        final DataHolder<TableDataSourceDbo> tableDataSourceDbo = new DataHolder<>();
+        final DataHolder<ColumnDataSourceDbo> columnDataSourceDbo = new DataHolder<>();
+
+        dataSource.getModel().traverser().forEach(dasObject ->
+        {
+            if (dasObject instanceof DbTable) {
+                DbTable table = (DbTable) dasObject;
+                tableDataSourceDbo.data = new TableDataSourceDbo();
+                tableDataSourceDbo.data.setName(table.getName());
+                dataSourceDbo.addTable(tableDataSourceDbo.data);
+            }
+            else if (dasObject instanceof DbColumn) {
+                DbColumn column = (DbColumn) dasObject;
+                columnDataSourceDbo.data = new ColumnDataSourceDbo();
+                columnDataSourceDbo.data.setName(column.getName());
+                columnDataSourceDbo.data.setNotNull(column.isNotNull());
+                SqlTypeDbo type = new SqlTypeDbo();
+                type.setType(column.getDataType().typeName);
+                type.setVagueArg(column.getDataType().vagueArg);
+                columnDataSourceDbo.data.setSqlType(type);
+                columnDataSourceDbo.data.setDefaultValue(column.getDefault());
+                columnDataSourceDbo.data.setPrimary(DasUtil.isPrimary(column));
+                columnDataSourceDbo.data.setSelected(false);
+                columnDataSourceDbo.data.setTypeNotNull(false);
+                columnDataSourceDbo.data.setType(null);
+                tableDataSourceDbo.data.addColumn(columnDataSourceDbo.data);
+            }
+        });
+
+        dataSource.getModel().traverser().forEach(dasObject ->
+        {
+            if (dasObject instanceof DbTable) {
+                DbTable table = (DbTable) dasObject;
+                tableDataSourceDbo.data = dataSourceDbo.findTable(table.getName());
+                System.out.println("Table: " + tableDataSourceDbo.data.getName());
+                DasUtil.getForeignKeys(table).forEach(fk ->
+                {
+                    if (fk.getRefTable() == null) {
+                        return;
+                    }
+
+                    TableDataSourceDbo srcTable = dataSourceDbo.findTable(fk.getTable().getName());
+                    TableDataSourceDbo targetTable = dataSourceDbo.findTable(fk.getRefTable().getName());
+
+                    ForeignKeyDbo fkDbo = new ForeignKeyDbo();
+                    fkDbo.setName(fk.getName());
+                    fkDbo.setSourceTable(srcTable);
+                    fkDbo.setSourceForeignKeyName("fk_" + targetTable.getName());//TODO find if it already exists
+                    fkDbo.setTargetTable(targetTable);
+                    fkDbo.setTargetForeignKeyName(srcTable.getName() + "_fk");//TODO find if it already exists
+
+                    fk.getColumnsRef().names().forEach(s -> fkDbo.addSourceColumn(srcTable.findColumn(s)));
+                    fk.getRefColumns().names().forEach(s -> fkDbo.addTargetColumn(targetTable.findColumn(s)));
+
+                    srcTable.addSourceForeignKey(fkDbo);
+                    targetTable.addTargetForeignKey(fkDbo);
+
+                    System.out.println("FK: " + fkDbo.getName());
+                });
+            }
+            else if (dasObject instanceof DbColumn) {
+                DbColumn column = (DbColumn) dasObject;
+                columnDataSourceDbo.data = tableDataSourceDbo.data.findColumn(column.getName());
+                System.out.println("Column: " + columnDataSourceDbo.data.getName());
+            }
+            else if (dasObject instanceof DbIndex) {
+                DbIndex index = (DbIndex) dasObject;
+                System.out.println("Index: " + index.getName());
+            }
+            else if (dasObject instanceof DbConstraint) {
+                DbConstraint constraint = (DbConstraint) dasObject;
+                System.out.println("Constraint: " + constraint.getName());
+            }
+            else if (dasObject instanceof DbRoutine) {
+                DbRoutine sp = (DbRoutine) dasObject;
+                System.out.println("SP: " + sp.getName());
+            }
+            else {
+                System.out.println(dasObject.getClass().getName());
+            }
+        });
+        return dataSourceDbo;
+    }
+}

src/com/rthoni/intellij/codefromds/business/DataSourcesBusiness.java

+package com.rthoni.intellij.codefromds.business;
+
+import com.rthoni.intellij.codefromds.DataAccess.DataSourcesDataAccess;
+import com.rthoni.intellij.codefromds.dbo.template.DataSourceDbo;
+
+import java.util.List;
+
+/**
+ * Created by robin on 4/12/17.
+ */
+public class DataSourcesBusiness {
+
+    public static List<DataSourceDbo> getDataSourcesDbo()
+    {
+        return DataSourcesDataAccess.getDataSourcesDbo();
+    }
+
+    public static DataSourceDbo getDataSourceDbo(String name)
+    {
+        return DataSourcesDataAccess.getDataSourceDbo(name);
+    }
+
+}

src/com/rthoni/intellij/codefromds/business/Generator.java

 package com.rthoni.intellij.codefromds.business;
 
-import com.intellij.database.model.DasForeignKey;
-import com.intellij.database.model.DataType;
-import com.intellij.database.model.MultiRef;
 import com.intellij.database.psi.DbDataSource;
-import com.intellij.database.util.DasUtil;
 import com.intellij.openapi.project.Project;
 import com.rthoni.intellij.codefromds.dbo.options.ColumnSelection;
 import com.rthoni.intellij.codefromds.dbo.options.GenerateOptions;
 import com.rthoni.intellij.codefromds.dbo.options.TypesCastOptions;
 import com.rthoni.intellij.codefromds.dbo.template.ColumnDataSourceDbo;
 import com.rthoni.intellij.codefromds.dbo.template.DataSourceDbo;
-import com.rthoni.intellij.codefromds.dbo.template.ForeignKeyDbo;
+import com.rthoni.intellij.codefromds.dbo.template.SqlTypeDbo;
 import com.rthoni.intellij.codefromds.dbo.template.TableDataSourceDbo;
 import org.json.JSONArray;
 import org.json.JSONObject;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Vector;
-import java.util.stream.Collectors;
-import java.util.stream.StreamSupport;
 
 /**
  * Created by robin on 11/15/16.
         return options;
     }
 
-    public static ForeignKeyDbo convertForeignKey(DasForeignKey fk, DataSourceDbo source)
+    public static String convertSqlType(SqlTypeDbo type, TypesCastOptions options)
     {
-        ForeignKeyDbo dbo = new ForeignKeyDbo();
-
-        dbo.setName(fk.getName());
-
-        dbo.setSourceForeignKeyName("fk_" + fk.getRefTable().getName());
-        dbo.setSourceTable(source.getTables().stream().filter(t -> t.getName().equals(fk.getTable().getName())).findFirst().get());
-        MultiRef columnsRef = fk.getColumnsRef();
-        dbo.setSourceColumns(dbo.getSourceTable().getColumns().stream().filter(c -> StreamSupport.stream(columnsRef.names().spliterator(), false).anyMatch(cc -> cc.equals(c.getName()))).collect(Collectors.toList()));
-
-        dbo.setTargetForeignKeyName(fk.getTable().getName() + "_fk");
-        dbo.setTargetTable(source.getTables().stream().filter(t -> t.getName().equals(fk.getRefTable().getName())).findFirst().get());
-        MultiRef refColumns = fk.getRefColumns();
-        dbo.setTargetColumns(dbo.getTargetTable().getColumns().stream().filter(c -> StreamSupport.stream(refColumns.names().spliterator(), false).anyMatch(cc -> cc.equals(c.getName()))).collect(Collectors.toList()));
-
-        dbo.getTargetTable().getTargetForeignKeys().add(dbo);
-
-        return dbo;
-    }
-
-    public static String convertSqlType(DataType type, TypesCastOptions options)
-    {
-        boolean isArray = type.typeName.endsWith("[]");
-        String sqlTypeName = isArray ? type.typeName.substring(0, type.typeName.length() - 2) : type.typeName;
-        String typeName = type.typeName;
+        boolean isArray = type.getType().endsWith("[]");
+        String sqlTypeName = isArray ? type.getType().substring(0, type.getType().length() - 2) : type.getType();
+        String typeName = type.getType();
         HashMap<String, HashMap<String, String>> types = options.getTypes();
 
         if (types.containsKey(sqlTypeName)) {
             HashMap<String, String> subtype = types.get(sqlTypeName);
-            if (subtype.containsKey(type.vagueArg)) {
-                typeName = subtype.get(type.vagueArg);
+            if (subtype.containsKey(type.getVagueArg())) {
+                typeName = subtype.get(type.getVagueArg());
             }
             else if (subtype.containsKey("*")) {
                 typeName = subtype.get("*");
         }
         return typeName;
     }
-
-    public static ColumnDataSourceDbo convertColumn(ColumnSelection columnSelection, TypesCastOptions options)
-    {
-        ColumnDataSourceDbo dbo = new ColumnDataSourceDbo();
-        dbo.setName(columnSelection.getColumn().getName());
-        dbo.setPrimary(DasUtil.isPrimary(columnSelection.getColumn()));
-        dbo.setSelected(columnSelection.isSelected());
-        dbo.setNotNull(columnSelection.getColumn().isNotNull());
-        dbo.setType(convertSqlType(columnSelection.getColumn().getDataType(), options));
-        dbo.setTypeNotNull(options.getNonNullableTypes().contains(dbo.getType()));
-        dbo.setDefaultValue(columnSelection.getColumn().getDefault());
-
-        return dbo;
-    }
-
-    public static TableDataSourceDbo convertTable(TableSelection tableSelection, TypesCastOptions types)
-    {
-        TableDataSourceDbo dbo = new TableDataSourceDbo();
-        dbo.setName(tableSelection.getTable().getName());
-        dbo.setColumns(tableSelection.getColumns().stream().map(c -> convertColumn(c, types)).collect(Collectors.toList()));
-        dbo.setPrimaryKeys(dbo.getColumns().stream().filter(ColumnDataSourceDbo::isPrimary).collect(Collectors.toList()));
-        dbo.setHasAny(!tableSelection.hasNone());
-        dbo.setTargetForeignKeys(new Vector<>());
-        return dbo;
-    }
+//
+//    public static boolean isUnionSame(List<ColumnDataSourceDbo> part1, List<ColumnDataSourceDbo> part2, List<ColumnDataSourceDbo> list2)
+//    {
+//        List<ColumnDataSourceDbo> list1 = new Vector<>(part1);
+//        for (ColumnDataSourceDbo col : part2) {
+//            if (!list1.contains(col)) {
+//                list1.add(col);
+//            }
+//        }
+//        if (list1.size() != list2.size()) {
+//            return false;
+//        }
+//        list1.sort((o1, o2) -> o1.getName().compareTo(o2.getName()));
+//        list2.sort((o1, o2) -> o1.getName().compareTo(o2.getName()));
+//        return list1.equals(list2);
+//    }
 
     public static DataSourceDbo convertOptions(GenerateOptions options, TypesCastOptions types)
     {
-        DataSourceDbo dbo = new DataSourceDbo();
-
-        dbo.setName(options.getSelection().getSource().getName());
-        dbo.setTables(options.getSelection().getTables().stream().map(t -> convertTable(t, types)).collect(Collectors.toList()));
-
-        List<TableDataSourceDbo> tables = dbo.getTables();
-        List<TableSelection> tableSelections = options.getSelection().getTables();
-        for (int i = 0; i < tables.size(); ++i) {
-            TableDataSourceDbo table = tables.get(i);
-            TableSelection tableSelection = tableSelections.get(i);
-            table.setSourceForeignKeys(DasUtil.getForeignKeys(tableSelection.getTable()).toList().stream().map(t -> convertForeignKey(t, dbo)).collect(Collectors.toList()));
+        String dataSourceName = options.getSelection().getSource().getName();
+        DataSourceDbo dataSourceDbo = DataSourcesBusiness.getDataSourceDbo(dataSourceName);
+
+        for (TableDataSourceDbo table : dataSourceDbo.getTables())
+        {
+            TableSelection tableSelection = options.getSelection().getTables().stream()
+                    .filter(t -> t.getTable().getName().equals(table.getName()))
+                    .findFirst().orElse(null);
+            for (ColumnDataSourceDbo column : table.getColumns())
+            {
+                ColumnSelection columnSelection = tableSelection.getColumns().stream()
+                        .filter(c -> c.getColumn().getName().equals(column.getName()))
+                        .findFirst().orElse(null);
+                column.setType(convertSqlType(column.getSqlType(), types));
+                column.setTypeNotNull(types.getNonNullableTypes().contains(column.getType()));
+                column.setSelected(columnSelection.isSelected());
+            }
         }
 
-        return dbo;
+        return dataSourceDbo;
     }
 
     public static TypesCastOptions loadTypesCast(String file) throws IOException
 
     public static void generate(GenerateOptions options, Project project) throws IOException
     {
+        DataSourcesBusiness.getDataSourcesDbo();
         String modelsAbsolutePath = Helper.getAbsolutePath(project, options.getModelsRelativePath());
         String dataSourceTemplateAbsolutePath = Helper.getAbsolutePath(project, options.getDataSourceTemplateRelativePath());
         String modelsTemplateAbsolutePath = Helper.getAbsolutePath(project, options.getModelsTemplateRelativePath());
         String typesCastAbsolutePath = Helper.getAbsolutePath(project, options.getCastFileRelativePath());
+        String dataSourceAbsolutePath = Helper.getAbsolutePath(project, options.getDataSourceRelativePath());
 
         TypesCastOptions types = loadTypesCast(typesCastAbsolutePath);
 
         DataSourceDbo dbo = convertOptions(options, types);
 
-        generateFile(dataSourceTemplateAbsolutePath, Helper.getAbsolutePath(project, options.getDataSourceRelativePath()), dbo, null);
+        generateFile(dataSourceTemplateAbsolutePath, dataSourceAbsolutePath, dbo, null);
         for (TableDataSourceDbo table : dbo.getTables()) {
             if (table.hasAny()) {
-                generateFile(modelsTemplateAbsolutePath, modelsAbsolutePath + File.separator +
-                        table.getName() + "." + options.getFilesExtension(), dbo, table);
+                String filename = modelsAbsolutePath + File.separator + table.getName() + "." + options.getFilesExtension();
+                generateFile(modelsTemplateAbsolutePath, filename, dbo, table);
             }
         }
     }

src/com/rthoni/intellij/codefromds/business/Helper.java

 import java.util.Arrays;
 import java.util.Collection;
 import java.util.List;
-import java.util.Optional;
 import java.util.stream.Collectors;
 
 /**
 
     public static DbDataSource findDataSource(String name)
     {
-        Optional<DbDataSource> opt = getDataSources().stream().filter(d -> d.getName().equals(name)).findFirst();
-        if (opt.isPresent()) {
-            return opt.get();
-        }
-        return null;
+        return getDataSources().stream().filter(d -> d.getName().equals(name)).findFirst().orElse(null);
     }
 
     public static JSONObject findTableInJson(JSONArray tables, String name)

src/com/rthoni/intellij/codefromds/dbo/template/ColumnDataSourceDbo.java

 
     private String _type;
 
+    private SqlTypeDbo _sqlType;
+
     private boolean _notNull;
 
     private boolean _typeNotNull;
         _type = type;
     }
 
+    public SqlTypeDbo getSqlType() {
+        return _sqlType;
+    }
+
+    public void setSqlType(SqlTypeDbo sqlType) {
+        _sqlType = sqlType;
+    }
+
     public boolean isNotNull() {
         return _notNull;
     }

src/com/rthoni/intellij/codefromds/dbo/template/DataHolder.java

+package com.rthoni.intellij.codefromds.dbo.template;
+
+/**
+ * Created by robin on 4/13/17.
+ */
+public class DataHolder<T> {
+    public T data;
+}

src/com/rthoni/intellij/codefromds/dbo/template/DataSourceDbo.java

 package com.rthoni.intellij.codefromds.dbo.template;
 
 import java.util.List;
+import java.util.Vector;
 
 /**
  * Created by robin on 11/18/16.
 
     private String _name;
 
-    private List<TableDataSourceDbo> _tables;
+    private List<TableDataSourceDbo> _tables = new Vector<>();
 
     public String getName() {
         return _name;
         return _tables;
     }
 
-    public void setTables(List<TableDataSourceDbo> tables) {
-        _tables = tables;
+    public void addTable(TableDataSourceDbo table) {
+        _tables.add(table);
+    }
+
+    public TableDataSourceDbo findTable(String name)
+    {
+        for (TableDataSourceDbo table : _tables) {
+            if (table.getName().equals(name)) {
+                return table;
+            }
+        }
+        return null;
     }
 }

src/com/rthoni/intellij/codefromds/dbo/template/ForeignKeyDbo.java

 package com.rthoni.intellij.codefromds.dbo.template;
 
 import java.util.List;
+import java.util.Vector;
 
 /**
  * Created by robin on 11/18/16.
 
     private TableDataSourceDbo _sourceTable;
 
-    private List<ColumnDataSourceDbo> _sourceColumns;
+    private List<ColumnDataSourceDbo> _sourceColumns = new Vector<>();
 
     private TableDataSourceDbo _targetTable;
 
-    private List<ColumnDataSourceDbo> _targetColumns;
+    private List<ColumnDataSourceDbo> _targetColumns = new Vector<>();
 
     private String _sourceForeignKeyName;
 
     private String _targetForeignKeyName;
 
     private String _name;
+//
+//    private ForeignKeyDbo _other;
+//
+//    private boolean _isOneToOne;
+//
+//    private boolean _isOneToMany;
+//
+//    private boolean _isManyToMany;
 
     public TableDataSourceDbo getSourceTable() {
         return _sourceTable;
         return _sourceColumns;
     }
 
-    public void setSourceColumns(List<ColumnDataSourceDbo> sourceColumns) {
-        _sourceColumns = sourceColumns;
+    public void addSourceColumn(ColumnDataSourceDbo sourceColumns) {
+        _sourceColumns.add(sourceColumns);
     }
 
     public TableDataSourceDbo getTargetTable() {
         return _targetColumns;
     }
 
-    public void setTargetColumns(List<ColumnDataSourceDbo> targetColumns) {
-        _targetColumns = targetColumns;
+    public void addTargetColumn(ColumnDataSourceDbo targetColumns) {
+        _targetColumns.add(targetColumns);
     }
 
     public String getSourceForeignKeyName() {
     public void setName(String name) {
         _name = name;
     }
+
+//    public boolean isOneToOne() {
+//        return _isOneToOne;
+//    }
+//
+//    public void setOneToOne(boolean oneToOne) {
+//        _isOneToOne = oneToOne;
+//        if (_isOneToOne) {
+//            _isOneToMany = true;
+//            _isManyToMany = false;
+//        }
+//    }
+//
+//    public boolean isOneToMany() {
+//        return _isOneToMany;
+//    }
+//
+//    public void setOneToMany(boolean oneToMany) {
+//        _isOneToMany = oneToMany;
+//        if (_isOneToMany) {
+//            _isOneToOne = true;
+//            _isManyToMany = false;
+//        }
+//    }
+//
+//    public boolean isManyToMany() {
+//        return _isManyToMany;
+//    }
+//
+//    public void setManyToMany(boolean manyToMany) {
+//        _isManyToMany = manyToMany;
+//        if (_isManyToMany) {
+//            _isOneToOne = true;
+//            _isOneToMany = false;
+//        }
+//    }
+//
+//    public ForeignKeyDbo getOther() {
+//        return _other;
+//    }
+//
+//    public void setOther(ForeignKeyDbo other) {
+//        _other = other;
+//    }
 }

src/com/rthoni/intellij/codefromds/dbo/template/SqlTypeDbo.java

+package com.rthoni.intellij.codefromds.dbo.template;
+
+/**
+ * Created by robin on 4/13/17.
+ */
+public class SqlTypeDbo {
+
+    private String _type;
+
+    private String vagueArg;
+
+    public String getType() {
+        return _type;
+    }
+
+    public void setType(String type) {
+        _type = type;
+    }
+
+    public String getVagueArg() {
+        return vagueArg;
+    }
+
+    public void setVagueArg(String vagueArg) {
+        this.vagueArg = vagueArg;
+    }
+}

src/com/rthoni/intellij/codefromds/dbo/template/TableDataSourceDbo.java

 package com.rthoni.intellij.codefromds.dbo.template;
 
 import java.util.List;
+import java.util.Vector;
+import java.util.stream.Collectors;
 
 /**
  * Created by robin on 11/18/16.
  */
 public class TableDataSourceDbo {
-    private String _name;
-
-    private List<ColumnDataSourceDbo> _columns;
 
-    private List<ColumnDataSourceDbo> _primaryKeys;
+    private String _name;
 
-    private List<ForeignKeyDbo> _sourceForeignKeys;
+    private List<ColumnDataSourceDbo> _columns = new Vector<>();
 
-    private List<ForeignKeyDbo> _targetForeignKeys;
+    private List<ForeignKeyDbo> _sourceForeignKeys = new Vector<>();
 
-    private boolean _hasAny;
+    private List<ForeignKeyDbo> _targetForeignKeys = new Vector<>();
 
     public String getName() {
         return _name;
         return _columns;
     }
 
-    public void setColumns(List<ColumnDataSourceDbo> columns) {
-        _columns = columns;
+    public void addColumn(ColumnDataSourceDbo column) {
+        _columns.add(column);
     }
 
-    public List<ColumnDataSourceDbo> getPrimaryKeys() {
-        return _primaryKeys;
+    public ColumnDataSourceDbo findColumn(String name)
+    {
+        for (ColumnDataSourceDbo column : _columns) {
+            if (column.getName().equals(name)) {
+                return column;
+            }
+        }
+        return null;
     }
 
-    public void setPrimaryKeys(List<ColumnDataSourceDbo> primaryKeys) {
-        _primaryKeys = primaryKeys;
+    public List<ColumnDataSourceDbo> getPrimaryKeys() {
+        return _columns.stream().filter(ColumnDataSourceDbo::isPrimary).collect(Collectors.toList());
     }
 
     public boolean hasAny() {
-        return _hasAny;
-    }
-
-    public void setHasAny(boolean hasAny) {
-        _hasAny = hasAny;
+        for (ColumnDataSourceDbo column : _columns) {
+            if (column.isSelected()) {
+                return true;
+            }
+        }
+        return false;
     }
 
     public List<ForeignKeyDbo> getSourceForeignKeys() {
         return _sourceForeignKeys;
     }
 
-    public void setSourceForeignKeys(List<ForeignKeyDbo> sourceForeignKeys) {
-        _sourceForeignKeys = sourceForeignKeys;
+    public void addSourceForeignKey(ForeignKeyDbo sourceForeignKeys) {
+        _sourceForeignKeys.add(sourceForeignKeys);
     }
 
     public List<ForeignKeyDbo> getTargetForeignKeys() {
         return _targetForeignKeys;
     }
 
-    public void setTargetForeignKeys(List<ForeignKeyDbo> targetForeignKeys) {
-        _targetForeignKeys = targetForeignKeys;
+    public void addTargetForeignKey(ForeignKeyDbo targetForeignKeys) {
+        _targetForeignKeys.add(targetForeignKeys);
     }
 }