Serveur d'impression

Comment charger les données JSON dans SQL Server de différentes manières – Serveur d’impression

Le 19 mai 2020 - 15 minutes de lecture

Récemment, j'ai écrit un article montrant
Comment charger les données d'Excel dans SQL Server de différentes manières. Cela m'a vraiment donné beaucoup d'occasions de mettre à jour mes compétences techniques. Je sais certainement que sans la poussée, il n'y aura pas de point de départ dans l'apprentissage.

Dans cet article, je montre les moyens les plus efficaces que je connaisse pour charger des données JSON dans un serveur Microsoft SQL. Si vous connaissez d'autres moyens qui vous semblent plus efficaces, veuillez partager vos idées dans la section des commentaires ci-dessous. Notez que certaines personnalisations peuvent encore être nécessaires pour répondre à votre propre projet.


Préparation

Étape 1. Créer la structure de table pour Table
TableJSON en exécutant la commande SQL ci-dessous:

CRÉER UNE TABLE [dbo].[TableJSON](
    [Dates] [datetime]    NUL,
    [Type] [varchar](1) NULL,
    [Code] [varchar](20) NUL,
    [Price] [money]    NUL,
    [Unit] [int]    NUL,
    [SubTotal] [money]    NUL,
    [Brokeage Rate] [money]    NUL,
    [Tax] [money]    NUL,
    [Stamp Duty] [money]    NUL,
    [Clearing Fee] [money]    NUL,
    [Amount] [money]    NUL,
    [Svc Cost] [money]    NUL
) SUR [PRIMARY]
ALLER


Étape 2. Copiez et collez les données JSON suivantes dans un fichier physique et nommez-les source.json ou vous pouvez télécharger une copie de
fichier source.json ici.

