From 4b2ab438bc6d2efb24144a091edaa3d4a1d75350 Mon Sep 17 00:00:00 2001 From: "Philip.Kirwin1" Date: Tue, 7 Feb 2017 15:33:38 -0500 Subject: [PATCH 1/6] Added order variable to CommonState --- src/main/java/com/fdflib/model/state/CommonState.java | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/main/java/com/fdflib/model/state/CommonState.java b/src/main/java/com/fdflib/model/state/CommonState.java index d877e66..a114006 100644 --- a/src/main/java/com/fdflib/model/state/CommonState.java +++ b/src/main/java/com/fdflib/model/state/CommonState.java @@ -33,6 +33,7 @@ public class CommonState implements Serializable { public long euid; public long esid; public long tid; // tenantId + public double order; public CommonState() { this.rid = -1; @@ -44,5 +45,6 @@ public CommonState() { this.esid = -1; this.euid = -1; this.tid = 1; + this.order = -1; } } From 0cccac7f7ba5ef06fc8adb50902e26d923a3a7f4 Mon Sep 17 00:00:00 2001 From: "Philip.Kirwin1" Date: Fri, 5 May 2017 15:57:24 -0400 Subject: [PATCH 2/6] Added logic to change order based on either position or based on a desired index. --- .../com/fdflib/model/state/CommonState.java | 2 +- .../service/impl/FdfCommonServices.java | 125 +++++++++++++++++- 2 files changed, 125 insertions(+), 2 deletions(-) diff --git a/src/main/java/com/fdflib/model/state/CommonState.java b/src/main/java/com/fdflib/model/state/CommonState.java index a114006..f6776fb 100644 --- a/src/main/java/com/fdflib/model/state/CommonState.java +++ b/src/main/java/com/fdflib/model/state/CommonState.java @@ -45,6 +45,6 @@ public CommonState() { this.esid = -1; this.euid = -1; this.tid = 1; - this.order = -1; + this.order = 0; } } diff --git a/src/main/java/com/fdflib/service/impl/FdfCommonServices.java b/src/main/java/com/fdflib/service/impl/FdfCommonServices.java index 9c27cfb..334cef8 100644 --- a/src/main/java/com/fdflib/service/impl/FdfCommonServices.java +++ b/src/main/java/com/fdflib/service/impl/FdfCommonServices.java @@ -98,6 +98,21 @@ public static S save(S state, Class entityState, long FdfPersistence.getInstance().update(entityState, lastCurrentEntity); } } + + if(state.order < 0) { + //this means that order was stored as a position. + state.order = Math.abs(state.order); + getOrderByPosition(state); + } + else if(state.order > 0) { + //this means that order was already set, so check if valid. + validateOrder(state); + } + else { + //this means that order should be set to last. + state.order = getNewOrder(state.getClass(), state.tid); + } + //Set generic fields for new record, save entity, then return it. state.arsd = Calendar.getInstance().getTime(); state.ared = null; @@ -167,6 +182,21 @@ public static FdfEntity save(Class entityState, S return new FdfEntity<>(); } } + + if(state.order < 0) { + //this means that order was stored as a position. + state.order = Math.abs(state.order); + getOrderByPosition(state); + } + else if(state.order > 0) { + //this means that order was already set, so check if valid. + validateOrder(state); + } + else { + //this means that order should be set to last. + state.order = getNewOrder(state.getClass(), state.tid); + } + // get full entity for state FdfEntity thisEntity = auditEntityById(entityState, state.id, tenantId); // check to see if there is an existing entity, if not, create @@ -191,6 +221,96 @@ public static FdfEntity save(Class entityState, S return auditEntityById(entityState, entity.id, tenantId); } + //Calculates "order" value based on the desired position. + private static void getOrderByPosition(S state) { + SqlStatement statement = SqlStatement.build().select("id, order").where(setForCurrent(state.tid)).orderBy("order"); + if(state.order == 1) { + statement.limit(1,1); + } else { + statement.limit(2, (int)state.order-1); + } + List orderBetween = statement.run((Class) state.getClass()); + if(orderBetween.size() == 2) { + if(orderBetween.get(1).id != state.id && orderBetween.get(0).order >= state.order || state.order >= orderBetween.get(1).order) { + if (orderBetween.get(1).order - orderBetween.get(0).order > 1) { + state.order = (orderBetween.get(0).order >= state.order + ? Math.floor(orderBetween.get(0).order + 1) : Math.ceil(orderBetween.get(1).order - 1)); + } + String orderCurve = Double.toString(state.order = orderBetween.get(1).order + orderBetween.get(0).order); + if (orderCurve.contains(".")) { + double curver = Math.pow(10, (1 + orderCurve.indexOf(".") - orderCurve.length())); + if (curver != orderBetween.get(1).order - orderBetween.get(0).order) { + state.order += curver; + } + } + state.order /= 2; + } + + } + else if(!orderBetween.isEmpty() && orderBetween.get(0).id != state.id) { + if(state.order == 1) { + if(orderBetween.get(0).order <= 1) { + String orderCurve = Double.toString(orderBetween.get(0).order); + if(orderCurve.contains(".")) { + double curver = Math.pow(10, (1 + orderCurve.indexOf(".") - orderCurve.length())); + if(curver != orderBetween.get(1).order - orderBetween.get(0).order) { + orderBetween.get(0).order += curver; + } + } + state.order = orderBetween.get(0).order/2; + } + } + else if(orderBetween.get(0).order >= state.order) { + state.order = Math.floor(orderBetween.get(0).order+1); + } + } + } + //Checks if "order" is already taken, and adjusts order if it is. + private static void validateOrder(S state) { + WhereClause whereOrder = new WhereClause(); + whereOrder.name = "order"; + whereOrder.operator = WhereClause.Operators.LESS_THAN_OR_EQUAL; + whereOrder.value = Double.toString(state.order); + whereOrder.valueDataType = Double.class; + List orderBetween = SqlStatement.build().select("id, order").where(whereOrder).where(setForCurrent(state.tid)) + .orderBy("order DESC").limit(2,1).run((Class) state.getClass()); + if(!orderBetween.isEmpty() && orderBetween.get(0).order == state.order && orderBetween.get(0).id != state.id) { + if(orderBetween.size() == 2) { + if(orderBetween.get(0).order - orderBetween.get(1).order > 1) { + state.order = Math.ceil(orderBetween.get(0).order-1); + } + else { + String orderCurb = Double.toString(state.order = orderBetween.get(1).order + orderBetween.get(0).order); + if(orderCurb.contains(".")) { + double curver = Math.pow(10, (1 + orderCurb.indexOf(".") - orderCurb.length())); + if(curver != orderBetween.get(0).order - orderBetween.get(1).order) { + state.order += curver; + } + } + state.order /= 2; + } + } + else if(orderBetween.get(0).order <= 1) { + String orderCurb = Double.toString(orderBetween.get(0).order); + if(orderCurb.contains(".")) { + double curver = Math.pow(10, (1 + orderCurb.indexOf(".") - orderCurb.length())); + if(curver != orderBetween.get(0).order) { + state.order += curver; + } + } + state.order = orderBetween.get(0).order/2; + } + else { + state.order = Math.ceil(orderBetween.get(0).order-1); + } + } + } + //Sets "order" to last possible order. + private static double getNewOrder(Class entityState, long tenantId) { + CommonState returnedState = SqlStatement.build().select("max(order) AS order").where(setForCurrent(tenantId)).run(entityState).stream().findAny().orElse(null); + return (returnedState != null && returnedState.order > 0 ? Math.floor(returnedState.order+1) : 1); + } + /** * Sets delete flag for entity. In order to record the date, time, user and system requesting the record be marked * deleted, a new current record is created to contain this information (arsd contains the date/time, ared is left @@ -332,7 +452,10 @@ public static long getEntityCount(Class entityState) * @return */ public static List sqlStatementSelect(Class entityState, SqlStatement sqlStatement) { - return FdfPersistence.getInstance().selectQuery(entityState, sqlStatement); + sqlStatement = sqlStatement.orderBy("order"); + List res = FdfPersistence.getInstance().selectQuery(entityState, sqlStatement); + + return res; } /** From 9ab759af5ee656e98c743ed4960c89d74af04a9e Mon Sep 17 00:00:00 2001 From: Brian Gormanly Date: Fri, 5 May 2017 17:12:54 -0400 Subject: [PATCH 3/6] working changes to deal with mysql and order field name --- build.gradle | 2 +- .../com/fdflib/model/util/SqlStatement.java | 5 ++- .../persistence/queries/CoreMySqlQueries.java | 32 +++++++++---------- .../service/impl/FdfCommonServices.java | 6 ++-- 4 files changed, 22 insertions(+), 23 deletions(-) diff --git a/build.gradle b/build.gradle index e20bae8..deb3f67 100644 --- a/build.gradle +++ b/build.gradle @@ -3,7 +3,7 @@ } group = 'com.fdflib' -version = '1.3.2-SNAPSHOT' +version = '1.3.3-SNAPSHOT' sourceCompatibility = 1.8 targetCompatibility = 1.8 diff --git a/src/main/java/com/fdflib/model/util/SqlStatement.java b/src/main/java/com/fdflib/model/util/SqlStatement.java index 157f71e..6abe2a7 100644 --- a/src/main/java/com/fdflib/model/util/SqlStatement.java +++ b/src/main/java/com/fdflib/model/util/SqlStatement.java @@ -1,7 +1,6 @@ package com.fdflib.model.util; import com.fdflib.model.state.CommonState; -import com.fdflib.persistence.FdfPersistence; import com.fdflib.service.impl.FdfCommonServices; import java.util.ArrayList; @@ -151,7 +150,7 @@ public String getGroupBy() { else { sql.append(","); } - sql.append(" ").append(group); + sql.append(" `").append(group).append("`"); }); return sql.toString(); } @@ -164,7 +163,7 @@ public String getOrderBy() { else { sql.append(","); } - sql.append(" ").append(order); + sql.append(" `").append(order).append("`"); }); return sql.toString(); } diff --git a/src/main/java/com/fdflib/persistence/queries/CoreMySqlQueries.java b/src/main/java/com/fdflib/persistence/queries/CoreMySqlQueries.java index f33bb36..c0b51f8 100644 --- a/src/main/java/com/fdflib/persistence/queries/CoreMySqlQueries.java +++ b/src/main/java/com/fdflib/persistence/queries/CoreMySqlQueries.java @@ -1079,58 +1079,58 @@ else if (pt.getActualTypeArguments().length == 1 && static String getFieldNameAndDataType(Field field) { String sql = ""; - fdfLog.debug("checking field: {} of type: {} ", field.getName(), field.getType()); + fdfLog.debug("checking field: {} of type: {} ", "`" + field.getName() + "`", field.getType()); if (field.getType() == String.class) { - sql += field.getName() + " TEXT"; + sql += "`" + field.getName() + "`" + " TEXT"; } else if (field.getType() == int.class || field.getType() == Integer.class) { - sql += field.getName() + " INT"; + sql += "`" + field.getName() + "`" + " INT"; } else if (field.getType() == Long.class || field.getType() == long.class) { - sql += field.getName() + " BIGINT"; + sql += "`" + field.getName() + "`" + " BIGINT"; if (field.getName().equals("rid")) { sql += " PRIMARY KEY AUTO_INCREMENT"; } } else if (field.getType() == Double.class || field.getType() == double.class) { - sql += field.getName() + " DOUBLE"; + sql += "`" + field.getName() + "`" + " DOUBLE"; } else if (field.getType() == Float.class || field.getType() == float.class) { - sql += field.getName() + " FLOAT"; + sql += "`" + field.getName() + "`" + " FLOAT"; } else if (field.getType() == BigDecimal.class) { - sql += field.getName() + " NUMERIC(10,4)"; + sql += "`" + field.getName() + "`" + " NUMERIC(10,4)"; } else if (field.getType() == boolean.class || field.getType() == Boolean.class) { - sql += field.getName() + " TINYINT(1)"; + sql += "`" + field.getName() + "`" + " TINYINT(1)"; } else if (field.getType() == Date.class) { - sql += field.getName() + " DATETIME"; + sql += "`" + field.getName() + "`" + " DATETIME"; if (field.getName().equals("arsd")) { sql += " DEFAULT CURRENT_TIMESTAMP"; } else { sql += " NULL"; } } else if (field.getType() == UUID.class) { - sql += field.getName() + " VARCHAR(132)"; + sql += "`" + field.getName() + "`" + " VARCHAR(132)"; } else if (field.getType() == Character.class || field.getType() == char.class) { - sql += field.getName() + " CHAR"; + sql += "`" + field.getName() + "`" + " CHAR"; } else if (field.getType() != null && field.getType().isEnum()) { - sql += field.getName() + " VARCHAR(200)"; + sql += "`" + field.getName() + "`" + " VARCHAR(200)"; } else if (Class.class.isAssignableFrom(field.getType())) { - sql += field.getName() + " VARCHAR(200)"; + sql += "`" + field.getName() + "`" + " VARCHAR(200)"; } else if (field.getGenericType() instanceof ParameterizedType) { ParameterizedType pt = (ParameterizedType) field.getGenericType(); if(pt.getActualTypeArguments().length == 1 && pt.getActualTypeArguments()[0].toString() .matches(".*?((L|l)ong|Integer|int|(D|d)ouble|(F|f)loat|(B|b)oolean|String).*")) { - sql += field.getName() + " TEXT"; + sql += "`" + field.getName() + "`" + " TEXT"; } else { // unknown create text fields to serialize fdfLog.debug("Was not able to identify field: {} of type: {} ", field.getName(), field.getType()); - sql += field.getName() + " BLOB"; + sql += "`" + field.getName() + "`" + " BLOB"; } } else { // unknown create text fields to serialize fdfLog.debug("Was not able to identify field: {} of type: {} ", field.getName(), field.getType()); - sql += field.getName() + " BLOB"; + sql += "`" + field.getName() + "`" + " BLOB"; } return sql; } diff --git a/src/main/java/com/fdflib/service/impl/FdfCommonServices.java b/src/main/java/com/fdflib/service/impl/FdfCommonServices.java index 334cef8..8e3a64d 100644 --- a/src/main/java/com/fdflib/service/impl/FdfCommonServices.java +++ b/src/main/java/com/fdflib/service/impl/FdfCommonServices.java @@ -307,7 +307,7 @@ else if(orderBetween.get(0).order <= 1) { } //Sets "order" to last possible order. private static double getNewOrder(Class entityState, long tenantId) { - CommonState returnedState = SqlStatement.build().select("max(order) AS order").where(setForCurrent(tenantId)).run(entityState).stream().findAny().orElse(null); + CommonState returnedState = SqlStatement.build().select("max(`order`) AS `order`").where(setForCurrent(tenantId)).run(entityState).stream().findAny().orElse(null); return (returnedState != null && returnedState.order > 0 ? Math.floor(returnedState.order+1) : 1); } @@ -424,7 +424,7 @@ public static FdfEntity removeDeleteFlag(Class ent * @return long representing teh number of rows in the table */ public static long getRowCount(Class entityState) { - CommonState returnedState = SqlStatement.build().select("max(rid) AS rid").run(entityState).stream().findAny().orElse(null); + CommonState returnedState = SqlStatement.build().select("max(`rid`) AS `rid`").run(entityState).stream().findAny().orElse(null); return (returnedState != null ? returnedState.rid : 0); /*List returnedQuery = FdfPersistence.getInstance().selectQuery(entityState, SqlStatement.build().select("rid")); @@ -1300,7 +1300,7 @@ public static long getNewEntityId(Class entityState) * @return Entities of Type passed */ public static long getNewEntityId(Class entityState, long tenantId) { - CommonState returnedState = SqlStatement.build().select("max(id) AS id").where(auditForCurrent(tenantId)).run(entityState).stream().findAny().orElse(null); + CommonState returnedState = SqlStatement.build().select("max(`id`) AS `id`").where(auditForCurrent(tenantId)).run(entityState).stream().findAny().orElse(null); return (returnedState != null && returnedState.id > 0 ? returnedState.id + 1 : 1); } From 56fc04296634073b3c7b3e1be4eb67feb633a35a Mon Sep 17 00:00:00 2001 From: Brian Gormanly Date: Mon, 8 May 2017 15:27:11 -0400 Subject: [PATCH 4/6] additional fixes to get ordering working with identity appliaction for mysql --- src/main/java/com/fdflib/model/util/SqlStatement.java | 9 ++++++--- .../com/fdflib/persistence/queries/CoreMySqlQueries.java | 6 +++--- .../java/com/fdflib/service/impl/FdfCommonServices.java | 8 ++++---- 3 files changed, 13 insertions(+), 10 deletions(-) diff --git a/src/main/java/com/fdflib/model/util/SqlStatement.java b/src/main/java/com/fdflib/model/util/SqlStatement.java index 6abe2a7..33afa88 100644 --- a/src/main/java/com/fdflib/model/util/SqlStatement.java +++ b/src/main/java/com/fdflib/model/util/SqlStatement.java @@ -104,7 +104,10 @@ public String getSelect() { if(s > 0) { sql.append(", "); } - sql.append(select.get(s)); + System.out.println("the mysterious is::::::::: ----------------------> " + select.get(s)); + + sql.append("`").append(select.get(s)).append("`"); + System.out.println("now the mysterious is::::::::: ----------------------> " + sql.toString()); } } else { sql.append("*"); @@ -125,7 +128,7 @@ public String getWhere() { clause.groupings.stream().filter(grouping -> grouping.equals(WhereClause.GROUPINGS.OPEN_PARENTHESIS)).forEach(openParen -> sql.append("(")); //Format clause by datatype if(clause.operator != WhereClause.Operators.UNARY) { - sql.append(clause.name).append(" ").append(clause.getOperatorString()).append(" "); + sql.append("`").append(clause.name).append("` ").append(clause.getOperatorString()).append(" "); if(clause.value.equals(WhereClause.NULL) || Number.class.isAssignableFrom(clause.valueDataType)) { sql.append(clause.value); } @@ -163,7 +166,7 @@ public String getOrderBy() { else { sql.append(","); } - sql.append(" `").append(order).append("`"); + sql.append(" ").append(order); }); return sql.toString(); } diff --git a/src/main/java/com/fdflib/persistence/queries/CoreMySqlQueries.java b/src/main/java/com/fdflib/persistence/queries/CoreMySqlQueries.java index c0b51f8..d3d1a44 100644 --- a/src/main/java/com/fdflib/persistence/queries/CoreMySqlQueries.java +++ b/src/main/java/com/fdflib/persistence/queries/CoreMySqlQueries.java @@ -280,7 +280,7 @@ public void update(Class c, S state) { //Start Sql Statement StringBuilder sql = new StringBuilder("UPDATE ").append(FdfSettings.DB_NAME).append(".") .append(c.getSimpleName().toLowerCase()).append(" SET"); - fields.forEach(field -> sql.append(" ").append(field.getName()).append(" = ?,")); + fields.forEach(field -> sql.append(" `").append(field.getName()).append("` = ?,")); sql.deleteCharAt(sql.length() - 1).append(" WHERE rid = ").append(c.getField("rid").get(state)).append(";"); //Create Connection conn = MySqlConnection.getInstance().get4dfDbConnection(); @@ -435,7 +435,7 @@ public Long insert(Class c, S state) { .append(c.getSimpleName().toLowerCase()).append(" ("), val = new StringBuilder(); fields.forEach(field -> { - sql.append(" ").append(field.getName()).append(","); + sql.append(" `").append(field.getName()).append("`,"); val.append(" ?,"); }); sql.deleteCharAt(sql.length()-1).append(") VALUES (") @@ -1166,7 +1166,7 @@ else if (clause.conditional == WhereClause.CONDITIONALS.NOT) { // add the claus formatting the sql for the correct datatype if(clause.operator != WhereClause.Operators.UNARY) { - sql += " " + clause.name + " " + clause.getOperatorString() + " "; + sql += " `" + clause.name + "` " + clause.getOperatorString() + " "; if(clause.value.equals(WhereClause.NULL)) { sql += clause.value; } diff --git a/src/main/java/com/fdflib/service/impl/FdfCommonServices.java b/src/main/java/com/fdflib/service/impl/FdfCommonServices.java index 8e3a64d..7093361 100644 --- a/src/main/java/com/fdflib/service/impl/FdfCommonServices.java +++ b/src/main/java/com/fdflib/service/impl/FdfCommonServices.java @@ -223,7 +223,7 @@ else if(state.order > 0) { //Calculates "order" value based on the desired position. private static void getOrderByPosition(S state) { - SqlStatement statement = SqlStatement.build().select("id, order").where(setForCurrent(state.tid)).orderBy("order"); + SqlStatement statement = SqlStatement.build().select("id").select("order").where(setForCurrent(state.tid)).orderBy("`order`"); if(state.order == 1) { statement.limit(1,1); } else { @@ -272,8 +272,8 @@ private static void validateOrder(S state) { whereOrder.operator = WhereClause.Operators.LESS_THAN_OR_EQUAL; whereOrder.value = Double.toString(state.order); whereOrder.valueDataType = Double.class; - List orderBetween = SqlStatement.build().select("id, order").where(whereOrder).where(setForCurrent(state.tid)) - .orderBy("order DESC").limit(2,1).run((Class) state.getClass()); + List orderBetween = SqlStatement.build().select("id").select("order").where(whereOrder).where(setForCurrent(state.tid)) + .orderBy("`order` DESC").limit(2,1).run((Class) state.getClass()); if(!orderBetween.isEmpty() && orderBetween.get(0).order == state.order && orderBetween.get(0).id != state.id) { if(orderBetween.size() == 2) { if(orderBetween.get(0).order - orderBetween.get(1).order > 1) { @@ -452,7 +452,7 @@ public static long getEntityCount(Class entityState) * @return */ public static List sqlStatementSelect(Class entityState, SqlStatement sqlStatement) { - sqlStatement = sqlStatement.orderBy("order"); + sqlStatement = sqlStatement.orderBy("`order`"); List res = FdfPersistence.getInstance().selectQuery(entityState, sqlStatement); return res; From e4738b61d2c5563f262bcdc7da73cde8450af4fe Mon Sep 17 00:00:00 2001 From: Brian Gormanly Date: Thu, 1 Jun 2017 14:13:58 -0400 Subject: [PATCH 5/6] working updates --- .../com/fdflib/model/util/SqlStatement.java | 22 +++++++++++++++---- .../service/impl/FdfCommonServices.java | 4 +++- 2 files changed, 21 insertions(+), 5 deletions(-) diff --git a/src/main/java/com/fdflib/model/util/SqlStatement.java b/src/main/java/com/fdflib/model/util/SqlStatement.java index 33afa88..6788288 100644 --- a/src/main/java/com/fdflib/model/util/SqlStatement.java +++ b/src/main/java/com/fdflib/model/util/SqlStatement.java @@ -104,10 +104,24 @@ public String getSelect() { if(s > 0) { sql.append(", "); } - System.out.println("the mysterious is::::::::: ----------------------> " + select.get(s)); - - sql.append("`").append(select.get(s)).append("`"); - System.out.println("now the mysterious is::::::::: ----------------------> " + sql.toString()); + if(!select.get(s).contains("DISTINCT") + && !select.get(s).contains("*") + && !select.get(s).contains("`")) { + if(select.get(s).contains("(")) { + sql + .append(select.get(s).substring(0, select.get(s).indexOf("(") + 1)) + .append("`") + .append(select.get(s).substring(select.get(s).indexOf("(") + 1, select.get(s).indexOf(")") + 1)) + .append("`") + .append(select.get(s).substring(select.get(s).indexOf(")") + 1, select.get(s).length())); + } + else { + sql.append("`").append(select.get(s)).append("`"); + } + } + else { + sql.append(select.get(s)); + } } } else { sql.append("*"); diff --git a/src/main/java/com/fdflib/service/impl/FdfCommonServices.java b/src/main/java/com/fdflib/service/impl/FdfCommonServices.java index 7093361..50d5128 100644 --- a/src/main/java/com/fdflib/service/impl/FdfCommonServices.java +++ b/src/main/java/com/fdflib/service/impl/FdfCommonServices.java @@ -452,7 +452,9 @@ public static long getEntityCount(Class entityState) * @return */ public static List sqlStatementSelect(Class entityState, SqlStatement sqlStatement) { - sqlStatement = sqlStatement.orderBy("`order`"); + if(!sqlStatement.getOrderBy().contains("ORDER BY `order`")) { + sqlStatement = sqlStatement.orderBy("`order`"); + } List res = FdfPersistence.getInstance().selectQuery(entityState, sqlStatement); return res; From 2dbca0192f3dd21717c84ee086108b5761aaafbb Mon Sep 17 00:00:00 2001 From: Corls Date: Thu, 1 Jun 2017 15:56:00 -0400 Subject: [PATCH 6/6] Fixes the ordering issue occurring in the preprod database for registration. --- .../java/com/fdflib/service/impl/FdfCommonServices.java | 7 +------ 1 file changed, 1 insertion(+), 6 deletions(-) diff --git a/src/main/java/com/fdflib/service/impl/FdfCommonServices.java b/src/main/java/com/fdflib/service/impl/FdfCommonServices.java index 50d5128..6258305 100644 --- a/src/main/java/com/fdflib/service/impl/FdfCommonServices.java +++ b/src/main/java/com/fdflib/service/impl/FdfCommonServices.java @@ -452,12 +452,7 @@ public static long getEntityCount(Class entityState) * @return */ public static List sqlStatementSelect(Class entityState, SqlStatement sqlStatement) { - if(!sqlStatement.getOrderBy().contains("ORDER BY `order`")) { - sqlStatement = sqlStatement.orderBy("`order`"); - } - List res = FdfPersistence.getInstance().selectQuery(entityState, sqlStatement); - - return res; + return FdfPersistence.getInstance().selectQuery(entityState, sqlStatement.orderBy("`order`").orderBy("rid")); } /**