Code Refactoring

pgajek2 · pgajek2 · commit 14894b9d66da · 2025-08-13T21:43:29.000+02:00
diff --git a/force-app/main/default/classes/main/cached-soql/SOQLCache.cls b/force-app/main/default/classes/main/cached-soql/SOQLCache.cls
@@ -86,11 +86,12 @@ public virtual inherited sharing class SOQLCache implements Cacheable {
         }
 
         String ofObject = records[0].getSObjectType().toString();
+        CacheStorageProxy proxy = new CacheStorageProxy(ofObject);
 
         // Record deletion will trigger an automatic cache refresh when the query is executed.
-        new CacheStorageProxy(ofObject).apexTransaction().removeRecordsFromCache(records);
-        new CacheStorageProxy(ofObject).orgCache().removeRecordsFromCache(records);
-        new CacheStorageProxy(ofObject).sessionCache().removeRecordsFromCache(records);
+        proxy.apexTransaction().removeRecordsFromCache(records);
+        proxy.orgCache().removeRecordsFromCache(records);
+        proxy.sessionCache().removeRecordsFromCache(records);
     }
 
     // Backward support
@@ -112,7 +113,7 @@ public virtual inherited sharing class SOQLCache implements Cacheable {
     public SOQL.Queryable currentyQuery = null;
 
     protected SOQLCache(SObjectType ofObject) {
-        this(ofObject + '');
+        this(ofObject.toString());
     }
 
     protected SOQLCache(String ofObject) {
@@ -183,7 +184,7 @@ public virtual inherited sharing class SOQLCache implements Cacheable {
     }
 
     public Cacheable whereEqual(SObjectField field, Object value) {
-        return this.whereEqual(field + '', value);
+        return this.whereEqual(field.toString(), value);
     }
 
     public Cacheable whereEqual(String field, Object value) {
@@ -216,7 +217,7 @@ public virtual inherited sharing class SOQLCache implements Cacheable {
     }
 
     public Id toId() {
-        return this.toObject().Id;
+        return this.toObject()?.Id;
     }
 
     public Boolean doExist() {
@@ -369,8 +370,6 @@ public virtual inherited sharing class SOQLCache implements Cacheable {
         }
 
         public void save(List<SObject> databaseRecords) {
-            List<CacheItem> newCacheRecords = new List<CacheItem>();
-
             if (this.isRecordMissingFromCache()) {
                 storage.addRecordsToCache(databaseRecords);
             } else if (databaseRecords.isEmpty()) { // record does not exist in database anymore
@@ -471,12 +470,12 @@ public virtual inherited sharing class SOQLCache implements Cacheable {
         }
 
         public void with(SObjectField field) {
-            this.cachedFields.add(field + '');
+            this.cachedFields.add(field.toString());
         }
 
         public void with(List<SObjectField> fields) {
             for (SObjectField field : fields) {
-                this.cachedFields.add(field + '');
+                this.cachedFields.add(field.toString());
             }
         }
 
@@ -490,11 +489,12 @@ public virtual inherited sharing class SOQLCache implements Cacheable {
         }
 
         public Boolean hasAllRequestedFields(SObject record) {
-            Boolean hasCachedFields = true;
             for (String field : this.cachedFields) {
-                hasCachedFields &= record.isSet(field);
+                if (!record.isSet(field)) {
+                    return false;
+                }
             }
-            return hasCachedFields;
+            return true;
         }
     }
 
@@ -516,7 +516,7 @@ public virtual inherited sharing class SOQLCache implements Cacheable {
         }
 
         public Boolean isRecentEnough(CacheItem cachedItem) {
-            Decimal recordAgeInHoursSinceCached = (System.now().getTime() - cachedItem.cachedDate.getTime()) / (1000 * 60 * 60);
+            Decimal recordAgeInHoursSinceCached = (System.now().getTime() - cachedItem.cachedDate.getTime()) / 3600000;
             return recordAgeInHoursSinceCached <= this.maxRecordAgeInHours;
         }
     }
@@ -555,12 +555,12 @@ public virtual inherited sharing class SOQLCache implements Cacheable {
         public SObject toObject() {
             List<SObject> records = this.toList();
 
-            if (records.size() > 1) {
-                throw new QueryException('List has more than 1 row for assignment to SObject');
+            if (records.isEmpty()) {
+                return null;
             }
 
-            if (records.size() == 0) {
-                return null;
+            if (records.size() > 1) {
+                throw new QueryException('List has more than 1 row for assignment to SObject');
             }
 
             return records[0];
diff --git a/force-app/main/default/classes/main/standard-soql/SOQL.cls b/force-app/main/default/classes/main/standard-soql/SOQL.cls
@@ -405,20 +405,23 @@ public virtual inherited sharing class SOQL implements Queryable {
 
     @TestVisible // deprecated
     private static void setMock(String mockId, SObject record) {
-        SOQL.queryIdToMock.put(mockId, new List<SoqlMock>{ new SoqlMock().useLegacyMockingBehavior() });
-        SOQL.queryIdToMock.get(mockId).get(SOQL.queryIdToMock.get(mockId).size() - 1).thenReturn(record);
+        SOQL.createLegacyMock(mockId).thenReturn(record);
     }
 
     @TestVisible // deprecated
     private static void setMock(String mockId, List<SObject> records) {
-        SOQL.queryIdToMock.put(mockId, new List<SoqlMock>{ new SoqlMock().useLegacyMockingBehavior() });
-        SOQL.queryIdToMock.get(mockId).get(SOQL.queryIdToMock.get(mockId).size() - 1).thenReturn(records);
+        SOQL.createLegacyMock(mockId).thenReturn(records);
     }
 
     @TestVisible // deprecated
     private static void setCountMock(String mockId, Integer amount) {
-        SOQL.queryIdToMock.put(mockId, new List<SoqlMock>{ new SoqlMock().useLegacyMockingBehavior() });
-        SOQL.queryIdToMock.get(mockId).get(SOQL.queryIdToMock.get(mockId).size() - 1).thenReturn(amount);
+        SOQL.createLegacyMock(mockId).thenReturn(amount);
+    }
+
+    private static SoqlMock createLegacyMock(String mockId) {
+        SoqlMock mock = new SoqlMock().useLegacyMockingBehavior();
+        SOQL.queryIdToMock.put(mockId, new List<SoqlMock>{ mock });
+        return mock;
     }
 
     // Implementation
@@ -944,11 +947,11 @@ public virtual inherited sharing class SOQL implements Queryable {
 
     public Boolean doExist() {
         this.builder.fields.clearAllFields(); // other fields not needed
-        return this.toList().size() > 0;
+        return this.setLimit(1).toList().size() > 0;
     }
 
     public override String toString() {
-        binder = new Binder(); // clear binding before query build
+        binder.reset(); // clear binding before query build
         return this.builder.toString();
     }
 
@@ -1125,15 +1128,15 @@ public virtual inherited sharing class SOQL implements Queryable {
         }
 
         public override String toString() {
-            String query = '';
-
+            List<String> queryParts = new List<String>();
+    
             for (QueryClause clause : this.clauses) {
                 if (clause != null) {
-                    query += ' ' + clause.toString();
+                    queryParts.add(clause.toString());
                 }
             }
-
-            return query.trim();
+            
+            return String.join(queryParts, ' ').trim();
         }
     }
 
@@ -2329,6 +2332,11 @@ public virtual inherited sharing class SOQL implements Queryable {
             return 'v' + bindIndex;
         }
 
+        public void reset() {
+            this.bindIndex = 0;
+            this.binding.clear();
+        }
+
         public Map<String, Object> getBindingMap() {
             return binding;
         }
@@ -2429,7 +2437,7 @@ public virtual inherited sharing class SOQL implements Queryable {
 
         private void stripAdditionalPlainFields(Map<String, Object> recordFilteredFields, SObject record, Set<String> requestedFields) {
             for (String field : requestedFields) {
-                recordFilteredFields.put(field, record.get(field) ?? null);
+                recordFilteredFields.put(field, record.get(field));
             }
         }
 
@@ -2539,12 +2547,12 @@ public virtual inherited sharing class SOQL implements Queryable {
         public SObject toObject() {
             List<SObject> records = toList();
 
-            if (records.size() > 1) {
-                throw new QueryException('List has more than 1 row for assignment to SObject');
+            if (records.isEmpty()) {
+                return null; // handle: List has no rows for assignment to SObject
             }
 
-            if (records.size() == 0) {
-                return null; // handle: List has no rows for assignment to SObject
+            if (records.size() > 1) {
+                throw new QueryException('List has more than 1 row for assignment to SObject');
             }
 
             return records[0];
@@ -2621,7 +2629,9 @@ public virtual inherited sharing class SOQL implements Queryable {
 
             SOQL.syncQueriesIssued++;
 
-            if (SOQL.syncQueriesIssued > 100) {
+            final Integer MAX_QUERIES_ISSUED_IN_SYNCHRONOUS_TRANSACTION = 100;
+
+            if (SOQL.syncQueriesIssued > MAX_QUERIES_ISSUED_IN_SYNCHRONOUS_TRANSACTION) {
                 throw new QueryException('Too many SOQL queries.');
             }
         }

Original file line number	Diff line number	Diff line change
`@@ -86,11 +86,12 @@ public virtual inherited sharing class SOQLCache implements Cacheable {`
`86`	`86`	`}`
`87`	`87`
`88`	`88`	`String ofObject = records[0].getSObjectType().toString();`
	`89`	`+ CacheStorageProxy proxy = new CacheStorageProxy(ofObject);`
`89`	`90`
`90`	`91`	`// Record deletion will trigger an automatic cache refresh when the query is executed.`
`91`		`- new CacheStorageProxy(ofObject).apexTransaction().removeRecordsFromCache(records);`
`92`		`- new CacheStorageProxy(ofObject).orgCache().removeRecordsFromCache(records);`
`93`		`- new CacheStorageProxy(ofObject).sessionCache().removeRecordsFromCache(records);`
	`92`	`+ proxy.apexTransaction().removeRecordsFromCache(records);`
	`93`	`+ proxy.orgCache().removeRecordsFromCache(records);`
	`94`	`+ proxy.sessionCache().removeRecordsFromCache(records);`
`94`	`95`	`}`
`95`	`96`
`96`	`97`	`// Backward support`
`@@ -112,7 +113,7 @@ public virtual inherited sharing class SOQLCache implements Cacheable {`
`112`	`113`	`public SOQL.Queryable currentyQuery = null;`
`113`	`114`
`114`	`115`	`protected SOQLCache(SObjectType ofObject) {`
`115`		`- this(ofObject + '');`
	`116`	`+ this(ofObject.toString());`
`116`	`117`	`}`
`117`	`118`
`118`	`119`	`protected SOQLCache(String ofObject) {`
`@@ -183,7 +184,7 @@ public virtual inherited sharing class SOQLCache implements Cacheable {`
`183`	`184`	`}`
`184`	`185`
`185`	`186`	`public Cacheable whereEqual(SObjectField field, Object value) {`
`186`		`- return this.whereEqual(field + '', value);`
	`187`	`+ return this.whereEqual(field.toString(), value);`
`187`	`188`	`}`
`188`	`189`
`189`	`190`	`public Cacheable whereEqual(String field, Object value) {`
`@@ -216,7 +217,7 @@ public virtual inherited sharing class SOQLCache implements Cacheable {`
`216`	`217`	`}`
`217`	`218`
`218`	`219`	`public Id toId() {`
`219`		`- return this.toObject().Id;`
	`220`	`+ return this.toObject()?.Id;`
`220`	`221`	`}`
`221`	`222`
`222`	`223`	`public Boolean doExist() {`
`@@ -369,8 +370,6 @@ public virtual inherited sharing class SOQLCache implements Cacheable {`
`369`	`370`	`}`
`370`	`371`
`371`	`372`	`public void save(List<SObject> databaseRecords) {`
`372`		`- List<CacheItem> newCacheRecords = new List<CacheItem>();`
`373`		`-`
`374`	`373`	`if (this.isRecordMissingFromCache()) {`
`375`	`374`	`storage.addRecordsToCache(databaseRecords);`
`376`	`375`	`} else if (databaseRecords.isEmpty()) { // record does not exist in database anymore`
`@@ -471,12 +470,12 @@ public virtual inherited sharing class SOQLCache implements Cacheable {`
`471`	`470`	`}`
`472`	`471`
`473`	`472`	`public void with(SObjectField field) {`
`474`		`- this.cachedFields.add(field + '');`
	`473`	`+ this.cachedFields.add(field.toString());`
`475`	`474`	`}`
`476`	`475`
`477`	`476`	`public void with(List<SObjectField> fields) {`
`478`	`477`	`for (SObjectField field : fields) {`
`479`		`- this.cachedFields.add(field + '');`
	`478`	`+ this.cachedFields.add(field.toString());`
`480`	`479`	`}`
`481`	`480`	`}`
`482`	`481`
`@@ -490,11 +489,12 @@ public virtual inherited sharing class SOQLCache implements Cacheable {`
`490`	`489`	`}`
`491`	`490`
`492`	`491`	`public Boolean hasAllRequestedFields(SObject record) {`
`493`		`- Boolean hasCachedFields = true;`
`494`	`492`	`for (String field : this.cachedFields) {`
`495`		`- hasCachedFields &= record.isSet(field);`
	`493`	`+ if (!record.isSet(field)) {`
	`494`	`+ return false;`
	`495`	`+ }`
`496`	`496`	`}`
`497`		`- return hasCachedFields;`
	`497`	`+ return true;`
`498`	`498`	`}`
`499`	`499`	`}`
`500`	`500`
`@@ -516,7 +516,7 @@ public virtual inherited sharing class SOQLCache implements Cacheable {`
`516`	`516`	`}`
`517`	`517`
`518`	`518`	`public Boolean isRecentEnough(CacheItem cachedItem) {`
`519`		`- Decimal recordAgeInHoursSinceCached = (System.now().getTime() - cachedItem.cachedDate.getTime()) / (1000 * 60 * 60);`
	`519`	`+ Decimal recordAgeInHoursSinceCached = (System.now().getTime() - cachedItem.cachedDate.getTime()) / 3600000;`
`520`	`520`	`return recordAgeInHoursSinceCached <= this.maxRecordAgeInHours;`
`521`	`521`	`}`
`522`	`522`	`}`
`@@ -555,12 +555,12 @@ public virtual inherited sharing class SOQLCache implements Cacheable {`
`555`	`555`	`public SObject toObject() {`
`556`	`556`	`List<SObject> records = this.toList();`
`557`	`557`
`558`		`- if (records.size() > 1) {`
`559`		`- throw new QueryException('List has more than 1 row for assignment to SObject');`
	`558`	`+ if (records.isEmpty()) {`
	`559`	`+ return null;`
`560`	`560`	`}`
`561`	`561`
`562`		`- if (records.size() == 0) {`
`563`		`- return null;`
	`562`	`+ if (records.size() > 1) {`
	`563`	`+ throw new QueryException('List has more than 1 row for assignment to SObject');`
`564`	`564`	`}`
`565`	`565`
`566`	`566`	`return records[0];`
Original file line number	Diff line number	Diff line change
`@@ -405,20 +405,23 @@ public virtual inherited sharing class SOQL implements Queryable {`
`405`	`405`
`406`	`406`	`@TestVisible // deprecated`
`407`	`407`	`private static void setMock(String mockId, SObject record) {`
`408`		`- SOQL.queryIdToMock.put(mockId, new List<SoqlMock>{ new SoqlMock().useLegacyMockingBehavior() });`
`409`		`- SOQL.queryIdToMock.get(mockId).get(SOQL.queryIdToMock.get(mockId).size() - 1).thenReturn(record);`
	`408`	`+ SOQL.createLegacyMock(mockId).thenReturn(record);`
`410`	`409`	`}`
`411`	`410`
`412`	`411`	`@TestVisible // deprecated`
`413`	`412`	`private static void setMock(String mockId, List<SObject> records) {`
`414`		`- SOQL.queryIdToMock.put(mockId, new List<SoqlMock>{ new SoqlMock().useLegacyMockingBehavior() });`
`415`		`- SOQL.queryIdToMock.get(mockId).get(SOQL.queryIdToMock.get(mockId).size() - 1).thenReturn(records);`
	`413`	`+ SOQL.createLegacyMock(mockId).thenReturn(records);`
`416`	`414`	`}`
`417`	`415`
`418`	`416`	`@TestVisible // deprecated`
`419`	`417`	`private static void setCountMock(String mockId, Integer amount) {`
`420`		`- SOQL.queryIdToMock.put(mockId, new List<SoqlMock>{ new SoqlMock().useLegacyMockingBehavior() });`
`421`		`- SOQL.queryIdToMock.get(mockId).get(SOQL.queryIdToMock.get(mockId).size() - 1).thenReturn(amount);`
	`418`	`+ SOQL.createLegacyMock(mockId).thenReturn(amount);`
	`419`	`+ }`
	`420`	`+`
	`421`	`+ private static SoqlMock createLegacyMock(String mockId) {`
	`422`	`+ SoqlMock mock = new SoqlMock().useLegacyMockingBehavior();`
	`423`	`+ SOQL.queryIdToMock.put(mockId, new List<SoqlMock>{ mock });`
	`424`	`+ return mock;`
`422`	`425`	`}`
`423`	`426`
`424`	`427`	`// Implementation`
`@@ -944,11 +947,11 @@ public virtual inherited sharing class SOQL implements Queryable {`
`944`	`947`
`945`	`948`	`public Boolean doExist() {`
`946`	`949`	`this.builder.fields.clearAllFields(); // other fields not needed`
`947`		`- return this.toList().size() > 0;`
	`950`	`+ return this.setLimit(1).toList().size() > 0;`
`948`	`951`	`}`
`949`	`952`
`950`	`953`	`public override String toString() {`
`951`		`- binder = new Binder(); // clear binding before query build`
	`954`	`+ binder.reset(); // clear binding before query build`
`952`	`955`	`return this.builder.toString();`
`953`	`956`	`}`
`954`	`957`
`@@ -1125,15 +1128,15 @@ public virtual inherited sharing class SOQL implements Queryable {`
`1125`	`1128`	`}`
`1126`	`1129`
`1127`	`1130`	`public override String toString() {`
`1128`		`- String query = '';`
`1129`		`-`
	`1131`	`+ List<String> queryParts = new List<String>();`
	`1132`	`+`
`1130`	`1133`	`for (QueryClause clause : this.clauses) {`
`1131`	`1134`	`if (clause != null) {`
`1132`		`- query += ' ' + clause.toString();`
	`1135`	`+ queryParts.add(clause.toString());`
`1133`	`1136`	`}`
`1134`	`1137`	`}`
`1135`		`-`
`1136`		`- return query.trim();`
	`1138`	`+`
	`1139`	`+ return String.join(queryParts, ' ').trim();`
`1137`	`1140`	`}`
`1138`	`1141`	`}`
`1139`	`1142`
`@@ -2329,6 +2332,11 @@ public virtual inherited sharing class SOQL implements Queryable {`
`2329`	`2332`	`return 'v' + bindIndex;`
`2330`	`2333`	`}`
`2331`	`2334`
	`2335`	`+ public void reset() {`
	`2336`	`+ this.bindIndex = 0;`
	`2337`	`+ this.binding.clear();`
	`2338`	`+ }`
	`2339`	`+`
`2332`	`2340`	`public Map<String, Object> getBindingMap() {`
`2333`	`2341`	`return binding;`
`2334`	`2342`	`}`
`@@ -2429,7 +2437,7 @@ public virtual inherited sharing class SOQL implements Queryable {`
`2429`	`2437`
`2430`	`2438`	`private void stripAdditionalPlainFields(Map<String, Object> recordFilteredFields, SObject record, Set<String> requestedFields) {`
`2431`	`2439`	`for (String field : requestedFields) {`
`2432`		`- recordFilteredFields.put(field, record.get(field) ?? null);`
	`2440`	`+ recordFilteredFields.put(field, record.get(field));`
`2433`	`2441`	`}`
`2434`	`2442`	`}`
`2435`	`2443`
`@@ -2539,12 +2547,12 @@ public virtual inherited sharing class SOQL implements Queryable {`
`2539`	`2547`	`public SObject toObject() {`
`2540`	`2548`	`List<SObject> records = toList();`
`2541`	`2549`
`2542`		`- if (records.size() > 1) {`
`2543`		`- throw new QueryException('List has more than 1 row for assignment to SObject');`
	`2550`	`+ if (records.isEmpty()) {`
	`2551`	`+ return null; // handle: List has no rows for assignment to SObject`
`2544`	`2552`	`}`
`2545`	`2553`
`2546`		`- if (records.size() == 0) {`
`2547`		`- return null; // handle: List has no rows for assignment to SObject`
	`2554`	`+ if (records.size() > 1) {`
	`2555`	`+ throw new QueryException('List has more than 1 row for assignment to SObject');`
`2548`	`2556`	`}`
`2549`	`2557`
`2550`	`2558`	`return records[0];`
`@@ -2621,7 +2629,9 @@ public virtual inherited sharing class SOQL implements Queryable {`
`2621`	`2629`
`2622`	`2630`	`SOQL.syncQueriesIssued++;`
`2623`	`2631`
`2624`		`- if (SOQL.syncQueriesIssued > 100) {`
	`2632`	`+ final Integer MAX_QUERIES_ISSUED_IN_SYNCHRONOUS_TRANSACTION = 100;`
	`2633`	`+`
	`2634`	`+ if (SOQL.syncQueriesIssued > MAX_QUERIES_ISSUED_IN_SYNCHRONOUS_TRANSACTION) {`
`2625`	`2635`	`throw new QueryException('Too many SOQL queries.');`
`2626`	`2636`	`}`
`2627`	`2637`	`}`