[
        "Dates": "2018-02-03T00:00:00",
        "Type": "B",
        "Code": "AB 101",
        "Price": 4.8800,
        "Unit": 500,
        "SubTotal": 2440.0000,
        "Brokeage Rate": 28.0000,
        "Tax": 1.6800,
        "Stamp Duty": 3.0000,
        "Clearing Fee": 0.7400,
        "Amount": 2473.4200,
        "Svc Cost": 33.4200
    , 
        "Dates": "2018-03-09T00:00:00",
        "Type": "B",
        "Code": "AB 101",
        "Price": 4.8500,
        "Unit": 500,
        "SubTotal": 2425.0000,
        "Brokeage Rate": 28.0000,
        "Tax": 1.6800,
        "Stamp Duty": 3.0000,
        "Clearing Fee": 0.7300,
        "Amount": 2458.4100,
        "Svc Cost": 33.4100
    , 
        "Dates": "2018-04-25T00:00:00",
        "Type": "B",
        "Code": "DX 012",
        "Price": 8.9300,
        "Unit": 300,
        "SubTotal": 2679.0000,
        "Brokeage Rate": 28.0000,
        "Tax": 1.6800,
        "Stamp Duty": 3.0000,
        "Clearing Fee": 0.8100,
        "Amount": 2712.4900,
        "Svc Cost": 33.4900
    , 
        "Dates": "2018-06-27T00:00:00",
        "Type": "D",
        "Code": "AB 101",
        "Price": 19.0000,
        "Unit": 1,
        "SubTotal": 19.0000,
        "Tax": 0.0000,
        "Amount": 19.0000
    , 
        "Dates": "2018-07-26T00:00:00",
        "Type": "B",
        "Code": "ND 252",
        "Price": 26.9000,
        "Unit": 100,
        "SubTotal": 2690.0000,
        "Brokeage Rate": 28.0000,
        "Tax": 1.6800,
        "Stamp Duty": 3.0000,
        "Clearing Fee": 0.8100,
        "Amount": 2723.4900,
        "Svc Cost": 33.4900
    , 
        "Dates": "2018-08-15T00:00:00",
        "Type": "B",
        "Code": "EW 013",
        "Price": 3.0500,
        "Unit": 800,
        "SubTotal": 2440.0000,
        "Brokeage Rate": 28.0000,
        "Tax": 1.6800,
        "Stamp Duty": 3.0000,
        "Clearing Fee": 0.7400,
        "Amount": 2473.4200,
        "Svc Cost": 33.4200
    , 
        "Dates": "2018-10-22T00:00:00",
        "Type": "B",
        "Code": "ND 252",
        "Price": 21.9000,
        "Unit": 100,
        "SubTotal": 2190.0000,
        "Brokeage Rate": 28.0000,
        "Tax": 1.6800,
        "Stamp Duty": 3.0000,
        "Clearing Fee": 0.6600,
        "Amount": 2223.3400,
        "Svc Cost": 33.3400
    , 
        "Dates": "2018-11-22T00:00:00",
        "Type": "D",
        "Code": "ND 252",
        "Price": 0.2600,
        "Unit": 100,
        "SubTotal": 26.0000,
        "Tax": 0.0000,
        "Amount": 26.0000
    , 
        "Dates": "2018-12-18T00:00:00",
        "Type": "B",
        "Code": "FP 009",
        "Price": 5.7800,
        "Unit": 500,
        "SubTotal": 2890.0000,
        "Brokeage Rate": 28.0000,
        "Tax": 1.6800,
        "Stamp Duty": 3.0000,
        "Clearing Fee": 0.8700,
        "Amount": 2923.5500,
        "Svc Cost": 33.5500
    , 
        "Dates": "2019-01-02T00:00:00",
        "Type": "D",
        "Code": "DX 012",
        "Price": 0.2500,
        "Unit": 300,
        "SubTotal": 75.0000,
        "Tax": 0.0000,
        "Amount": 75.0000
    , 
        "Dates": "2019-02-10T00:00:00",
        "Type": "D",
        "Code": "AB 101",
        "Price": 0.0190,
        "Unit": 1000,
        "SubTotal": 19.0000,
        "Tax": 0.0000,
        "Amount": 19.0000
    , 
        "Dates": "2019-03-11T00:00:00",
        "Type": "D",
        "Code": "EW 013",
        "Price": 0.0600,
        "Unit": 800,
        "SubTotal": 48.0000,
        "Tax": 0.0000,
        "Amount": 48.0000
    , 
        "Dates": "2019-04-21T00:00:00",
        "Type": "B",
        "Code": "ND 252",
        "Price": 19.6800,
        "Unit": 100,
        "SubTotal": 1968.0000,
        "Brokeage Rate": 28.0000,
        "Tax": 1.6800,
        "Stamp Duty": 2.0000,
        "Clearing Fee": 0.6000,
        "Amount": 2000.2800,
        "Svc Cost": 32.2800
    , 
        "Dates": "2019-05-12T00:00:00",
        "Type": "B",
        "Code": "DX 012",
        "Price": 8.8200,
        "Unit": 300,
        "SubTotal": 2646.0000,
        "Brokeage Rate": 28.0000,
        "Tax": 1.6800,
        "Stamp Duty": 3.0000,
        "Clearing Fee": 0.8000,
        "Amount": 2679.4800,
        "Svc Cost": 33.4800
    , 
        "Dates": "2019-06-18T00:00:00",
        "Type": "D",
        "Code": "FP 009",
        "Price": 0.0650,
        "Unit": 500,
        "SubTotal": 32.5000,
        "Tax": 0.0000,
        "Amount": 32.5000
    , 
        "Dates": "2019-07-26T00:00:00",
        "Type": "D",
        "Code": "ND 252",
        "Price": 0.2900,
        "Unit": 300,
        "SubTotal": 87.0000,
        "Tax": 0.0000,
        "Amount": 87.0000
    , 
        "Dates": "2019-08-04T00:00:00",
        "Type": "B",
        "Code": "KE 130",
        "Price": 0.9850,
        "Unit": 3200,
        "SubTotal": 3152.0000,
        "Brokeage Rate": 28.0000,
        "Tax": 1.6800,
        "Stamp Duty": 4.0000,
        "Clearing Fee": 0.9500,
        "Amount": 3186.6300,
        "Svc Cost": 34.6300
    , 
        "Dates": "2019-09-27T00:00:00",
        "Type": "D",
        "Code": "AB 101",
        "Price": 0.0180,
        "Unit": 1000,
        "SubTotal": 18.0000,
        "Tax": 0.0000,
        "Amount": 18.0000
    , 
        "Dates": "2019-10-14T00:00:00",
        "Type": "B",
        "Code": "DX 012",
        "Price": 8.5900,
        "Unit": 400,
        "SubTotal": 3436.0000,
        "Brokeage Rate": 28.0000,
        "Tax": 1.6800,
        "Stamp Duty": 4.0000,
        "Clearing Fee": 1.0400,
        "Amount": 3470.7200,
        "Svc Cost": 34.7200
    , 
        "Dates": "2019-11-09T00:00:00",
        "Type": "D",
        "Code": "KE 130",
        "Price": 0.0184,
        "Unit": 3200,
        "SubTotal": 58.8800,
        "Tax": 5.8900,
        "Amount": 52.9900,
        "Svc Cost": 5.8900
    , 
        "Dates": "2019-12-30T00:00:00",
        "Type": "B",
        "Code": "PC 924",
        "Price": 6.4200,
        "Unit": 600,
        "SubTotal": 3852.0000,
        "Brokeage Rate": 28.0000,
        "Tax": 1.6800,
        "Stamp Duty": 4.0000,
        "Clearing Fee": 1.1600,
        "Amount": 3886.8400,
        "Svc Cost": 34.8400
    , 
        "Dates": "2020-01-04T00:00:00",
        "Type": "B",
        "Code": "FP 009",
        "Price": 4.9200,
        "Unit": 800,
        "SubTotal": 3936.0000,
        "Brokeage Rate": 28.0000,
        "Tax": 1.6800,
        "Stamp Duty": 4.0000,
        "Clearing Fee": 1.1900,
        "Amount": 3970.8700,
        "Svc Cost": 34.8700
    , 
        "Dates": "2020-01-18T00:00:00",
        "Type": "D",
        "Code": "ND 252",
        "Price": 0.3300,
        "Unit": 300,
        "SubTotal": 99.0000,
        "Tax": 0.0000,
        "Amount": 99.0000
    , 
        "Dates": "2020-02-27T00:00:00",
        "Type": "D",
        "Code": "AB 101",
        "Price": 0.0180,
        "Unit": 1000,
        "SubTotal": 18.0000,
        "Tax": 0.0000,
        "Amount": 18.0000
    , 
        "Dates": "2020-03-27T00:00:00",
        "Type": "D",
        "Code": "PC 924",
        "Price": 0.0700,
        "Unit": 600,
        "SubTotal": 42.0000,
        "Tax": 0.0000,
        "Amount": 42.0000
    
]


Comment charger les données de JSON dans SQL Server

1) Utilisation de SQL Server Management Studio – commandes OPENROWSET + OPENJSON

2) Utilisation de SSIS dans Visual Studio

