From bd790a55c0e8f13784872b44c63804c66f34805e Mon Sep 17 00:00:00 2001 From: Tony Green Date: Fri, 24 Feb 2017 15:29:03 +0800 Subject: [PATCH] Add index function when create tables. --- .../main/java/org/litepal/LitePalBase.java | 7 +++-- .../java/org/litepal/annotation/Column.java | 5 +++ .../tablemanager/AssociationCreator.java | 28 +++++++++++++++-- .../tablemanager/AssociationUpdater.java | 20 +++++++----- .../org/litepal/tablemanager/Creator.java | 31 +++++++++++++++---- .../org/litepal/tablemanager/Generator.java | 12 ++++--- .../org/litepal/tablemanager/Upgrader.java | 12 +++---- .../tablemanager/model/ColumnModel.java | 17 ++++++++-- .../main/java/org/litepal/util/DBUtility.java | 4 +-- 9 files changed, 103 insertions(+), 33 deletions(-) diff --git a/litepal/src/main/java/org/litepal/LitePalBase.java b/litepal/src/main/java/org/litepal/LitePalBase.java index 7f3ea47..8cf287d 100644 --- a/litepal/src/main/java/org/litepal/LitePalBase.java +++ b/litepal/src/main/java/org/litepal/LitePalBase.java @@ -674,18 +674,21 @@ public abstract class LitePalBase { String columnType = getColumnType(fieldType); boolean nullable = true; boolean unique = false; + boolean hasIndex = false; String defaultValue = ""; Column annotation = field.getAnnotation(Column.class); if (annotation != null) { nullable = annotation.nullable(); unique = annotation.unique(); + hasIndex = annotation.index(); defaultValue = annotation.defaultValue(); } ColumnModel columnModel = new ColumnModel(); columnModel.setColumnName(DBUtility.convertToValidColumnName(field.getName())); columnModel.setColumnType(columnType); - columnModel.setIsNullable(nullable); - columnModel.setIsUnique(unique); + columnModel.setNullable(nullable); + columnModel.setUnique(unique); + columnModel.setHasIndex(hasIndex); columnModel.setDefaultValue(defaultValue); return columnModel; } diff --git a/litepal/src/main/java/org/litepal/annotation/Column.java b/litepal/src/main/java/org/litepal/annotation/Column.java index 81179b0..3fb358a 100644 --- a/litepal/src/main/java/org/litepal/annotation/Column.java +++ b/litepal/src/main/java/org/litepal/annotation/Column.java @@ -51,4 +51,9 @@ public @interface Column { */ boolean ignore() default false; + /** + * Set index for the column. + */ + boolean index() default false; + } diff --git a/litepal/src/main/java/org/litepal/tablemanager/AssociationCreator.java b/litepal/src/main/java/org/litepal/tablemanager/AssociationCreator.java index 9f08abc..a2ea639 100644 --- a/litepal/src/main/java/org/litepal/tablemanager/AssociationCreator.java +++ b/litepal/src/main/java/org/litepal/tablemanager/AssociationCreator.java @@ -122,6 +122,27 @@ public abstract class AssociationCreator extends Generator { return "drop table if exists " + tableName; } + /** + * Generate SQLs for creating index on a table. + * + * @param tableName + * The table name. + * @param columnModels + * A list contains all column models with column info. + * @return SQLs to create index. + */ + protected List generateCreateIndexSQL(String tableName, List columnModels) { + List createIndexSQLs = new ArrayList(); + for (ColumnModel columnModel : columnModels) { + if (columnModel.isHasIndex()) { + String sql = "create index " + tableName + "_" + columnModel.getColumnName() + "_index" + + " on " + tableName + "(" + columnModel.getColumnName() + ")"; + createIndexSQLs.add(sql); + } + } + return createIndexSQLs; + } + /** * Generate a SQL for add new column into the existing table. * @param tableName @@ -332,7 +353,7 @@ public abstract class AssociationCreator extends Generator { } else { sqls.add(generateCreateTableSQL(intermediateTableName, columnModelList, false)); } - execute(sqls.toArray(new String[0]), db); + execute(sqls, db); giveTableSchemaACopy(intermediateTableName, Const.TableSchema.INTERMEDIATE_JOIN_TABLE, db); } @@ -370,7 +391,7 @@ public abstract class AssociationCreator extends Generator { } else { sqls.add(generateCreateTableSQL(tableName, columnModelList, false)); } - execute(sqls.toArray(new String[0]), db); + execute(sqls, db); giveTableSchemaACopy(tableName, Const.TableSchema.GENERIC_TABLE, db); } @@ -405,7 +426,8 @@ public abstract class AssociationCreator extends Generator { ColumnModel columnModel = new ColumnModel(); columnModel.setColumnName(foreignKeyColumn); columnModel.setColumnType("integer"); - String[] sqls = { generateAddColumnSQL(tableHoldsForeignKey, columnModel) }; + List sqls = new ArrayList(); + sqls.add(generateAddColumnSQL(tableHoldsForeignKey, columnModel)); execute(sqls, db); } else { LogUtil.d(TAG, "column " + foreignKeyColumn diff --git a/litepal/src/main/java/org/litepal/tablemanager/AssociationUpdater.java b/litepal/src/main/java/org/litepal/tablemanager/AssociationUpdater.java index 8744e40..7b6d837 100644 --- a/litepal/src/main/java/org/litepal/tablemanager/AssociationUpdater.java +++ b/litepal/src/main/java/org/litepal/tablemanager/AssociationUpdater.java @@ -140,9 +140,9 @@ public abstract class AssociationUpdater extends Creator { */ protected void dropTables(List dropTableNames, SQLiteDatabase db) { if (dropTableNames != null && !dropTableNames.isEmpty()) { - String[] dropTableSQLS = new String[dropTableNames.size()]; - for (int i = 0; i < dropTableSQLS.length; i++) { - dropTableSQLS[i] = generateDropTableSQL(dropTableNames.get(i)); + List dropTableSQLS = new ArrayList(); + for (int i = 0; i < dropTableNames.size(); i++) { + dropTableSQLS.add(generateDropTableSQL(dropTableNames.get(i))); } execute(dropTableSQLS, db); } @@ -185,7 +185,8 @@ public abstract class AssociationUpdater extends Creator { deleteData.append("=").append(" lower('").append(tableName).append("')"); } LogUtil.d(TAG, "clear table schema value sql is " + deleteData); - String[] sqls = { deleteData.toString() }; + List sqls = new ArrayList(); + sqls.add(deleteData.toString()); execute(sqls, mDb); } } @@ -415,10 +416,10 @@ public abstract class AssociationUpdater extends Creator { * The column names need to remove. * @param tableName * The table name to remove from. - * @return A SQL array contains create temporary table, create new table, + * @return A SQL list contains create temporary table, create new table, * migrate data and drop temporary table. */ - private String[] getRemoveColumnSQLs(Collection removeColumnNames, String tableName) { + private List getRemoveColumnSQLs(Collection removeColumnNames, String tableName) { TableModel tableModelFromDB = getTableModelFromDB(tableName); String alterToTempTableSQL = generateAlterToTempTableSQL(tableName); LogUtil.d(TAG, "generateRemoveColumnSQL >> " + alterToTempTableSQL); @@ -428,8 +429,11 @@ public abstract class AssociationUpdater extends Creator { LogUtil.d(TAG, "generateRemoveColumnSQL >> " + dataMigrationSQL); String dropTempTableSQL = generateDropTempTableSQL(tableName); LogUtil.d(TAG, "generateRemoveColumnSQL >> " + dropTempTableSQL); - String[] sqls = { alterToTempTableSQL, createNewTableSQL, dataMigrationSQL, - dropTempTableSQL }; + List sqls = new ArrayList(); + sqls.add(alterToTempTableSQL); + sqls.add(createNewTableSQL); + sqls.add(dataMigrationSQL); + sqls.add(dropTempTableSQL); return sqls; } diff --git a/litepal/src/main/java/org/litepal/tablemanager/Creator.java b/litepal/src/main/java/org/litepal/tablemanager/Creator.java index 2b1acfb..895ef21 100644 --- a/litepal/src/main/java/org/litepal/tablemanager/Creator.java +++ b/litepal/src/main/java/org/litepal/tablemanager/Creator.java @@ -22,6 +22,9 @@ import org.litepal.util.DBUtility; import android.database.sqlite.SQLiteDatabase; +import java.util.ArrayList; +import java.util.List; + /** * This is a subclass of Generator. Use to create tables. It will automatically * build a create table SQL based on the passing TableModel object. In case of @@ -66,17 +69,21 @@ class Creator extends AssociationCreator { * @return A SQL array contains drop table if it exists and create new * table. */ - protected String[] getCreateTableSQLs(TableModel tableModel, SQLiteDatabase db, boolean force) { + protected List getCreateTableSQLs(TableModel tableModel, SQLiteDatabase db, boolean force) { + List sqls = new ArrayList(); if (force) { - return new String[] { generateDropTableSQL(tableModel), - generateCreateTableSQL(tableModel) }; + sqls.add(generateDropTableSQL(tableModel)); + sqls.add(generateCreateTableSQL(tableModel)); + sqls.addAll(generateCreateIndexSQLs(tableModel)); } else { if (DBUtility.isTableExists(tableModel.getTableName(), db)) { return null; } else { - return new String[] { generateCreateTableSQL(tableModel) }; + sqls.add(generateCreateTableSQL(tableModel)); + sqls.addAll(generateCreateIndexSQLs(tableModel)); } } + return sqls; } /** @@ -86,7 +93,7 @@ class Creator extends AssociationCreator { * The table model. * @return A SQL to drop table. */ - protected String generateDropTableSQL(TableModel tableModel) { + private String generateDropTableSQL(TableModel tableModel) { return generateDropTableSQL(tableModel.getTableName()); } @@ -100,8 +107,20 @@ class Creator extends AssociationCreator { * generate SQL. * @return A generated create table SQL. */ - protected String generateCreateTableSQL(TableModel tableModel) { + String generateCreateTableSQL(TableModel tableModel) { return generateCreateTableSQL(tableModel.getTableName(), tableModel.getColumnModels(), true); } + /** + * Generate create index SQLs by analyzing the TableModel. + * + * @param tableModel + * Use the TableModel to get table name and columns name to + * generate SQL. + * @return generated create index SQLs. + */ + private List generateCreateIndexSQLs(TableModel tableModel) { + return generateCreateIndexSQL(tableModel.getTableName(), tableModel.getColumnModels()); + } + } diff --git a/litepal/src/main/java/org/litepal/tablemanager/Generator.java b/litepal/src/main/java/org/litepal/tablemanager/Generator.java index 4d37f31..cb92dd9 100644 --- a/litepal/src/main/java/org/litepal/tablemanager/Generator.java +++ b/litepal/src/main/java/org/litepal/tablemanager/Generator.java @@ -18,6 +18,7 @@ package org.litepal.tablemanager; import java.util.ArrayList; import java.util.Collection; +import java.util.List; import org.litepal.LitePalBase; import org.litepal.exceptions.DatabaseGenerateException; @@ -28,6 +29,7 @@ import org.litepal.util.BaseUtility; import android.database.SQLException; import android.database.sqlite.SQLiteDatabase; +import android.text.TextUtils; /** * This class is the basic class for managing database dynamically. It is used @@ -100,13 +102,15 @@ public abstract class Generator extends LitePalBase { * * @throws org.litepal.exceptions.DatabaseGenerateException */ - protected void execute(String[] sqls, SQLiteDatabase db) { + protected void execute(List sqls, SQLiteDatabase db) { String throwSQL = ""; try { - if (sqls != null) { + if (sqls != null && !sqls.isEmpty()) { for (String sql : sqls) { - throwSQL = sql; - db.execSQL(BaseUtility.changeCase(sql)); + if (!TextUtils.isEmpty(sql)) { + throwSQL = BaseUtility.changeCase(sql); + db.execSQL(throwSQL); + } } } } catch (SQLException e) { diff --git a/litepal/src/main/java/org/litepal/tablemanager/Upgrader.java b/litepal/src/main/java/org/litepal/tablemanager/Upgrader.java index 6c5d5d4..ee8784e 100644 --- a/litepal/src/main/java/org/litepal/tablemanager/Upgrader.java +++ b/litepal/src/main/java/org/litepal/tablemanager/Upgrader.java @@ -244,14 +244,14 @@ public class Upgrader extends AssociationUpdater { * * @param columnModelList * List with ColumnModel to add new column. - * @return A SQL array contains add all new columns job. + * @return A SQL list contains add all new columns job. */ - private String[] getAddColumnSQLs(List columnModelList) { + private List getAddColumnSQLs(List columnModelList) { List sqls = new ArrayList(); for (ColumnModel columnModel : columnModelList) { sqls.add(generateAddColumnSQL(columnModel)); } - return sqls.toArray(new String[0]); + return sqls; } /** @@ -316,10 +316,10 @@ public class Upgrader extends AssociationUpdater { /** * This method create a SQL array for the whole changing column constraints job. - * @return A SQL array contains create temporary table, create new table, add foreign keys, + * @return A SQL list contains create temporary table, create new table, add foreign keys, * migrate data and drop temporary table. */ - private String[] getChangeColumnsConstraintsSQL() { + private List getChangeColumnsConstraintsSQL() { String alterToTempTableSQL = generateAlterToTempTableSQL(mTableModel.getTableName()); String createNewTableSQL = generateCreateTableSQL(mTableModel); List addForeignKeySQLs = generateAddForeignKeySQL(); @@ -336,7 +336,7 @@ public class Upgrader extends AssociationUpdater { LogUtil.d(TAG, sql); } LogUtil.d(TAG, "<< generateChangeConstraintSQL"); - return sqls.toArray(new String[0]); + return sqls; } /** diff --git a/litepal/src/main/java/org/litepal/tablemanager/model/ColumnModel.java b/litepal/src/main/java/org/litepal/tablemanager/model/ColumnModel.java index dbe694e..1a6043d 100644 --- a/litepal/src/main/java/org/litepal/tablemanager/model/ColumnModel.java +++ b/litepal/src/main/java/org/litepal/tablemanager/model/ColumnModel.java @@ -46,6 +46,11 @@ public class ColumnModel { */ private boolean isUnique = false; + /** + * Column has index or not. + */ + private boolean hasIndex = false; + /** * Default constraint. */ @@ -71,7 +76,7 @@ public class ColumnModel { return isNullable; } - public void setIsNullable(boolean isNullable) { + public void setNullable(boolean isNullable) { this.isNullable = isNullable; } @@ -79,10 +84,18 @@ public class ColumnModel { return isUnique; } - public void setIsUnique(boolean isUnique) { + public void setUnique(boolean isUnique) { this.isUnique = isUnique; } + public boolean isHasIndex() { + return hasIndex; + } + + public void setHasIndex(boolean hasIndex) { + this.hasIndex = hasIndex; + } + public String getDefaultValue() { return defaultValue; } diff --git a/litepal/src/main/java/org/litepal/util/DBUtility.java b/litepal/src/main/java/org/litepal/util/DBUtility.java index f14d2d9..82ac901 100644 --- a/litepal/src/main/java/org/litepal/util/DBUtility.java +++ b/litepal/src/main/java/org/litepal/util/DBUtility.java @@ -374,8 +374,8 @@ public class DBUtility { String defaultValue = cursor.getString(cursor.getColumnIndexOrThrow("dflt_value")); columnModel.setColumnName(name); columnModel.setColumnType(type); - columnModel.setIsNullable(nullable); - columnModel.setIsUnique(unique); + columnModel.setNullable(nullable); + columnModel.setUnique(unique); if (defaultValue != null) { defaultValue = defaultValue.replace("'", ""); } else { -- GitLab