Comment gérer les champs nullables pour la génération csv?

Question

Je crée à partir d'une source json un csv que je veux utiliser pour remplir une base de données memsql à l'aide de LOAD DATA INFILE.

J'ai écrit un script de type pour la conversation et j'utilise la bibliothèque json2csv.

Il laisse les valeurs pour les entrées vides Nulled cependant, la création d'une chaîne comme:

foo, bar, , barz, 11 , 

Pourtant, je mes sortie soit:

foo, bar, \N , barz, 11 , \N 

pour mes champs Nulled. Sinon, ma base de données remplira différentes valeurs par défaut, telles que 0 pour un nombre qui devrait être NULL.

Je me suis retrouvé à faire:

const someEntitites.map((entity: Entity) => { 
    entity.foo = entity.foo === null ? '\\N' : entity.foo; 
    entity.bar = entity.bar === null ? '\\N' : entity.bar; 
    ... 

    return entity; 
} 

Donc, fondamentalement, je suis hardcoding mon approche à mon entité, et je suis aussi sujette à des bugs, car je pourrais avoir oublié de vérifier une propriété annulable. Et si je dois exporter une autre table, je dois répéter cela encore une fois.

Comment est-ce que je peux généraliser ceci, ainsi je peux employer ceci sur différentes entités où le manuscrit "découvre" les champs nullables et place le marqueur en conséquence?

Answer 1

J'ai créé une fonction qui effectue une itération sur ses propres propriétés et définit sa valeur \N si la valeur selon est null:

const handleNullCases = (record: any): any => { 
    for (let key in record) { 
     if (record.hasOwnProperty(key)) { 
      const value = record[key]; 
      if (value === null) { 
       record[key] = "\\N"; 
      } 
     } 
    } 

    return record; 
}; 

De cette façon, je peux réutiliser cette snipplet pour d'autres entités ainsi:

const processedEntities = entities.map(handleNullCases); 
const processedEntities2 = entities2.map(handleNullCases); 
... 

Je trouve cela un peu sale, car je tape simplement any et je convertis la valeur en une chaîne même si elle a été déclarée comme un autre type.

Answer 2

Je vais supposer que toutes les propriétés dans Entity peuvent être null. Si oui, ce frappe est un peu plus sûr:

type Nullable<T> = {[K in keyof T]: T[K] | null}; 
type CSVSafe<T> = {[K in keyof T]: T[K] | '\\N'}; 

const handleNullCases = <E>(record: Nullable<E>): CSVSafe<E> => { 
    let ret = Object.assign(record) as CSVSafe<E>; 
    Object.keys(ret).forEach((key: keyof E) => { 
    if (record[key] === null) { 
     ret[key] = '\\N'; 
    } 
    }); 
    return ret; 
}; 

type Entity = Nullable<{ a: number, b: string, c: boolean, d: number, e: string }>; 
const entity: Entity = { a: 1, b: null, c: false, d: null, e: 'e' }; 
const safeEntity = handleNullCases(entity); 
// type CSVSafe<{ a: number; b: string; c: boolean; d: number; e: string; }> 

La fonction handleNullCases prendra tout objet dont les valeurs pourraient être null, et retourner un nouvel objet qui est la même chose, sauf que null valeurs ont été remplacées par "\\N". Le type de sortie sera une version CSVSafe<> du type d'entrée Nullable<>.

Espérons que cela aide.