3) Utilisation de PowerShell

4) Utilisation de Node.js

5) Utiliser Python

6) Utilisation de SQL Server Management Studio – commande sp_execute_external_script

7) Utilisation de .NET (C #)

8) Utiliser PHP

9) Utilisation de Java

10) Utiliser Golang

* La liste ci-dessus sera mise à jour en temps voulu.

1) Utilisation de SQL Server Management Studio – Commandes OPENROWSET + OPENJSON

Pour importer les données, nous pouvons essayer les scripts SQL suivants:

-Ceci est à des fins de test, alors nettoyez la table
TRUNCATE TABLE TableJSON;


--Importez les données dans la table cible
INSÉRER DANS TableJSON
SELECT tbl. *
FROM OPENROWSET (BULK 'C:  yourpath  source.json', SINGLE_CLOB) js
CROSS APPLY OPENJSON (BulkColumn)
AVEC
(
    [Dates] [datetime],
    [Type] [varchar](1),
    [Code] [varchar](20) ou
    [Price] [money],
    [Unit] [int],
    [SubTotal] [money],
    [Brokeage Rate] [money],
    [Tax] [money],
    [Stamp Duty] [money],
    [Clearing Fee] [money],
    [Amount] [money],
    [Svc Cost] [money]



) tbl;

Remarque: vous pouvez rencontrer l'erreur suivante lorsque vous exécutez la commande OPENROWSET.

SQL Server a bloqué l'accès à la DÉCLARATION «OpenRowset / OpenDatasource» du composant «Ad Hoc Distributed Queries» car ce composant est désactivé dans le cadre de la configuration de sécurité de ce serveur. Un administrateur système peut activer l'utilisation de «requêtes distribuées ad hoc» à l'aide de sp_configure. Pour plus d'informations sur l'activation des «requêtes distribuées ad hoc», recherchez «requêtes distribuées ad hoc» dans la documentation en ligne de SQL Server.

Pour résoudre le problème, vous devez exécuter les commandes SQL suivantes:

EXEC sp_configure 'afficher les options avancées', 1
RECONFIGURER AVEC OVERRIDE
ALLER

EXEC sp_configure 'requêtes distribuées ad hoc', 1
RECONFIGURER AVEC OVERRIDE
ALLER

EXEC master.dbo.sp_MSset_oledb_prop N'Microsoft.ACE.OLEDB.15.0 ', N'AllowInProcess', 1
ALLER

EXEC master.dbo.sp_MSset_oledb_prop N'Microsoft.ACE.OLEDB.15.0 ', N'DynamicParameters', 1
ALLER

le
La commande OPENJSON SQL est relativement nouvelle dans SQL Server mais nous nous rendons compte qu'elle a commencé à gagner en popularité auprès des utilisateurs de SQL Server car elle peut être utilisée pour lire facilement des données au format JSON.

Si tout est fait correctement, vous devriez pouvoir voir les données correctement insérées.



Ensuite, vous pouvez examiner les données qui ont été importées dans le
table: TableJSON dans SQL Server.



2) Utilisation de SSIS dans Visual Studio

Pour créer un projet SSIS dans Visual Studio, vous devez d'abord télécharger et installer le
Outils de données SQL Server (SSDT) séparément.

Télécharger SQL Server Data Tools (SSDT) ​​pour Visual Studio

Une fois installé et disponible, vous devriez pouvoir voir une nouvelle note d'arbre appelée
L'intelligence d'entreprise, puis sélectionnez
Projet de services intégrés continuer.



Pour commencer, nous pouvons faire glisser et déposer un
Exécuter une tâche SQL dans le flux de contrôle.

Ensuite, nous devons configurer le
Connexion aussi bien que
SQLStatement à exécuter, qui consiste à nettoyer la table cible avec SQL ci-dessous:

Truncate Table TableJSON;




Après cela, faites glisser et déposez un
Tâche de flux de données sous la tâche d'exécution SQL que nous avons créée.

Une fois cela fait, sélectionnez la tâche d'exécution SQL et une flèche verte apparaîtra.



Faites glisser la flèche verte vers le haut de la tâche de flux de données et reliez-les ensemble.



Maintenant, double-cliquez sur la tâche de flux de données, et cela nous amènera à la
Flux de données languette.

le
Le flux de données est l'endroit où nous sélectionnons, transformons la source de données, puis la chargeons dans une destination de données.

Tout d'abord, nous devons sélectionner et faire glisser le
Source OLE DB de
Boîte à outils SSIS> Autres sources dans l'espace de travail Flux de données.

Double-cliquez sur la source OLE DB pour modifier le gestionnaire de connexions, le mappage des colonnes, la gestion des erreurs.



Pour le
Mode d'accès aux données, nous devons sélectionner
Commande SQL et entrez le SQL suivant, qui correspond exactement aux commandes OPENROWSET + OPENJSON dans la méthode précédente pour
Texte de commande SQL.

SELECT tbl. *
FROM OPENROWSET (BULK 'C:  yourpath  source.json', SINGLE_CLOB) js
CROSS APPLY OPENJSON (BulkColumn)
AVEC
(
    [Dates] [datetime],
    [Type] [varchar](1),
    [Code] [varchar](20) ou
    [Price] [money],
    [Unit] [int],
    [SubTotal] [money],
    [Brokeage Rate] [money],
    [Tax] [money],
    [Stamp Duty] [money],
    [Clearing Fee] [money],
    [Amount] [money],
    [Svc Cost] [money]



) tbl;

