Getting the static formulas being processed on input, not re-processing on output.

packages/builder/src/components/backend/DataTable/modals/CreateEditColumn.svelte

@@ -435,18 +435,20 @@
       error={errors.relatedName}
     />
   {:else if field.type === FORMULA_TYPE}
-    <Select
+    {#if !table.sql}
-      label="Formula type"
+      <Select
-      bind:value={field.formulaType}
+        label="Formula type"
-      options={[
+        bind:value={field.formulaType}
-        { label: "Dynamic", value: "dynamic" },
+        options={[
-        { label: "Static", value: "static" },
+          { label: "Dynamic", value: "dynamic" },
-      ]}
+          { label: "Static", value: "static" },
-      getOptionLabel={option => option.label}
+        ]}
-      getOptionValue={option => option.value}
+        getOptionLabel={option => option.label}
-      tooltip="Dynamic formula are calculated when retrieved, but cannot be filtered,
+        getOptionValue={option => option.value}
-       while static formula are calculated when the row is saved."
+        tooltip="Dynamic formula are calculated when retrieved, but cannot be filtered,
-    />
+         while static formula are calculated when the row is saved."
+      />
+    {/if}
     <ModalBindableInput
       title="Formula"
       label="Formula"

packages/server/src/api/controllers/row/internalSearch.js

@@ -37,22 +37,30 @@ class QueryBuilder {
   }
 
   setLimit(limit) {
-    this.limit = limit
+    if (limit != null) {
+      this.limit = limit
+    }
     return this
   }
 
   setSort(sort) {
-    this.sort = sort
+    if (sort != null) {
+      this.sort = sort
+    }
     return this
   }
 
   setSortOrder(sortOrder) {
-    this.sortOrder = sortOrder
+    if (sortOrder != null) {
+      this.sortOrder = sortOrder
+    }
     return this
   }
 
   setSortType(sortType) {
-    this.sortType = sortType
+    if (sortType != null) {
+      this.sortType = sortType
+    }
     return this
   }
 

packages/server/src/constants/index.js

@@ -58,6 +58,11 @@ exports.RelationshipTypes = {
   MANY_TO_MANY: "many-to-many",
 }
 
+exports.FormulaTypes = {
+  STATIC: "static",
+  DYNAMIC: "dynamic",
+}
+
 exports.AuthTypes = {
   APP: "app",
   BUILDER: "builder",

packages/server/src/utilities/rowProcessor/index.js

@@ -229,11 +229,12 @@ exports.inputProcessing = (
       }
       continue
     }
-    // specific case to delete formula values if they get saved
+    // remove any formula values, they are to be generated
-    // type coercion cannot completely remove the field, so have to do it here
     if (field.type === FieldTypes.FORMULA) {
       delete clonedRow[key]
-    } else {
+    }
+    // otherwise coerce what is there to correct types
+    else {
       clonedRow[key] = exports.coerce(value, field.type)
     }
   }
@@ -243,6 +244,9 @@ exports.inputProcessing = (
     clonedRow._rev = row._rev
   }
 
+  // now process the static formulas
+  clonedRow = processFormulas(table, clonedRow, { dynamic: false })
+
   // handle auto columns - this returns an object like {table, row}
   return processAutoColumn(user, copiedTable, clonedRow, opts)
 }
@@ -273,7 +277,7 @@ exports.outputProcessing = async (
   let enriched = await linkRows.attachFullLinkedDocs(ctx, table, rows)
 
   // process formulas
-  enriched = processFormulas(table, enriched)
+  enriched = processFormulas(table, enriched, { dynamic: true })
 
   // update the attachments URL depending on hosting
   for (let [property, column] of Object.entries(table.schema)) {

packages/server/src/utilities/rowProcessor/utils.js

@@ -1,16 +1,21 @@
-const { FieldTypes } = require("../../constants")
+const { FieldTypes, FormulaTypes } = require("../../constants")
 const { processStringSync } = require("@budibase/string-templates")
 
 /**
  * Looks through the rows provided and finds formulas - which it then processes.
  */
-exports.processFormulas = (table, rows) => {
+exports.processFormulas = (table, rows, { dynamic } = { dynamic: true }) => {
   const single = !Array.isArray(rows)
   if (single) {
     rows = [rows]
   }
   for (let [column, schema] of Object.entries(table.schema)) {
-    if (schema.type !== FieldTypes.FORMULA) {
+    const isStatic = schema.formulaType === FormulaTypes.STATIC
+    if (
+      schema.type !== FieldTypes.FORMULA ||
+      (dynamic && isStatic) ||
+      (!dynamic && !isStatic)
+    ) {
       continue
     }
     // iterate through rows and process formula