feat(push): preserve null (#362)

* feat(push): preserve null

* feat(push): preserve for oracle

* feat(push): update with preserve null for pg and oracle

* fix(push): lint error

* test(preserve): use lino query to set value

* test(preserve): use lino query to set value

* test(preserve): change yaml configuration

* test(preserve): assert that others columns are updated

* chore: add gci linter

* feat(preserve): oracle support

* feat(preserve): add preserve methods for DB2 Dialect

Author: youen

CHANGELOG.md

@@ -14,13 +14,17 @@ Types of changes
 - `Fixed` for any bug fixes.
 - `Security` in case of vulnerabilities.
 
+## [3.4.0]
+
+- `Added` preserve NULL or empty functionality in "lino push update" command
+
 ## [3.3.0]
 
- - `Added` configurable CORS support to http command
+- `Added` configurable CORS support to http command
 
 ## [3.2.1]
 
- - `Fixed`Filter Parameter Not Working in "lino http" Command [#369](https://github.com/CGI-FR/LINO/issues/369)
+- `Fixed` Filter Parameter Not Working in "lino http" Command [#369](https://github.com/CGI-FR/LINO/issues/369)
 
 ## [3.2.0]
 

README.md

@@ -375,6 +375,52 @@ tables:
           bytes: true
 ```
 
+### Preserving `null` Values in the Database
+
+In some use cases, it's important to **preserve `null` values that already exist in the database**, even when incoming data provides a new value. For example, a `null` might indicate intentionally missing or incomplete information that should not be overwritten automatically.
+
+Lino supports this behavior through the `preserve` setting, which can be configured per column in the `tables.yaml` file. To preserve `null` values, you can define:
+
+```yaml
+columns:
+  - name: address2
+    export: string
+    preserve: "null"
+```
+
+With this setting, if the **current value in the database is `null`**, Lino will **skip the update for this column only**, even if the input JSON contains a non-null value. This allows you to maintain the integrity of `null` values that have semantic meaning.
+
+⚠️ **Important:**
+Only the preserved column is skipped — other columns in the same record **will still be updated as usual** if their values change.
+
+The same logic applies to other preservation modes:
+
+* `preserve: empty` skips updates if the current DB value is an **empty string (`""`)**.
+* `preserve: blank` skips updates if the current DB value is **`null`**, **empty**, or consists of **only whitespace** (e.g. `"   "`).
+
+The table below summarizes how `preserve` behaves based on the current database value and the incoming JSON input:
+
+
+| Preserve   | Current DB Value | JSON Input  | Final DB Value | Explanation                                                                                      |
+|------------|------------------|-------------|----------------|------------------------------------------------------------------------------------------------|
+| **default**| `NULL`           | `"new"`    | `"new"`        | No preservation, update applies even if DB is null.                                            |
+| **default**| `""`             | `"new"`    | `"new"`        | No preservation, update applies even if DB is empty string.                                    |
+| **default**| `"   "`          | `"new"`    | `"new"`        | No preservation, update applies even if DB is blank spaces.                                    |
+| **default**| `"old"`          | `"new"`    | `"new"`        | Normal update applies.                                                                          |
+| **null**   | `NULL`           | `"new"`    | `NULL`         | Preserve null: keep DB null even if new value is real.                                         |
+| **null**   | `"   "`          | `"new"`    | `"new"`        | DB is not null, update applies.                                                                |
+| **null**   | `""`             | `"new"`    | `"new"`        | DB is not null, update applies.                                                                |
+| **empty**  | `""`             | `"new"`    | `""`           | Preserve empty string: keep empty string in DB, ignore new value.                              |
+| **empty**  | `NULL`           | `"new"`    | `"new"`        | DB is null, not empty string → update applies.                                                |
+| **empty**  | `"   "`          | `"new"`    | `"new"`        | DB is blank spaces, not empty string → update applies.                                        |
+| **blank**  | `NULL`           | `"new"`    | `NULL`         | Preserve blank: null is considered blank, preserve it.                                        |
+| **blank**  | `""`             | `"new"`    | `""`           | Preserve blank: empty string preserved.                                                       |
+| **blank**  | `"   "`          | `"new"`    | `"   "`        | Preserve blank: spaces-only string preserved.                                                 |
+| **blank**  | `"old"`          | `"new"`    | `"new"`        | Not blank, update applies.                                                                    |
+
+⚠️ **Important:**
+This feature is only supported for Oracle and PostgreSQL databases.
+
 ### How to update primary key
 
 Let's say you have this record in database :

demo/store.json

@@ -0,0 +1 @@
+{"address_id":2,"last_update":"2006-02-15T09:57:12Z","manager_staff_id":1,"store_id":1}

internal/app/push/cli.go

@@ -320,7 +320,7 @@ func (c idToPushConverter) getTable(name string, autoTruncate bool) push.Table {
 
 	columns := []push.Column{}
 	for _, col := range table.Columns {
-		columns = append(columns, push.NewColumn(col.Name, col.Export, col.Import, col.DBInfo.Length, col.DBInfo.ByteBased, autoTruncate))
+		columns = append(columns, push.NewColumn(col.Name, col.Export, col.Import, col.DBInfo.Length, col.DBInfo.ByteBased, autoTruncate, col.Preserve))
 	}
 
 	return push.NewTable(table.Name, table.Keys, push.NewColumnList(columns))

internal/infra/push/datadestination_db2.go

@@ -115,9 +115,11 @@ func (d Db2Dialect) UpdateStatement(tableName string, selectValues []ValueDescri
 
 		headers = append(headers, column)
 
-		sql.WriteString(column.name)
-		sql.WriteString("=")
-		sql.WriteString(d.Placeholder(index + 1))
+		errColumn := appendColumnToSQL(column, sql, d, index)
+		if errColumn != nil {
+			return "", nil, errColumn
+		}
+
 		if index+1 < len(selectValues) {
 			sql.WriteString(", ")
 		}
@@ -172,3 +174,18 @@ func (d Db2Dialect) DisableConstraintStatement(tableName string, constraintName
 func (d Db2Dialect) EnableConstraintStatement(tableName string, constraintName string) string {
 	panic(fmt.Errorf("Not implemented"))
 }
+
+func (d Db2Dialect) SupportPreserve() []string {
+	return []string{
+		string(push.PreserveNothing),
+	}
+}
+
+// BlankTest implements SQLDialect.
+func (d Db2Dialect) BlankTest(name string) string {
+	panic("unimplemented")
+}
+
+func (d Db2Dialect) EmptyTest(name string) string {
+	panic("unimplemented")
+}

internal/infra/push/datadestination_db2_dummy.go

@@ -97,3 +97,18 @@ func (d Db2Dialect) DisableConstraintStatement(tableName string, constraintName
 func (d Db2Dialect) EnableConstraintStatement(tableName string, constraintName string) string {
 	panic(fmt.Errorf("Not implemented"))
 }
+
+func (d Db2Dialect) SupportPreserve() []string {
+	return []string{
+		string(push.PreserveNothing),
+	}
+}
+
+// BlankTest implements SQLDialect.
+func (d Db2Dialect) BlankTest(name string) string {
+	panic("unimplemented")
+}
+
+func (d Db2Dialect) EmptyTest(name string) string {
+	panic("unimplemented")
+}

internal/infra/push/datadestination_db2_test.go

@@ -0,0 +1,50 @@
+// Copyright (C) 2021 CGI France
+//
+// This file is part of LINO.
+//
+// LINO is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// LINO is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with LINO.  If not, see <http://www.gnu.org/licenses/>.
+
+//go:build db2
+// +build db2
+
+package push
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/cgi-fr/lino/pkg/push"
+	_ "github.com/ibmdb/go_ibm_db"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestAppendColumnToSQLWithPreserveBlank(t *testing.T) {
+	sql := &strings.Builder{}
+	column := ValueDescriptor{
+		name: "column",
+		column: push.NewColumn(
+			"column",
+			"",
+			"",
+			0,
+			false,
+			false,
+
+			push.PreserveBlank,
+		),
+	}
+
+	err := appendColumnToSQL(column, sql, Db2Dialect{}, 0)
+	assert.NotNil(t, err)
+}

internal/infra/push/datadestination_mariadb.go

@@ -112,9 +112,11 @@ func (d MariadbDialect) UpdateStatement(tableName string, selectValues []ValueDe
 
 		headers = append(headers, column)
 
-		sql.WriteString(column.name)
-		sql.WriteString("=")
-		sql.WriteString(d.Placeholder(index + 1))
+		errColumn := appendColumnToSQL(column, sql, d, index)
+		if errColumn != nil {
+			return "", nil, errColumn
+		}
+
 		if index+1 < len(selectValues) {
 			sql.WriteString(", ")
 		}
@@ -164,3 +166,18 @@ func (d MariadbDialect) DisableConstraintStatement(tableName string, constraintN
 func (d MariadbDialect) EnableConstraintStatement(tableName string, constraintName string) string {
 	panic(fmt.Errorf("Not implemented"))
 }
+
+func (d MariadbDialect) SupportPreserve() []string {
+	return []string{
+		string(push.PreserveNothing),
+	}
+}
+
+// BlankTest implements SQLDialect.
+func (d MariadbDialect) BlankTest(name string) string {
+	panic("unimplemented")
+}
+
+func (d MariadbDialect) EmptyTest(column string) string {
+	return fmt.Sprintf("%s = ''", column)
+}

internal/infra/push/datadestination_mariadb_test.go

@@ -0,0 +1,70 @@
+// Copyright (C) 2021 CGI France
+//
+// This file is part of LINO.
+//
+// LINO is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// LINO is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with LINO.  If not, see <http://www.gnu.org/licenses/>.
+
+package push
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/cgi-fr/lino/pkg/push"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestAppendColumnToSQLMariaDBWithPreserveBlank(t *testing.T) {
+	t.Parallel()
+	sql := &strings.Builder{}
+	column := ValueDescriptor{
+		name: "column",
+		column: push.NewColumn(
+			"column",
+			"",
+			"",
+			0,
+			false,
+			false,
+
+			push.PreserveBlank,
+		),
+	}
+
+	err := appendColumnToSQL(column, sql, MariadbDialect{}, 0)
+	assert.NotNil(t, err)
+}
+
+func TestAppendColumnToSQLMariaDB(t *testing.T) {
+	t.Parallel()
+	sql := &strings.Builder{}
+	column := ValueDescriptor{
+		name: "column",
+		column: push.NewColumn(
+			"column",
+			"",
+			"",
+			0,
+			false,
+			false,
+
+			push.PreserveNothing,
+		),
+	}
+
+	err := appendColumnToSQL(column, sql, MariadbDialect{}, 0)
+	assert.Nil(t, err)
+
+	assert.Equal(t, "column=?", sql.String())
+}

internal/infra/push/datadestination_oracle.go

@@ -138,6 +138,7 @@ func (d OracleDialect) UpdateStatement(tableName string, selectValues []ValueDes
 			for _, pk := range whereValues {
 				if column.name == pk.name {
 					isInWhere = true
+
 					break
 				}
 			}
@@ -148,17 +149,21 @@ func (d OracleDialect) UpdateStatement(tableName string, selectValues []ValueDes
 
 		headers = append(headers, column)
 
-		sql.WriteString(column.name)
-		sql.WriteString("=")
-		sql.WriteString(d.Placeholder(index + 1))
+		errColumn := appendColumnToSQL(column, sql, d, index)
+		if errColumn != nil {
+			return "", nil, errColumn
+		}
+
 		if index+1 < len(selectValues) {
 			sql.WriteString(", ")
 		}
 	}
 	if len(whereValues) > 0 {
 		sql.WriteString(" WHERE ")
 	} else {
-		return "", nil, &push.Error{Description: fmt.Sprintf("can't update table [%s] because no primary key is defined", tableName)}
+		return "", nil, &push.Error{
+			Description: fmt.Sprintf("can't update table [%s] because no primary key is defined", tableName),
+		}
 	}
 	for index, pk := range whereValues {
 		headers = append(headers, pk)
@@ -243,3 +248,20 @@ func (d OracleDialect) EnableConstraintStatement(tableName string, constraintNam
 	sql.WriteString(constraintName)
 	return sql.String()
 }
+
+func (d OracleDialect) SupportPreserve() []string {
+	return []string{
+		string(push.PreserveNothing),
+		string(push.PreserveNull),
+		string(push.PreserveBlank),
+	}
+}
+
+// BlankTest implements SQLDialect.
+func (d OracleDialect) BlankTest(column string) string {
+	return fmt.Sprintf("TRIM(%s) IS NULL", column)
+}
+
+func (d OracleDialect) EmptyTest(column string) string {
+	return fmt.Sprintf("%s IS NULL", column)
+}