Une fois cela fait, nous devons sélectionner et faire glisser le
Destination OLE DB de
Boîte à outils SSIS> Autres destinations dans l'espace de travail Flux de données.



Ensuite, reliez les flux ensemble.



Essayez d'exécuter le package en cliquant sur le
Début (ou appuyez sur la touche F5).

Vous devriez pouvoir voir que le package est exécuté avec succès.



Ensuite, vous pouvez examiner les données qui ont été importées dans le
table: TableJSON dans SQL Server.

3) Utilisation de PowerShell

PowerShell est un outil très puissant développé dans .NET et peut faciliter de nombreuses tâches efficacement.

Pour importer JSON directement dans SQL Server, nous devrons installer 1 bibliothèque supplémentaire

Nous pouvons installer cette bibliothèque à partir de la commande
Install-Module, tel que:

Dbatools du module d'installation

Une fois les bibliothèques installées, nous pouvons essayer les scripts suivants pour importer les données JSON dans SQL Server

$ TargetServer = 'ServerName'
$ TargetDb = 'DatabaseName'
$ TableName = 'TableJSON'

$ SourcePath = 'C:  yourpath  source.json'

essayer ConvertFrom-Json

$ data 
capture
 Erreur:" + $ ErrorMessage + "-" + $ FailedItem);

La commande
ConvertFrom-Json convertit une chaîne au format JSON en un objet personnalisé ou une table de hachage.

La commande
Write-DbaDbTableData est très puissant. Vous devriez consulter la documentation sur les fonctionnalités disponibles.

Vous devriez pouvoir voir que le script est exécuté avec succès.



Ensuite, vous pouvez examiner les données qui ont été importées dans le
table: TableJSON dans SQL Server.

4) Utilisation de Node.js

Pour importer les données JSON dans SQL Server, vous devrez peut-être d'abord installer la bibliothèque appropriée requise pour la connexion.

Une fois l'installation terminée, vous pouvez préparer et exécuter les codes ci-dessous:

«utiliser strictement»;
var http = require ('http');
var port = process.env.PORT || 1337;


http.createServer (fonction (req, res) {
if (req.url === '/favicon.ico') 
res.writeHead (200, 'Content-Type': 'image / x-icon');
res.end (/ * contenu de l'icône ici * /);
 autre {
res.writeHead (200, 'Content-Type': 'text / plain');


essayez {
const conn = require ('mssql');


//Réglages
var TableName = 'TableJSON';
var SourceFile = 'C: \ yourpath \ source.json';


var config = 
serveur: 'ServerName',
base de données: 'DatabaseName',
authentification: 
tapez: 'default',
options: 
userName: 'UserID',
mot de passe: 'Password'

,
options: 
encrypt: false // Définissez sur true si vous vous connectez à Azure

;


// Charger les données JSON
var fs = require ('fs');
var contents = fs.readFileSync (SourceFile);
var xlData = JSON.parse (contenu);


conn.connect (config, fonction (err) {
si (err) 
console.log (err);



// Nettoyer la table cible
var sql = 'Truncate Table' + TableName;
conn.query (sql, fonction (err, résultat) 
si (err) 
console.log (err);

);


// Lire les champs de la table cible
var sql = 'SELECT COLUMN_NAME, DATA_TYPE, CHARACTER_MAXIMUM_LENGTH, NUMERIC_PRECISION, NUMERIC_SCALE FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_NAME = N ' '+ TableName +'  'ORDER BY ORDINAL_POSITION';
conn.query (sql, fonction (err, résultat) {
si (err) 
console.log (err);
 autre {
var cols = result.recordset;


var table = new conn.Table (TableName);
table.create = false;


if ((typeof (cols)! == 'indéfini') && (cols! == null)) 
pour (var i = 0; i <cols.length; i ++) 
commutateur (cols[i]['DATA_TYPE']) 
cas 'datetime':
table.columns.add (cols[i]['COLUMN_NAME'], conn.Date, nullable: true);
Pause;
cas 'varchar':
table.columns.add (cols[i]['COLUMN_NAME'], conn.VarChar (cols[i]['CHARACTER_MAXIMUM_LENGTH']), nullable: true);
Pause;
cas «argent»:
cas «décimal»:
table.columns.add (cols[i]['COLUMN_NAME'], conn.Décimal (cols[i]['NUMERIC_PRECISION'], cols[i]['NUMERIC_SCALE']), nullable: true);
Pause;
cas 'int':
table.columns.add (cols[i]['COLUMN_NAME'], conn.Int, nullable: true);
Pause;
défaut:
// Ne peut pas être mappé
Pause;





pour (ligne var dans xlData) 


// Insérer dans la table cible
var req = new conn.Request ();
conn.connect (config, fonction (err) 
si (err) 
console.log (err);



req.bulk (table, fonction (err, rowCount) 
//console.log(table);


si (err) 
console.log (err);
 autre ' + rowCount.rowsAffected + 'lignes affecté');



);
);
}
});
});


res.end ('terminé!');


} catch (err) 
console.log (err);

}
}). listen (port);

Vous obtiendrez probablement l'erreur ci-dessous lors de l'exécution des codes ci-dessus.

Impossible de se connecter à YourServerName: 1433 – Impossible de se connecter (séquence)

Pour résoudre ce problème, nous devons nous assurer que le
TCP / IP le paramètre est activé sous
Protocoles pour MSSQLServer. Nous pouvons trouver ce paramètre en lançant
Gestion d'ordinateur puis recherchez
Services et applications> Gestionnaire de configuration SQL Server> Configuration réseau SQL Server.



Une fois que vous avez fait cela et réexécuté les codes, vous devriez pouvoir voir que le script est exécuté avec succès.



Ensuite, vous pouvez examiner les données qui ont été importées dans le
table: TableJSON dans SQL Server.

5) Utiliser Python

