public void resetMigrations() {
open();
String sql = "DROP TABLE IF EXISTS `" + DatabaseBuilder.getTableName(Migration.class) + "`;";
mDb.execSQL(sql);
ModelCache.reset(DatabaseBuilder.getTableName(Migration.class));
close();
}
@Override
public void onCreate(SQLiteDatabase db) {
for (String table : _builder.getTables()) {
String sqlStr = null;
try {
sqlStr = _builder.getSQLCreate(table);
} catch (DataAccessException e) {
EvtLog.e(this.getClass().getName(), e);
}
if (sqlStr != null) db.execSQL(sqlStr);
}
db.setVersion(_version);
}
@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
ArrayList<String> scripts = databaseUpgrade(oldVersion, newVersion);
if (scripts == null || scripts.size() == 0) {
for (String table : _builder.getTables()) {
String sqlStr = _builder.getSQLDrop(table);
db.execSQL(sqlStr);
}
onCreate(db);
} else {
for (int i = 0; i < scripts.size(); ++i) {
String sql = scripts.get(i);
if (!(sql.trim().equals("") || sql.trim().startsWith("--"))) {
db.execSQL(scripts.get(i));
}
}
}
}
/**
* Inflate this entity using the current row from the given cursor.
*
* @param cursor The cursor to get object data from.
* @throws IllegalArgumentException
* @throws IllegalAccessException
* @throws InstantiationException
*/
@SuppressWarnings("unchecked")
void inflate(Cursor cursor) throws ActiveRecordException {
HashMap<Field, Long> entities = new HashMap<Field, Long>();
for (Field field : getColumnFields()) {
try {
String typeString = field.getType().getName();
String colName = CamelNotationHelper.toSQLName(field.getName());
if (typeString.equals("long")) {
field.setLong(this, cursor.getLong(cursor.getColumnIndex(colName)));
} else if (typeString.equals("java.lang.String")) {
String val = cursor.getString(cursor.getColumnIndex(colName));
field.set(this, val.equals("null") ? null : val);
} else if (typeString.equals("double")) {
field.setDouble(this, cursor.getDouble(cursor.getColumnIndex(colName)));
} else if (typeString.equals("boolean")) {
field.setBoolean(this, cursor.getString(cursor.getColumnIndex(colName)).equals("true"));
} else if (typeString.equals("[B")) {
field.set(this, cursor.getBlob(cursor.getColumnIndex(colName)));
} else if (typeString.equals("int")) {
field.setInt(this, cursor.getInt(cursor.getColumnIndex(colName)));
} else if (typeString.equals("float")) {
field.setFloat(this, cursor.getFloat(cursor.getColumnIndex(colName)));
} else if (typeString.equals("short")) {
field.setShort(this, cursor.getShort(cursor.getColumnIndex(colName)));
} else if (typeString.equals("java.sql.Timestamp")) {
long l = cursor.getLong(cursor.getColumnIndex(colName));
field.set(this, new Timestamp(l));
} else if (field.getType().getSuperclass() == ActiveRecordBase.class) {
long id = cursor.getLong(cursor.getColumnIndex(colName));
if (id > 0) entities.put(field, id);
else field.set(this, null);
} else if (field.getType() == List.class) {
String classKey = field.getName();
// hack
classKey =
classKey.replaceFirst(
"" + classKey.charAt(0), "" + Character.toUpperCase(classKey.charAt(0)));
if (field.getName().endsWith("s")) {
classKey = classKey.substring(0, classKey.length() - 1);
}
DatabaseBuilder ownBuilder = getDatabase().getOwnBuilder();
Class fieldClass = ownBuilder.getClassForName(classKey);
if (fieldClass != null) {
List<ActiveRecordBase> ownObjects =
(List<ActiveRecordBase>)
findByColumn(
fieldClass,
CamelNotationHelper.toSQLName(getTableName()),
Long.toString(getID()));
field.set(this, ownObjects);
}
} else if (field.getAnnotation(ActiveRecordIgnoreAttribute.class) != null) {
continue;
} else
throw new ActiveRecordException(
field.getName()
+ " of type "
+ field.getType()
+ " cannot be read from Sqlite3 database.");
} catch (IllegalArgumentException e) {
throw new ActiveRecordException(e.getLocalizedMessage());
} catch (IllegalAccessException e) {
throw new ActiveRecordException(e.getLocalizedMessage());
}
}
s_EntitiesMap.set(this);
for (Field f : entities.keySet()) {
try {
f.set(
this, this.findByID((Class<? extends ActiveRecordBase>) f.getType(), entities.get(f)));
} catch (SQLiteException e) {
throw new ActiveRecordException(e.getLocalizedMessage());
} catch (IllegalArgumentException e) {
throw new ActiveRecordException(e.getLocalizedMessage());
} catch (IllegalAccessException e) {
throw new ActiveRecordException(e.getLocalizedMessage());
}
}
}
@Override
public void generateAccess(
String accessFilename,
int rowCount,
List<FieldDefinition> fieldDefinitionList,
int tableCount) {
long startTime = new Date().getTime();
outputWriterHolder.writeValueInLine("Access data generation started");
Database db = null;
try {
db = DatabaseBuilder.create(Database.FileFormat.V2010, new File(accessFilename));
// New table
int columnCount = fieldDefinitionList.size();
// Create Hash Map of Field Definitions
Map<Integer, Input2TableInfo> input2TableInfoMap = new LinkedHashMap<>(columnCount);
Map<Table, List<Object[]>> tableToGeneratedData = new HashMap<>();
for (int i = 0; i < columnCount; i++) {
Input2TableInfo input2TableInfo = new Input2TableInfo();
FieldDefinition fieldDefinition = fieldDefinitionList.get(i);
input2TableInfo.setFieldText(fieldDefinition.getFieldName());
input2TableInfo.setFieldDefinition(fieldDefinition);
input2TableInfo.initGenerator();
input2TableInfoMap.put(i, input2TableInfo);
}
if (tableCount > 1) {
List<Table> tableListForGeneration = new ArrayList<>();
for (int i = 0; i < tableCount; i++) {
TableBuilder tableBuilder = new TableBuilder("dataTable_" + i);
for (Integer key : input2TableInfoMap.keySet()) {
Input2TableInfo input2TableInfo = input2TableInfoMap.get(key);
tableBuilder.addColumn(
new ColumnBuilder(input2TableInfo.getFieldText())
.setSQLType(getType(input2TableInfo.getFieldDefinition().getType())));
}
tableListForGeneration.add(tableBuilder.toTable(db));
}
CountDownLatch startSignal = new CountDownLatch(1);
CountDownLatch doneSignal;
doneSignal = new CountDownLatch(tableCount);
ParameterVault parameterVault = new DefaultParameterVault(0, rowCount);
TableProcessor tableProcessor1 =
new TableProcessor(
parameterVault,
startSignal,
doneSignal,
tableListForGeneration.get(0),
columnCount,
input2TableInfoMap,
outputWriterHolder,
tableToGeneratedData);
new Thread(tableProcessor1, "Processor-" + tableCount).start();
for (int i = 1; i < tableCount; i++) {
ParameterVault parameterVaultRest = new DefaultParameterVault(i, rowCount);
TableProcessor tableProcessor =
new TableProcessor(
parameterVaultRest,
startSignal,
doneSignal,
tableListForGeneration.get(i),
columnCount,
input2TableInfoMap,
outputWriterHolder,
tableToGeneratedData);
new Thread(tableProcessor, "Processor-" + i).start();
}
startSignal.countDown();
doneSignal.await();
} else {
TableBuilder tableBuilder = new TableBuilder("dataTable_0");
for (Integer key : input2TableInfoMap.keySet()) {
Input2TableInfo input2TableInfo = input2TableInfoMap.get(key);
tableBuilder.addColumn(
new ColumnBuilder(input2TableInfo.getFieldText())
.setSQLType(getType(input2TableInfo.getFieldDefinition().getType())));
}
ParameterVault parameterVault = new DefaultParameterVault(0, rowCount);
new TableProcessor(outputWriterHolder)
.generateTableData(
parameterVault,
tableBuilder.toTable(db),
columnCount,
input2TableInfoMap,
tableToGeneratedData);
}
outputWriterHolder.writeValueInLine("Access data generation finished.");
long generationTime = new Date().getTime();
outputWriterHolder.writeValueInLine(
"Time used " + ((generationTime - startTime) / 1000) + " sec");
outputWriterHolder.writeValueInLine("Writing to file.");
for (Map.Entry<Table, List<Object[]>> tableListEntry : tableToGeneratedData.entrySet()) {
Table table = tableListEntry.getKey();
List<Object[]> rowListForTable = tableListEntry.getValue();
for (Object[] row : rowListForTable) {
table.addRow(row);
}
}
long writeTime = new Date().getTime();
outputWriterHolder.writeValueInLine(
"Time used " + ((writeTime - generationTime) / 1000) + " sec");
outputWriterHolder.writeValueInLine(
"Total time used " + ((writeTime - startTime) / 1000) + " sec");
outputWriterHolder.writeValueInLine("Done");
} catch (Exception e) {
LOGGER.error(e.getMessage(), e);
} finally {
try {
if (db != null) {
db.close();
}
} catch (IOException e) {
LOGGER.error(e.getMessage(), e);
}
}
}
