@SuppressWarnings("unchecked")
private <X> List<X> selectSimple(X x, boolean distinct) {
SQLStatement stat = getSelectStatement(distinct);
appendSQL(stat, x);
appendFromWhere(stat);
ResultSet rs = stat.executeQuery();
List<X> result = New.arrayList();
Statement s = null;
try {
s = rs.getStatement();
while (rs.next()) {
try {
X value;
Object o = rs.getObject(1);
int convertHereIsProbablyWrong;
if (Clob.class.isAssignableFrom(o.getClass())) {
value = (X) ClassUtils.convert(o, String.class);
} else {
value = (X) o;
}
result.add(value);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
} catch (SQLException e) {
throw new RuntimeException(e);
} finally {
JdbcUtils.closeSilently(rs);
JdbcUtils.closeSilently(s);
}
return result;
}
@Override
public void removeDomainCreatePostCreateSysPermissions(
SQLConnection connection,
Resource accessorResource,
Set<DomainCreatePermission> domainCreatePermissions) {
SQLStatement statement = null;
try {
statement =
connection.prepareStatement(
sqlStrings
.SQL_removeInGrantDomainCreatePermissionPostCreateSys_BY_AccessorID_PostCreateSysPermissionID);
for (DomainCreatePermission domainCreatePermission : domainCreatePermissions) {
if (!domainCreatePermission.isSystemPermission()
&& domainCreatePermission.getPostCreateDomainPermission().isSystemPermission()) {
statement.setResourceId(1, accessorResource);
statement.setDomainSystemPermissionId(
2, domainCreatePermission.getPostCreateDomainPermission().getSystemPermissionId());
assertOneRowUpdated(statement.executeUpdate());
}
}
} catch (SQLException e) {
throw new RuntimeException(e);
} finally {
closeStatement(statement);
}
}
/**
* Check equality based on the current state of the SQL statement as returned by {@link
* #getSQLStatement()}.
*
* @since 1.1.0
*/
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj == null) {
return false;
}
if (getClass() != obj.getClass()) {
return false;
}
SQLStatement other = (SQLStatement) obj;
if (getSQLStatement() == null) {
if (other.getSQLStatement() != null) return false;
} else if (!getSQLStatement().equals(other.getSQLStatement())) {
return false;
}
return true;
}
@Override
public int deleteAll(Class<?> claxx) {
acquireReference();
try {
SQLiteDatabase db = mHelper.getWritableDatabase();
SQLStatement stmt = SQLBuilder.buildDeleteAllSql(claxx);
int num = stmt.execDelete(db);
// 删除关系映射
final MapInfo mapTable = SQLBuilder.buildDelAllMappingSql(claxx);
if (mapTable != null && !mapTable.isEmpty()) {
Transaction.execute(
db,
new Worker<Boolean>() {
@Override
public Boolean doTransaction(SQLiteDatabase db) throws Exception {
if (mapTable.delOldRelationSQL != null) {
for (SQLStatement st : mapTable.delOldRelationSQL) {
long rowId = st.execDelete(db);
if (Log.isPrint) {
Log.i(TAG, "Exec delete mapping success, nums: " + rowId);
}
}
}
return true;
}
});
}
return num;
} catch (Exception e) {
e.printStackTrace();
} finally {
releaseReference();
}
return SQLStatement.NONE;
}
@Override
public Set<DomainCreatePermission> getDomainCreatePostCreateSysPermissions(
SQLConnection connection, Resource accessorResource) {
SQLStatement statement = null;
try {
statement =
connection.prepareStatement(
sqlStrings
.SQL_findInGrantDomainCreatePermissionPostCreateSys_withoutInheritance_PostCreateSysPermissionID_PostCreateIsWithGrant_IsWithGrant_BY_AccessorID);
statement.setResourceId(1, accessorResource);
SQLResult resultSet = statement.executeQuery();
// collect the create permissions that this resource has to domains directly
Set<DomainCreatePermission> domainCreatePermissions = new HashSet<>();
while (resultSet.next()) {
domainCreatePermissions.add(getDomainCreatePostCreateSysPermission(resultSet));
}
resultSet.close();
return domainCreatePermissions;
} catch (SQLException e) {
throw new RuntimeException(e);
} finally {
closeStatement(statement);
}
}
void delete(Db db, Object obj) {
if (primaryKeyColumnNames == null || primaryKeyColumnNames.size() == 0) {
throw new IllegalStateException(
"No primary key columns defined "
+ "for table "
+ obj.getClass()
+ " - no update possible");
}
SQLStatement stat = new SQLStatement(db);
StatementBuilder buff = new StatementBuilder("DELETE FROM ");
buff.append(db.getDialect().getTableName(schemaName, tableName));
buff.resetCount();
Object alias = ClassUtils.newObject(obj.getClass());
Query<Object> query = Query.from(db, alias);
boolean firstCondition = true;
for (FieldDefinition field : fields) {
if (field.isPrimaryKey) {
Object aliasValue = field.getValue(alias);
Object value = field.getValue(obj);
if (!firstCondition) {
query.addConditionToken(ConditionAndOr.AND);
}
firstCondition = false;
query.addConditionToken(new Condition<Object>(aliasValue, value, CompareType.EQUAL));
}
}
stat.setSQL(buff.toString());
query.appendWhere(stat);
StatementLogger.delete(stat.getSQL());
stat.executeUpdate();
}
public int delete() {
SQLStatement stat = new SQLStatement(db);
stat.appendSQL("DELETE FROM ");
from.appendSQL(stat);
appendWhere(stat);
StatementLogger.delete(stat.getSQL());
return stat.executeUpdate();
}
private SQLStatement getSelectStatement(boolean distinct) {
SQLStatement stat = new SQLStatement(db);
stat.appendSQL("SELECT ");
if (distinct) {
stat.appendSQL("DISTINCT ");
}
return stat;
}
void appendSelectList(SQLStatement stat) {
for (int i = 0; i < fields.size(); i++) {
if (i > 0) {
stat.appendSQL(", ");
}
FieldDefinition def = fields.get(i);
stat.appendSQL(def.columnName);
}
}
void appendWhere(SQLStatement stat) {
if (!conditions.isEmpty()) {
stat.appendSQL(" WHERE ");
for (Token token : conditions) {
token.appendSQL(stat, this);
stat.appendSQL(" ");
}
}
}
@Override
public <T> ArrayList<T> queryAll(Class<T> claxx) {
acquireReference();
try {
SQLStatement stmt = new QueryBuilder(claxx).createStatement();
return stmt.query(mHelper.getReadableDatabase(), claxx);
} finally {
releaseReference();
}
}
/**
* Build a statement that returns a 1 by 1 table with a numeric value. SELECT COUNT(*) FROM table;
*/
public SQLStatement createStatementForCount() {
StringBuilder query = new StringBuilder(120);
query.append(SELECT_COUNT).append(getTableName());
SQLStatement stmt = new SQLStatement();
if (whereBuilder != null) {
query.append(whereBuilder.createWhereString());
stmt.bindArgs = whereBuilder.transToStringArray();
}
stmt.sql = query.toString();
return stmt;
}
public <T> void appendSQL(SQLStatement stat, Query<T> query) {
stat.appendSQL(name).appendSQL("(");
int i = 0;
for (Object o : x) {
if (i++ > 0) {
stat.appendSQL(",");
}
query.appendSQL(stat, o);
}
stat.appendSQL(")");
}
@Override
public long queryCount(QueryBuilder qb) {
acquireReference();
try {
SQLiteDatabase db = mHelper.getReadableDatabase();
SQLStatement stmt = qb.createStatementForCount();
return stmt.queryForLong(db);
} catch (Exception e) {
e.printStackTrace();
} finally {
releaseReference();
}
return SQLStatement.NONE;
}
@Override
public void removeDomainCreatePostCreateSysPermissions(
SQLConnection connection, Resource accessorResource) {
SQLStatement statement = null;
try {
statement =
connection.prepareStatement(
sqlStrings.SQL_removeInGrantDomainCreatePermissionPostCreateSys_BY_AccessorID);
statement.setResourceId(1, accessorResource);
statement.executeUpdate();
} catch (SQLException e) {
throw new RuntimeException(e);
} finally {
closeStatement(statement);
}
}
@Override
public int update(
Collection<?> collection, ColumnsValue cvs, ConflictAlgorithm conflictAlgorithm) {
acquireReference();
try {
if (!Checker.isEmpty(collection)) {
SQLiteDatabase db = mHelper.getWritableDatabase();
Object entity = collection.iterator().next();
SQLStatement stmt = SQLBuilder.buildUpdateAllSql(entity, cvs, conflictAlgorithm);
return stmt.execUpdateCollection(db, collection, cvs, mTableManager);
}
} catch (Exception e) {
e.printStackTrace();
} finally {
releaseReference();
}
return SQLStatement.NONE;
}
/**
* INTERNAL
*
* @param stat the statement
* @param x the alias object
*/
public void appendSQL(SQLStatement stat, Object x) {
if (x == Function.count()) {
stat.appendSQL("COUNT(*)");
return;
}
Token token = Db.getToken(x);
if (token != null) {
token.appendSQL(stat, this);
return;
}
SelectColumn<T> col = aliasMap.get(x);
if (col != null) {
col.appendSQL(stat);
return;
}
stat.appendSQL("?");
stat.addParameter(x);
}
public long selectCount() {
SQLStatement stat = getSelectStatement(false);
stat.appendSQL("COUNT(*) ");
appendFromWhere(stat);
ResultSet rs = stat.executeQuery();
Statement s = null;
try {
s = rs.getStatement();
rs.next();
long value = rs.getLong(1);
return value;
} catch (SQLException e) {
throw new RuntimeException(e);
} finally {
JdbcUtils.closeSilently(rs);
JdbcUtils.closeSilently(s);
}
}
@Override
public int save(Collection<?> collection) {
acquireReference();
try {
if (!Checker.isEmpty(collection)) {
SQLiteDatabase db = mHelper.getWritableDatabase();
Object entity = collection.iterator().next();
SQLStatement stmt = SQLBuilder.buildReplaceAllSql(entity);
mTableManager.checkOrCreateTable(db, entity);
return stmt.execInsertCollection(db, collection, mTableManager);
}
} catch (Exception e) {
e.printStackTrace();
} finally {
releaseReference();
}
return SQLStatement.NONE;
}
protected static void closeStatement(SQLStatement statement) {
try {
if (statement != null) {
statement.close();
}
} catch (SQLException e) {
throw new RuntimeException(e);
}
}
@Override
public <T> T queryById(String id, Class<T> claxx) {
acquireReference();
try {
SQLiteDatabase db = mHelper.getReadableDatabase();
EntityTable table = TableManager.getTable(claxx);
SQLStatement stmt =
new QueryBuilder(claxx)
.where(table.key.column + "=?", new String[] {id})
.createStatement();
ArrayList<T> list = stmt.query(db, claxx);
if (!Checker.isEmpty(list)) {
return list.get(0);
}
} finally {
releaseReference();
}
return null;
}
<Y, X> void appendSelectList(SQLStatement stat, Query<Y> query, X x) {
for (int i = 0; i < fields.size(); i++) {
if (i > 0) {
stat.appendSQL(", ");
}
FieldDefinition def = fields.get(i);
Object obj = def.getValue(x);
query.appendSQL(stat, obj);
}
}
/** 删除从[start,end]的数据 此方法暂不会删除关联映射表里的关系数据 */
@Override
public int delete(Class<?> claxx, long start, long end, String orderAscColumn) {
acquireReference();
try {
if (start < 0 || end < start) {
throw new RuntimeException("start must >=0 and smaller than end");
}
if (start != 0) {
start -= 1;
}
end = end == Integer.MAX_VALUE ? -1 : end - start;
SQLStatement stmt = SQLBuilder.buildDeleteSql(claxx, start, end, orderAscColumn);
return stmt.execDelete(mHelper.getWritableDatabase());
} catch (Exception e) {
e.printStackTrace();
} finally {
releaseReference();
}
return SQLStatement.NONE;
}
public static final void doSQL(
java.sql.Connection db, String cmd, VariableTable vt, DBCommandHandler cmdhandler) {
int rows = 0;
int rowcount = -1;
boolean resultreturned = false;
java.sql.ResultSet rset = null;
SQLStatement pstmt = null;
try {
pstmt = DBOperation.prepareStatement(db, cmd, vt);
if (pstmt.stmt == null) return;
pstmt.bind(vt);
resultreturned = pstmt.stmt.execute();
do {
if (resultreturned) {
rset = pstmt.stmt.getResultSet();
cmdhandler.showResultSet(rset);
rset.close();
} else {
try {
rowcount = pstmt.stmt.getUpdateCount();
} catch (java.sql.SQLException e) {
rowcount = -1;
}
if (rowcount >= 0) {
cmdhandler.showMessage(rowcount);
}
}
resultreturned = pstmt.stmt.getMoreResults();
} while (resultreturned || rowcount != -1);
} catch (java.sql.SQLException sqle) {
cmdhandler.showSQLException(sqle);
} finally {
if (pstmt != null && pstmt.stmt != null) {
try {
pstmt.stmt.close();
} catch (java.sql.SQLException e) {
}
}
}
clearWarnings(db, cmdhandler);
}
/** 构建查询语句 */
public SQLStatement createStatement() {
if (clazz == null) {
throw new IllegalArgumentException(
"U Must Set A Query Entity Class By queryWho(Class) or " + "QueryBuilder(Class)");
}
if (Checker.isEmpty(group) && !Checker.isEmpty(having)) {
throw new IllegalArgumentException(
"HAVING仅允许在有GroupBy的时候使用(HAVING clauses are only permitted when using a groupBy clause)");
}
if (!Checker.isEmpty(limit) && !limitPattern.matcher(limit).matches()) {
throw new IllegalArgumentException("invalid LIMIT clauses:" + limit);
}
StringBuilder query = new StringBuilder(120);
query.append(SELECT);
if (distinct) {
query.append(DISTINCT);
}
if (!Checker.isEmpty(columns)) {
appendColumns(query, columns);
} else {
query.append(ASTERISK);
}
query.append(FROM).append(getTableName());
query.append(whereBuilder.createWhereString());
appendClause(query, GROUP_BY, group);
appendClause(query, HAVING, having);
appendClause(query, ORDER_BY, order);
appendClause(query, LIMIT, limit);
SQLStatement stmt = new SQLStatement();
stmt.sql = query.toString();
stmt.bindArgs = whereBuilder.transToStringArray();
return stmt;
}
void merge(Db db, Object obj) {
if (primaryKeyColumnNames == null || primaryKeyColumnNames.size() == 0) {
throw new IllegalStateException(
"No primary key columns defined "
+ "for table "
+ obj.getClass()
+ " - no update possible");
}
SQLStatement stat = new SQLStatement(db);
StatementBuilder buff = new StatementBuilder("MERGE INTO ");
buff.append(db.getDialect().getTableName(schemaName, tableName)).append(" (");
buff.resetCount();
for (FieldDefinition field : fields) {
buff.appendExceptFirst(", ");
buff.append(field.columnName);
}
buff.append(") KEY(");
buff.resetCount();
for (FieldDefinition field : fields) {
if (field.isPrimaryKey) {
buff.appendExceptFirst(", ");
buff.append(field.columnName);
}
}
buff.append(") ");
buff.resetCount();
buff.append("VALUES (");
for (FieldDefinition field : fields) {
buff.appendExceptFirst(", ");
buff.append('?');
Object value = getValue(obj, field);
stat.addParameter(value);
}
buff.append(')');
stat.setSQL(buff.toString());
StatementLogger.merge(stat.getSQL());
stat.executeUpdate();
}
@Override
public boolean execute(SQLiteDatabase db, SQLStatement statement) {
acquireReference();
try {
if (statement != null) {
return statement.execute(db);
}
} catch (Exception e) {
e.printStackTrace();
} finally {
releaseReference();
}
return false;
}
private <X> List<X> select(Class<X> clazz, X x, boolean distinct) {
List<X> result = New.arrayList();
TableDefinition<X> def = db.define(clazz);
SQLStatement stat = getSelectStatement(distinct);
def.appendSelectList(stat, this, x);
appendFromWhere(stat);
ResultSet rs = stat.executeQuery();
Statement s = null;
try {
s = rs.getStatement();
while (rs.next()) {
X row = ClassUtils.newObject(clazz);
def.readRow(row, rs);
result.add(row);
}
} catch (SQLException e) {
throw new RuntimeException(e);
} finally {
JdbcUtils.closeSilently(rs);
JdbcUtils.closeSilently(s);
}
return result;
}
private List<T> select(boolean distinct) {
List<T> result = New.arrayList();
TableDefinition<T> def = from.getAliasDefinition();
SQLStatement stat = getSelectStatement(distinct);
def.appendSelectList(stat);
appendFromWhere(stat);
ResultSet rs = stat.executeQuery();
Statement s = null;
try {
s = rs.getStatement();
while (rs.next()) {
T item = from.newObject();
from.getAliasDefinition().readRow(item, rs);
result.add(item);
}
} catch (SQLException e) {
throw new RuntimeException(e);
} finally {
JdbcUtils.closeSilently(rs);
JdbcUtils.closeSilently(s);
}
return result;
}
@Override
public int delete(final Collection<?> collection) {
acquireReference();
try {
if (!Checker.isEmpty(collection)) {
EntityTable table = TableManager.getTable(collection.iterator().next());
if (table.key != null) {
SQLStatement stmt = SQLBuilder.buildDeleteSql(collection);
return stmt.execDeleteCollection(
mHelper.getWritableDatabase(), collection, mTableManager);
} else {
Integer size =
Transaction.execute(
mHelper.getWritableDatabase(),
new Worker<Integer>() {
@Override
public Integer doTransaction(SQLiteDatabase db) throws Exception {
for (Object entity : collection) {
SQLBuilder.buildDeleteSql(entity)
.execDeleteWithMapping(db, entity, mTableManager);
}
if (Log.isPrint) {
Log.i(TAG, "Exec delete(no primarykey) ：" + collection.size());
}
return collection.size();
}
});
return size == null ? 0 : size;
}
}
} catch (Exception e) {
e.printStackTrace();
} finally {
releaseReference();
}
return SQLStatement.NONE;
}