L'exécution en Python est également facile.

Avant l'exécution, vous devez installer les modules suivants:

Nous pouvons installer ces deux bibliothèques à partir de la commande
installation de pip, telle que:

pip installer des pandas

pip installer Flask-SQLAlchemy

Le script se présente comme suit:

depuis sqlalchemy import create create_engine
importer urllib
importer des pandas en tant que pd
importer datetime comme dt

# Réglages
TargetServer = 'ServerName'
SchemaName = 'dbo'
TargetDb = 'DatabaseName'
TableName = 'TableJSON'
UserName = 'UserID'
Mot de passe = 'Mot de passe'
SourceFile = "C: \ yourpath \ source.json"

# Configurer la connexion
Params = urllib.parse.quote_plus (r'DRIVER = SQL Server; SERVER = '+ TargetServer +'; DATABASE = '+ TargetDb +'; UID = '+ UserName +'; PWD = '+ Password)
ConnStr = 'mssql + pyodbc: ///? Odbc_connect = ' .format (Params)
Moteur = create_engine (ConnStr)

# Charger le json dans un DataFrame
df = pd.read_json (SourceFile)

# Effacer les données du tableau cible
sql = 'Truncate Table' + TableName
avec Engine.begin () comme conn:
conn.execute (sql)

# Charger les données de DataFrame dans la table
df.to_sql (TableName, con = Engine, schema = SchemaName, if_exists = 'append', index = False)

print (dt.datetime.now (). strftime ("% Y-% m-% d% H:% M:% S") + '| Données importées avec succès')

Nous utilisons Pandas '
read_jsonmethod pour charger JSON dans une trame de données.

Vous devriez pouvoir voir que le script est exécuté avec succès.



Ensuite, vous pouvez examiner les données qui ont été importées dans le
table: TableJSON dans SQL Server.

6) Utilisation de SQL Server Management Studio – commande sp_execute_external_script

En raison de la popularité des programmes Machine Learning, à partir de SQL Server 2016, nous sommes en mesure d'exécuter des scripts Python et R dans l'environnement SQL Server, en particulier, le
sp_execute_external_script est utilisée.

Avant d'exécuter les scripts, nous devons effectuer une configuration:

a) Exécutez le script SQL ci-dessous pour activer les paramètres:

sp_configure 'scripts externes activés', 1;
RECONFIGURER AVEC OVERRIDE;

b) Redémarrez les services SQL Server.

Une fois cela fait, nous pouvons exécuter le script SQL ci-dessous:

--Effacer le tableau cible
Truncate Table TableJSON;

--Importer des données dans la table cible
INSÉRER DANS TableJSON
EXEC sp_execute_external_script
@language = N'Python ',
@script =
N '
# Importer des bibliothèques
importer des pandas en tant que pd

# Charger JSON
SourceFile = "C: \ yourpath \ source.json"

df = pd.read_json (SourceFile)
df = pd.DataFrame (données = df, colonnes =[''Dates'', ''Type'', ''Code'', ''Price'', ''Unit'', ''SubTotal'', ''Brokeage Rate'', ''Tax'', ''Stamp Duty'', ''Clearing Fee'', ''Amount'', ''Svc Cost''])

OutputDataSet = df
"

Vous devriez pouvoir voir que le script est exécuté avec succès.

Ensuite, vous pouvez examiner les données qui ont été importées dans le
table: TableJSON dans SQL Server.

7) Utilisation de .NET (C #)

Dans l'environnement .NET, nous pourrions utiliser un
Objet SqlBulkCopy pour importer efficacement des données dans la base de données.

String ConnStr_SQLServer = "Source de données = ServerName; Initial Catalog = TableName; Persist Security Info = True; User ID = UserID; Password = Password";
String TableName = "TableJSON";
String SourceFile = @ "C:  yourpath  source.json";

en utilisant (SqlConnection ConnSQLServer = new SqlConnection (ConnStr_SQLServer))

// Lire les données JSON dans DataTable
String json = File.ReadAllText (SourceFile);
DataTable dt = (DataTable) JsonConvert.DeserializeObject (json, (typeof (DataTable)));

// Ouvrir la connexion à la base de données
ConnSQLServer.Open ();

// Nettoyer la table cible
SqlCommand CmdSQLServer = nouveau SqlCommand ("Truncate Table" + TableName, ConnSQLServer)

CommandType = CommandType.Text
;
CmdSQLServer.ExecuteNonQuery ();


// Configurez l'objet Bulk Copy.
// Notez que les positions des colonnes dans la source
// le tableau de données correspond aux positions des colonnes dans
// la table de destination donc pas besoin de
// mappe les colonnes.
en utilisant (SqlBulkCopy bulkCopy = new SqlBulkCopy (ConnSQLServer))

bulkCopy.DestinationTableName = TableName;

essayer

// Ecrit de la source vers la destination.
bulkCopy.WriteToServer (dt);

catch (Exception ex)

Console.WriteLine (ex.Message);

enfin

dt.Clear ();



MessageBox.Show (DateTime.Now.ToString ("aaaa-MM-jj h: mm tt") + "| Données importées avec succès!", "Processus terminé", MessageBoxButtons.OK);

Vous devriez pouvoir voir que le script est exécuté avec succès.



Ensuite, vous pouvez examiner les données qui ont été importées dans le
table: TableJSON dans SQL Server.

8) Utiliser PHP

Nous pourrions utiliser
Fonction json_decode pour décoder facilement les données JSON.

    "$ TargetDb", "UID" => "$ UserName", "PWD" => "$ Password", "CharacterSet" => "UTF-8");
$ conn = sqlsrv_connect ($ TargetServer, $ connectionInfo);
$ colcnt = 0;


// Effacer les données
$ sql = "Tronquer la table $ TableName;";
$ stmt = sqlsrv_prepare ($ conn, $ sql);
if (sqlsrv_execute ($ stmt) === false) 
die (print_r (sqlsrv_errors (), true));



// Charger le JSON
$ json = file_get_contents ($ SourceFile);
$ json_obj = json_decode ($ json, true);


if (count ($ json_obj)> 0)  Données chargées avec succès";
 autre 
date d'écho ('Y-m-d H: i: s'). "


//Fermer la connexion
sqlsrv_close ($ conn);

Vous devriez pouvoir voir que le script est exécuté avec succès.

Ensuite, vous pouvez examiner les données qui ont été importées dans le
table: TableJSON dans SQL Server.

9) Utilisation de Java

Encore une fois, j'ai l'occasion de retoucher mes compétences en programmation en Java en implémentant les codes ci-dessous.

Pour autant que je sache, il n'y a pas de méthode native en Java pour analyser les données JSON et il y a beaucoup de bibliothèques supplémentaires disponibles pour accomplir cette tâche, telles que:

Dans ce tutoriel, je voudrais donner
Jsoniter un essai.

Il nous faudrait donc installer les bibliothèques ci-dessous:

Après cela, nous pouvons préparer et exécuter les codes, comme indiqué ci-dessous:

package javaapplication1;


import com.jsoniter.JsonIterator;
import com.jsoniter.any. *;


import java.io. *;
import java.sql. *;
import java.text. *;
import java.util. *;


classe publique ImportJSON {


public static void main (String[] args) {
Connexion conn = null;
essayez {


// Réglages
String TargetName = "ServerName";
String SchemaName = "DatabaseName";
String TableName = "TableJSON";
String UserName = "UserID";
Mot de passe de chaîne = "Mot de passe";
String url = "jdbc: sqlserver: //" + TargetName + "; databaseName =" + SchemaName + "; user =" + UserName + "; password =" + Password + ";";
String SourceFile = "C: \ yourpath \ source.json";


// Se connecter à la base de données cible
conn = DriverManager.getConnection (url, nom d'utilisateur, mot de passe);
conn.setAutoCommit (false);


// Nettoyer la table cible
Instruction stmt = conn.createStatement ();
String sql = "Truncate Table" + TableName;
stmt.executeUpdate (sql);
conn.commit ();

// Préparez l'instruction Insert SQL
sql = "INSERT INTO" + TableName + "VALUES (?,?,?,?,?,?,?,?,?,?,?,?);";
PreparedStatement prepstmt = conn.prepareStatement (sql);

// Lire JSON et insérer son contenu dans la table cible
String json = "";
essayez 
StringBuilder stringBuilder;
try (lecteur BufferedReader = nouveau BufferedReader (nouveau FileReader (SourceFile))) 
stringBuilder = new StringBuilder ();
Ligne de chaîne = null;
String ls = System.getProperty ("line.separator");
while ((line = reader.readLine ())! = null) 
stringBuilder.append (ligne);
stringBuilder.append (ls);

// Supprimer le dernier nouveau séparateur de ligne
stringBuilder.deleteCharAt (stringBuilder.length () - 1);

json = stringBuilder.toString ();
 catch (IOException ex) 
ex.printStackTrace (System.out);


Tous les enregistrements = JsonIterator.deserialize (json);
pour (Tout enregistrement: enregistrements) {

// Définit les paramètres sur NULL par défaut
pour (int i = 1; i <= 12; i ++) 
prepstmt.setNull (i, Types.NULL);


Any.EntryIterator entryIterator = record.entries ();
while (entryIterator.next ()) 
switch (entryIterator.key ()) 
cas "Dates":
if (entryIterator.value ()! = null) 
SimpleDateFormat inputFormat = new SimpleDateFormat ("aaaa-MM-jj'T'HH: mm: ss");
java.util.Date t;
essayez 
t = inputFormat.parse (entryIterator.value (). toString ());
prepstmt.setObject (1, t);
 catch (ParseException ex) 
ex.printStackTrace (System.out);


Pause;
cas "Type":
if (entryIterator.value ()! = null) 
prepstmt.setObject (2, entryIterator.value (). toString ());

Pause;
cas "Code":
if (entryIterator.value ()! = null) 
prepstmt.setObject (3, entryIterator.value (). toString ());

Pause;
cas "Prix":
if (entryIterator.value ()! = null) 
prepstmt.setObject (4, entryIterator.value (). toBigDecimal ());

Pause;
cas "Unité":
if (entryIterator.value ()! = null) 
prepstmt.setObject (5, entryIterator.value (). toBigDecimal ());

Pause;
cas "Sous-total":
if (entryIterator.value ()! = null) 
prepstmt.setObject (6, entryIterator.value (). toBigDecimal ());

Pause;
cas "Brokeage Rate":
if (entryIterator.value ()! = null) 
prepstmt.setObject (7, entryIterator.value (). toBigDecimal ());

Pause;
cas "Taxe":
if (entryIterator.value ()! = null) 
prepstmt.setObject (8, entryIterator.value (). toBigDecimal ());

Pause;
cas "Stamp Duty":
if (entryIterator.value ()! = null) 
prepstmt.setObject (9, entryIterator.value (). toBigDecimal ());

Pause;
cas "Frais de compensation":
if (entryIterator.value ()! = null) 
prepstmt.setObject (10, entryIterator.value (). toBigDecimal ());

Pause;
cas "Montant":
if (entryIterator.value ()! = null) 
prepstmt.setObject (11, entryIterator.value (). toBigDecimal ());

Pause;
cas "Coût Svc":
if (entryIterator.value ()! = null) 
prepstmt.setObject (12, entryIterator.value (). toBigDecimal ());

Pause;


prepstmt.addBatch ();
}

// Insérer dans la table cible
prepstmt.executeBatch ();
conn.commit ();

Modèle de chaîne = "jj / MM / aaaa h: mm: ss a z";
SimpleDateFormat simpleDateFormat = new SimpleDateFormat (pattern, new Locale ("en", "US"));
String date = simpleDateFormat.format (new java.util.Date ());


System.out.println (date + "| Données chargées avec succès");
//} catch (SQLException | IOException ex) 
 catch (SQLException ex) 
ex.printStackTrace (System.out);
 enfin 
essayez 
if (conn! = null &&! conn.isClosed ()) 
conn.close ();

 catch (SQLException ex) 
ex.printStackTrace (System.out);


}
}

Vous devriez pouvoir voir que le script est exécuté avec succès.



Ensuite, vous pouvez examiner les données qui ont été importées dans le
table: Sheet1 $ dans SQL Server.


10) Utiliser Golang

Il existe différentes façons de charger JSON dans Golang mais dans cet article, nous allons utiliser la bibliothèque par défaut.

Les codes d'exécution sont présentés comme suit:

paquet principal


importer (
"le contexte"
"base de données / sql"
"encodage / json"
"fmt"
"io / ioutil"
"Journal"
"réfléchir"
"cordes"
"temps"


_ "github.com/denisenkom/go-mssqldb"
)


// NullInt64 est un alias pour le type de données sql.NullInt64
type NullInt64 sql.NullInt64


// Scan implémente l'interface Scanner pour NullInt64
func (ni * NullInt64) Erreur de scan (interface de valeur ) 
var i sql.NullInt64
si err: = i.Scan (valeur); err! = nil 
retour err



// si nul, alors validez false
si reflect.TypeOf (value) == nil 
* ni = NullInt64 i.Int64, false
 autre 
* ni = NullInt64 i.Int64, true

retour nul



// NullBool est un alias pour le type de données sql.NullBool
type NullBool sql.NullBool


// Scan implémente l'interface Scanner pour NullBool
func (nb * NullBool) Scan (interface de valeur ) erreur 
var b sql.NullBool
si err: = b.Scan (valeur); err! = nil 
retour err



// si nul, alors validez false
si reflect.TypeOf (value) == nil 
* nb = NullBool b.Bool, false
 autre 
* nb = NullBool b.Bool, true



retour nul



// NullFloat64 est un alias pour le type de données sql.NullFloat64
type NullFloat64 sql.NullFloat64


// Scan implémente l'interface Scanner pour NullFloat64
func (nf * NullFloat64) Erreur de scan (interface de valeur ) 
var f sql.NullFloat64
si err: = f.Scan (valeur); err! = nil 
retour err



// si nul, alors validez false
si reflect.TypeOf (value) == nil 
* nf = NullFloat64 f.Float64, false
 autre 
* nf = NullFloat64 f.Float64, true



retour nul



// NullString est un alias pour le type de données sql.NullString
type NullString sql.NullString


// Scan implémente l'interface Scanner pour NullString
func (ns * NullString) Scan (interface de valeur ) erreur 
var s sql.NullString
si err: = s.Scan (valeur); err! = nil 
retour err



// si nul, alors validez false
si reflect.TypeOf (value) == nil 
* ns = NullString s.String, false
 autre 
* ns = NullString s.String, true



retour nul



// NullTime est un alias pour le type de données sql.NullTime
type NullTime sql.NullTime


// Scan implémente l'interface Scanner pour NullTime
func (nt * NullTime) Scan (valeur interface ) erreur 
var t sql.NullTime
si err: = t.Scan (valeur); err! = nil 
retour err



// si nul, alors validez false
si reflect.TypeOf (value) == nil 
* nt = NullTime t.Time, false
 autre 
* nt = NullTime t.Time, true



retour nul



// JSONDate: type de date personnalisé
tapez JSONDate time.


// UnmarshalJSON: implémentation de l'interface Marshaler et Unmarshalere
func (j * JSONDate) UnmarshalJSON (b []octet) erreur 
s: = strings.Trim (string (b), "" ")
t, err: = time.Parse ("2006-01-02T00: 00: 00", s)
si err! = nil 
retour err

* j = JSONDate (t)
retour nul



// MarshalJSON: implémentation de l'interface Marshaler et Unmarshalere
func (j JSONDate) MarshalJSON () ([]octet, erreur) 
retour json.Marshal (j)



// Format: Peut-être une fonction Format pour imprimer votre date
func (j JSONDate) Format (chaîne de s) chaîne 
t: = time.Time (j)
retourner t.Format (s)



// FormatNow: Format Date Heure
func FormatNow () chaîne 
const layout = "2 janvier 2006 15:04"
now: = time.Now (). Format (layout)
revenir maintenant



// Réglages
const (
server = "ServerName"
port = 1433
database = "DatabaseName"
user = "UserID"
password = "Mot de passe"
sourcepath = "C: \ yourpath \ source.json"
tablename = "TableJSON"
)


var (
db * sql.DB
erreur d'erreur
)


// TargetTable: Structure de la table cible
type TargetTable struct 
chaîne colName
chaîne dataType
chaMaxLen NullInt64
numericPrecision NullInt64
numericScale NullInt64



// DataList: Structure de la liste de données
type DataList struct 
DataList []Données `json:" datalist "`



// Données: structure des données
type Structure de données 
Dates JSONDate `json:" Dates "`
Interface de type  `json:" Type "`
Interface de code  `json:" Code "`
Interface de prix  `json:" Price "`
Interface de l'unité  `json:" Unit "`
Interface de sous-total  `json:" Subtotal "`
Interface BrokeageRate  `json:" Taux de brokeage "`
Interface fiscale  `json:" Taxe "`
Interface StampDuty  `json:" Stamp Duty "`
Interface ClearingFee  `json:" Clearing Fee "`
Interface de montant  `json:" Montant "`
Interface SvcCost  `json:" Coût Svc "`



func main () 


// Créer une chaîne de connexion
connString: = fmt.Sprintf ("serveur =% s; id utilisateur =% s; mot de passe =% s; port =% d; base de données =% s;", serveur, utilisateur, mot de passe, port, base de données)


// Créer un pool de connexions
db, err = sql.Open ("sqlserver", connString)
si err! = nil 
log.Fatal (err)



// Nettoyer la table cible
sqlstr: = ""
sqlstr = fmt.Sprintf ("Truncate Table% s;", tablename)
si _, err = db.Exec (sqlstr); err! = nil 
log.Fatal (err)



// Lire les champs de la table cible
sqlstr = fmt.Sprintf ("SELECT COLUMN_NAME, DATA_TYPE, CHARACTER_MAXIMUM_LENGTH, NUMERIC_PRECISION, NUMERIC_SCALE FROM INFORMATION_SCHEMA.COLUMN WHERE TABLE_NAME = N '% s ORDER BY ORDINAL_POSITION;", tablename)
trows, err: = db.Query (sqlstr)
si err! = nil 
log.Fatal (err)

reporter des trows.Fermer ()
enregistrements var []TargetTable


pour trows.Next () 
var record TargetTable


err: = trows.Scan (& record.colName, & record.dataType, & record.chaMaxLen, & record.numericPrecision, & record.numericScale)
si err! = nil 
log.Fatal (err)

enregistrements = ajouter (enregistrements, enregistrement)



// Lire le contenu du fichier JSON
f, err: = ioutil.ReadFile (chemin source)
si err! = nil 
log.Fatal (err)



var datalist []Les données
err = json.Unmarshal (f, & datalist)
si err! = nil 
log.Fatal (err)



var sqlcmdstr = "insérer dans% s ([%s], [%s], [%s], [%s], [%s], [%s], [%s], [%s], [%s], [%s], [%s], [%s]) valeurs (@pDates, @pType, @pCode, @pPrice, @pUnit, @pSubTotal, @pBrokeageRate, @pTax, @pStampDuty, @pClearingFee, @pAmount, @pSvcCost); "
sqlstr = fmt.Sprintf (sqlcmdstr, nom de table, enregistrements[0].colName, enregistrements[1].colName, enregistrements[2].colName, enregistrements[3].colName, enregistrements[4].colName, enregistrements[5].colName, enregistrements[6].colName, enregistrements[7].colName, enregistrements[8].colName, enregistrements[9].colName, enregistrements[10].colName, enregistrements[11].colName)
stmt, err: = db.Prepare (sqlstr)


si err! = nil 
log.Fatal (err)



// Ferme le pool de connexions à la base de données après l'exécution du programme
différer db.Close ()


ctx: = context.Background ()


pour i: = 0; i <len (datalist); i ++ 
// Fermez l'instruction
différer stmt.Close ()


var pDates = sql.Named ("pDates", liste de données[i].Dates.Format ("2 janvier 2006"))
var pType = sql.Named ("pType", liste de données[i].Type)
var pCode = sql.Named ("pCode", liste de données[i].Code)
var pPrice = sql.Named ("pPrice", liste de données[i].Prix)
var pUnit = sql.Named ("pUnit", liste de données[i].Unité)
var pSubTotal = sql.Named ("pSubTotal", liste de données[i].Total)
var pBrokeageRate = sql.Named ("pBrokeageRate", liste de données[i].BrokeageRate)
var pTax = sql.Named ("pTax", liste de données[i].Impôt)
var pStampDuty = sql.Named ("pStampDuty", liste de données[i].StampDuty)
var pClearingFee = sql.Named ("pClearingFee", liste de données[i].ClearingFee)
var pAmount = sql.Named ("pAmount", liste de données[i].Montant)
var pSvcCost = sql.Named ("pSvcCost", liste de données[i].SvcCost)


si _, err: = stmt.ExecContext (ctx, pDates, pType, pCode, pPrice, pUnit, pSubTotal, pBrokeageRate, pTax, pStampDuty, pClearingFee, pAmount, pSvcCost); err! = nil 
log.Fatal (err)




fmt.Println (FormatNow () + "

Vous devriez pouvoir voir que le script est exécuté avec succès.



Ensuite, vous pouvez examiner les données qui ont été importées dans le
table: TableJSON dans SQL Server.

Commentaires

Laisser un commentaire

Votre commentaire sera révisé par les administrateurs si besoin.