IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Python Discussion :

Problème-de- chargement BAse MarianDB


Sujet :

Python

  1. #1
    Membre habitué Avatar de dedalios
    Homme Profil pro
    concepteur d'application
    Inscrit en
    février 2008
    Messages
    423
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Indre et Loire (Centre)

    Informations professionnelles :
    Activité : concepteur d'application
    Secteur : Santé

    Informations forums :
    Inscription : février 2008
    Messages : 423
    Points : 135
    Points
    135
    Par défaut Problème-de- chargement BAse MarianDB
    bonjour

    Dans ce code je lis une base MSACCESS et je transfert les données dans 3 bases 2 SQLLITE et une MariamDB.
    pour les base sqllite tous va bien.
    mais problème avec la phase d'insertion mariamdb

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
    179
    180
    181
    182
    183
    184
    185
    186
    187
    188
    189
    190
    191
    192
    193
    194
    195
    196
    197
    198
    199
    200
    201
    202
    203
    204
    205
    206
    207
    208
    209
    210
    211
    212
    213
    214
    215
    216
    217
    218
    219
    220
    221
    222
    223
    224
    225
    226
    227
    228
    229
    230
    231
    232
    233
    234
    235
    236
    237
    238
    239
    240
    241
    242
    243
    244
    245
    246
    247
    248
    249
    250
    251
    252
    253
    254
    255
    256
    257
    258
    259
    260
    261
    262
    263
    264
    265
    266
    267
    268
    269
    270
    271
    272
    273
    274
    275
    276
    277
    278
    279
    280
    281
    282
    283
    284
    285
    286
    287
    288
    289
    290
    291
    292
    293
    294
    295
    296
    297
    298
    299
    300
    301
    302
    303
    304
    305
    306
    307
    308
    309
    310
    311
    312
    313
    314
    315
    316
    317
    318
    319
    320
    321
    322
    323
    324
    325
    # coding: utf-8  
    
    # creattion des tables
    
    import mariadb
    import sqlite3
    import pyodbc 
    from dataclasses import InitVar, dataclass, fields
    
    
    
    @dataclass
    class animal :
        Nom_Animal : str = None
        Point_de_Vie : int = 0
        SDC : int = 0
        MDC : int = -1
        Touche : int = 0
        Parade : int = 0
        Esquive : int = 0
        Vitesse : int = 0
        Attaque1 : str = None
        Degat_attaque1 : str = None
        Attaque2 : str = None
        Degat_attaque2 : str = None
        Attaque3 : str = None
        Degat_attaque3 : str = None 
        Abilite : str = None
        APR : int = 0
        Categorie : str = None
        Description : str = None
        
            
        def charge_table_acess(self , valeur):
            self.Nom_Animal = valeur[0]
            self.Point_de_Vie =  int( valeur[1])
            self.SDC = int( valeur[2])
            self.MDC =  int( valeur[3])
            self.Touche = int(  valeur[4])
            self.Parade = int( valeur[5])
            self.Esquive = int( valeur[6])
            self.Vitesse = int( valeur[7])
            self.Attaque1 = valeur[8]
            self.Degat_attaque1 =  valeur[9]
            self.Attaque2 = valeur[10]
            self.Degat_attaque2 =  valeur[11]
            self.Attaque3 = valeur[12]
            self.Degat_attaque3 =  valeur[13]
            self.Abilite = valeur[14]
            self.APR =  int( valeur[15])
            self.Categorie = valeur[16]
    
    
        def imprimer(self):
            return f"""Donnée de la table Animal : 
    Nom_Animal : { self.Nom_Animal}  
    Point_de_Vie : { self.Point_de_Vie} 
    SDC : { self.SDC}
    MDC : { self.MDC}
    Touche : { self.Touche}
    Parade : { self.Parade}
    Esquive : { self.Esquive}
    Vitesse : { self.Vitesse}
    Attaque1 : { self.Attaque1}
    Degat_attaque1 : { self.Degat_attaque1}
    Attaque2 : { self.Attaque2}
    Degat_attaque2 : { self.Degat_attaque2}
    Attaque3 : { self.Attaque3} '/n'
    Degat_attaque3 : { self.Degat_attaque3}
    Abilite : { self.Abilite}
    APR : { self.APR}
    Categorie : { self.Categorie}
    Description : { self.Description}
                   """ 
                   
        def insertion_db_mariam(self):
            sql_animale_MDB_1 =f""" INSERT INTO Rifter.Animal
                             (Nom_Animal, Point_de_Vie, SDC, MDC, Touche, Parade, Esquive, Vitesse, 
                             Attaque1,Degat_attaque1, Attaque2, Degat_attaque2, Attaque3, Degat_attaque3,
                            Abilite, APR, Categorie)
                        VALUES('{self.Nom_Animal}' , '{self.Point_de_Vie}' , '{self.SDC}', '{self.MDC}' , '{self.Touche}' ,'{self.Parade}' ,
                            '{self.Esquive}' , '{self.Vitesse}' ,'{self.Attaque1}' ,'{self.Degat_attaque1}', '{self.Attaque2}' ,
                            '{self.Degat_attaque2}' , '{self.Attaque3}' , '{self.Degat_attaque3}' ,'{self.Abilite}' ,'{self.APR}' ,'{self.Categorie}'
                             );"""
            print(sql_animale_MDB_1)           
                   
            
    def Tb_animal():
        
        un_animal = animal()
        
    
    
        drop_Table_animale = """ DROP TABLE if exists  Animal; """ 
    
        creer_Table_animale_MDB ="""
        CREATE TABLE  if not exists `Animal` (
          `id_Animal` int(11) NOT NULL AUTO_INCREMENT,
          `Nom_Animal` varchar(255) DEFAULT NULL,
          `Point_de_Vie` int(11) DEFAULT NULL,
          `SDC` int(11) DEFAULT NULL,
          `MDC` int(11) DEFAULT -1,
          `Touche` int(11) DEFAULT NULL,
          `Parade` int(11) DEFAULT NULL,
          `Esquive` int(11) DEFAULT NULL,
          `Vitesse` int(11) DEFAULT NULL,
          `Attaque1` varchar(255) DEFAULT NULL,
          `Degat_attaque1` varchar(255) DEFAULT NULL,
          `Attaque2` varchar(255) DEFAULT NULL,
          `Degat_attaque2` varchar(255) DEFAULT NULL,
          `Attaque3` varchar(255) DEFAULT NULL,
          `Degat_attaque3` varchar(255) DEFAULT NULL,
          `Abilite` blob DEFAULT NULL,
          `APR` int(11) DEFAULT NULL,
          `Categorie` varchar(255) DEFAULT NULL,
          `Description` blob DEFAULT NULL,
          PRIMARY KEY (`id_Animal`),
          UNIQUE KEY `Nom_Animal_indx` (`Nom_Animal`)
        ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
        """
         
        
        creer_Table_animale_SQLITE ="""
        CREATE TABLE if not exists  Animal(
            id_Animal INTEGER PRIMARY KEY AUTOINCREMENT,
            Nom_Animal VARCHAR(255) NOT NULL UNIQUE,
            Point_de_Vie INTEGER,
            SDC INTEGER,
            MDC INTEGER DEFAULT -1,
            Touche INTEGER,
            Parade INTEGER,
            Esquive INTEGER,
            Vitesse INTEGER,
            Attaque1 VARCHAR(255),
            Degat_attaque1 VARCHAR(255),
            Attaque2 VARCHAR(255),
            Degat_attaque2  VARCHAR(255),
            Attaque3  VARCHAR(255),
            Degat_attaque3  VARCHAR(255),
            Abilite  VARCHAR(16777216),
            APR INTEGER,
            Categorie VARCHAR(255),
            Description Blob
            ); 
         """ 
         
        
        sql_animale_SQLITE =""" INSERT INTO Animal
                            (Nom_Animal, Point_de_Vie, SDC, MDC, Touche, Parade, Esquive, Vitesse, 
                            Attaque1, Degat_attaque1, Attaque2, Degat_attaque2, Attaque3, Degat_attaque3,
                             Abilite, APR, Categorie)
                        VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?);"""
           
        
        sql_animale_MDB =""" INSERT INTO Rifter.Animal
                             (Nom_Animal, Point_de_Vie, SDC, MDC, Touche, Parade, Esquive, Vitesse, 
                             Attaque1,Degat_attaque1, Attaque2, Degat_attaque2, Attaque3, Degat_attaque3,
                              Abilite, APR, Categorie)
                        VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?);"""
        
        sql_animale_MDB_1 =f""" INSERT INTO Rifter.Animal
                             (Nom_Animal, Point_de_Vie, SDC, MDC, Touche, Parade, Esquive, Vitesse, 
                             Attaque1,Degat_attaque1, Attaque2, Degat_attaque2, Attaque3, Degat_attaque3,
                              Abilite, APR, Categorie)
                        VALUES('{un_animal.Nom_Animal}' , 
                        '{un_animal.Point_de_Vie}' ,
                        '{un_animal.SDC}', 
                        '{un_animal.MDC}' ,
                        '{un_animal.Touche}' ,
                        '{un_animal.Parade}' ,
                        '{un_animal.Esquive}' ,
                        '{un_animal.Vitesse}' ,
                        '{un_animal.Attaque1}' ,
                        '{un_animal.Degat_attaque1}', 
                        '{un_animal.Attaque2}' ,
                        '{un_animal.Degat_attaque2}' ,
                        '{un_animal.Attaque3}' ,
                        '{un_animal.Degat_attaque3}' ,
                        '{un_animal.Abilite}' ,
                        {un_animal.APR}' ,
                        '{un_animal.Categorie}' );"""
        
         
        # 17 champ 
        sql_animale_Base_Access = """ 
                                    SELECT `AnimalName`, HP, SDC, MDC, `Strike`, 
                                    `Parry`, `Dodge`, `Spd`, `Attack1`, `Attack1Damage`, 
                                    `Attack2`, `Attack2Damage`, `Attack3`,
                                    `Attack3Damage`, `Ability`, APR, `Category` FROM `Animals`;"""
                                    
        # lire la table  animal
        
        
        # Vérification des tables
        try:
            
            
            cur_Base_SQlite.execute(drop_Table_animale)
            connection_Base_SQlite.commit()
            cur_Base_SQlite.execute(creer_Table_animale_SQLITE)
            connection_Base_SQlite.commit()
        except  Exception as erreur:
            print("Erreur -SQLLITE base clone:" , erreur)
            connection_Base_SQlite.rollback()       
        
        try:
            #Base  Base_SQlite_fr
            cur_Base_SQlite_fr.execute(drop_Table_animale)
            connection_Basefr.commit()
            
            cur_Base_SQlite_fr.execute(creer_Table_animale_SQLITE)
            connection_Basefr.commit()
            
        except  Exception as erreur:
            print("Erreur -SQLLITE base française:" , erreur)
            connection_Basefr.rollback()     
        
        try:
            #Base  mariadb    
            cur_mariad.execute(drop_Table_animale)
            cur_mariad.execute(creer_Table_animale_MDB)
            
        except mariadb.Error as e:
            print("Creation de la table Animale ")
            print(f"Erreur de connexion avec MariaDB Platform: {e}")   
            connection_mariadb.rollback()
     
        cur_BaseOrigine.execute(sql_animale_Base_Access )
                 
        result = cur_BaseOrigine.fetchall()  # fetchall() : récupère toutes les lignes qui correspondent aux paramètres définis.
        for valeur in result:
            print("Charger animal")
            
            un_animal.charge_table_acess(valeur)
            #print(un_animal.imprimer())
            
            try:
                #Base  Base_SQlite
                cur_Base_SQlite.execute(sql_animale_SQLITE , valeur)
                connection_Base_SQlite.commit()
            except  Exception as erreur:
                print("Erreur -SQLLITE:" , erreur)
                connection_Base_SQlite.rollback()        
            try:
                #Base  Base_SQlite_fr
                cur_Base_SQlite_fr.execute(sql_animale_SQLITE , valeur)
                connection_Basefr.commit()
            except  Exception as erreur:
                print("Erreur -SQLLITE:" , erreur)
                connection_Basefr.rollback()        
             
            try:
                #Base  mariadb    
                #print(un_animal )
                #print(un_animal.insertion_db_mariam())
                cur_mariad.execute(sql_animale_MDB_1 )
    
                print(f"{cur_mariad.rowcount} details inserted")
    
            except mariadb.Error as e:
                print(f"Erreur d'insertion à la table Animale sur MariaDB  pour : {e}")   
                print(f"donnee : {valeur}")
                connection_mariadb.rollback()
     
      
    if __name__ == '__main__':
     
        
        try: 
                
            BaseOrigine = (
                r"DRIVER={Microsoft Access Driver (*.mdb, *.accdb)};"
                r"DBQ=E:\eclipse-workspace\RIFT\Base\rcg.mdb;")
            
            BaseSqllite_bg ='RCG-V2.sqllite'
            BaseSqllite_fr ='rcg-fr.sqllite'
    
            connection_BaseOrigine = pyodbc.connect(BaseOrigine)  # Connexion a la base Access
            cur_BaseOrigine = connection_BaseOrigine.cursor()     # Curseur  a la base Access        
            #
            try: 
                # ouverture Bese Sqllite anglise
                connection_Base_SQlite = sqlite3.connect(BaseSqllite_bg)
                cur_Base_SQlite = connection_Base_SQlite.cursor()
                print("Ouverture de la base de données: ",BaseSqllite_bg )
                
                try:
                    # ouverture Bese Sqllite française
                    connection_Basefr = sqlite3.connect(BaseSqllite_fr)
                    cur_Base_SQlite_fr = connection_Basefr.cursor()
                    print("Ouverture de la base de données: ",BaseSqllite_fr )
                    
                    try: 
                        # ouverture Bese mariadb
                        connection_mariadb = mariadb.connect(
                            user="toto",
                            password="mot-de-Passs",
                            host="machine",
                            port=3306,
                            database="tpz")
                        print("Ouverture de la base de mariadb")
                        
                        cur_mariad = connection_mariadb.cursor()
    
                        Tb_animal()
                        
                    except mariadb.Error as e:
                        print(f"Erreur de connection avec MariaDB Platform: {e}")  
                    
                except  Exception as erreur:
                    print("Erreur:" , erreur)
                
            except  Exception as erreur:
                print("Erreur:" , erreur)
                 
        except  Exception as erreur:
            print("Erreur:" , erreur)
            
            
        finally:
            connection_BaseOrigine.close()
            connection_mariadb.close()
            connection_Basefr.close()
            connection_Base_SQlite.close()

    voici ce que j'obtiens

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    Ouverture de la base de données:  RCG-V2.sqllite
    Ouverture de la base de données:  rcg-fr.sqllite
    Ouverture de la base de mariadb
    Charger animal
    Erreur d'insertion à la table Animale sur MariaDB  pour : You have an error in your SQL syntax; check the manual that corresponds to your MariaDB server version for the right syntax to use near '' ,
                        'None' )' at line 20
    donnee : ('Gorilla', 80, 80, -1, 3, 3, 1, 12, 'Bite', '2D4 S.D.', 'Slashing and Tearing hands', '2D6 + 6 S.D.', None, None, 'Nightvision 15 feet (4.6 m), climb 40%, and prowl 40%.', 4, 'Medium')
    Charger animal 
    Erreur d'insertion à la table Animale sur MariaDB  pour : You have an error in your SQL syntax; check the manual that corresponds to your MariaDB server version for the right syntax to use near '' ,
                        'None' )' at line 20
    donnee : ('Badger', 30, 10, -1, 1, 1, 3, 12, 'Bite or Slashing claws', '1D6 + 2 S.D.', None, None, None, None, 'Nightvision 50 Feet (4.6 m), climb 60%, leap up to 10 feet (3 m). Dig 5 feet (1.5 m) per minute, track by smell 65%.', 3, 'Small')
     
    etc
    Je ne parviens pas a voir ce qui provoque ce problème d'insertion.


    J'ai aussi testé ce code
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
    179
    180
    181
    182
    183
    184
    185
    186
    187
    188
    189
    190
    191
    192
    193
    194
    195
    196
    197
    198
    199
    200
    201
    202
    203
    204
    205
    206
    207
    208
    209
    210
    211
    212
    213
    214
    215
    216
    217
    218
    219
    220
    221
    222
    223
    224
    225
    226
    227
    228
    229
    230
    231
    232
    233
    234
    235
    236
    237
    238
    239
    240
    241
    242
    243
    244
    245
    246
    247
    248
    249
    250
    251
    252
    253
    254
    255
    256
    257
    258
    259
    260
    261
    262
    263
    264
    265
    266
    267
    268
    269
    270
    271
    272
    273
    274
    275
    276
    277
    278
    279
    280
    281
    282
    283
    284
    285
    286
    287
    288
    289
    290
    291
    292
    293
    294
    295
    296
    297
    298
    299
    300
    301
    302
    303
    304
    305
    306
    307
    308
    309
    310
    311
    312
    313
    314
    315
    316
    317
    318
    319
    320
    321
    322
    323
    324
    325
    # coding: utf-8  
    
    # creattion des tables
    
    import mariadb
    import sqlite3
    import pyodbc 
    from dataclasses import InitVar, dataclass, fields
    
    
    
    @dataclass
    class animal :
        Nom_Animal : str = None
        Point_de_Vie : int = 0
        SDC : int = 0
        MDC : int = -1
        Touche : int = 0
        Parade : int = 0
        Esquive : int = 0
        Vitesse : int = 0
        Attaque1 : str = None
        Degat_attaque1 : str = None
        Attaque2 : str = None
        Degat_attaque2 : str = None
        Attaque3 : str = None
        Degat_attaque3 : str = None 
        Abilite : str = None
        APR : int = 0
        Categorie : str = None
        Description : str = None
        
            
        def charge_table_acess(self , valeur):
            self.Nom_Animal = valeur[0]
            self.Point_de_Vie =  int( valeur[1])
            self.SDC = int( valeur[2])
            self.MDC =  int( valeur[3])
            self.Touche = int(  valeur[4])
            self.Parade = int( valeur[5])
            self.Esquive = int( valeur[6])
            self.Vitesse = int( valeur[7])
            self.Attaque1 = valeur[8]
            self.Degat_attaque1 =  valeur[9]
            self.Attaque2 = valeur[10]
            self.Degat_attaque2 =  valeur[11]
            self.Attaque3 = valeur[12]
            self.Degat_attaque3 =  valeur[13]
            self.Abilite = valeur[14]
            self.APR =  int( valeur[15])
            self.Categorie = valeur[16]
    
    
        def imprimer(self):
            return f"""Donnée de la table Animal : 
    Nom_Animal : { self.Nom_Animal}  
    Point_de_Vie : { self.Point_de_Vie} 
    SDC : { self.SDC}
    MDC : { self.MDC}
    Touche : { self.Touche}
    Parade : { self.Parade}
    Esquive : { self.Esquive}
    Vitesse : { self.Vitesse}
    Attaque1 : { self.Attaque1}
    Degat_attaque1 : { self.Degat_attaque1}
    Attaque2 : { self.Attaque2}
    Degat_attaque2 : { self.Degat_attaque2}
    Attaque3 : { self.Attaque3} '/n'
    Degat_attaque3 : { self.Degat_attaque3}
    Abilite : { self.Abilite}
    APR : { self.APR}
    Categorie : { self.Categorie}
    Description : { self.Description}
                   """ 
                   
        def insertion_db_mariam(self):
            sql_animale_MDB_1 =f""" INSERT INTO Rifter.Animal
                             (Nom_Animal, Point_de_Vie, SDC, MDC, Touche, Parade, Esquive, Vitesse, 
                             Attaque1,Degat_attaque1, Attaque2, Degat_attaque2, Attaque3, Degat_attaque3,
                            Abilite, APR, Categorie)
                        VALUES('{self.Nom_Animal}' , '{self.Point_de_Vie}' , '{self.SDC}', '{self.MDC}' , '{self.Touche}' ,'{self.Parade}' ,
                            '{self.Esquive}' , '{self.Vitesse}' ,'{self.Attaque1}' ,'{self.Degat_attaque1}', '{self.Attaque2}' ,
                            '{self.Degat_attaque2}' , '{self.Attaque3}' , '{self.Degat_attaque3}' ,'{self.Abilite}' ,'{self.APR}' ,'{self.Categorie}'
                             );"""
            print(sql_animale_MDB_1)           
                   
            
    def Tb_animal():
        
        un_animal = animal()
        
    
    
        drop_Table_animale = """ DROP TABLE if exists  Animal; """ 
    
        creer_Table_animale_MDB ="""
        CREATE TABLE  if not exists `Animal` (
          `id_Animal` int(11) NOT NULL AUTO_INCREMENT,
          `Nom_Animal` varchar(255) DEFAULT NULL,
          `Point_de_Vie` int(11) DEFAULT NULL,
          `SDC` int(11) DEFAULT NULL,
          `MDC` int(11) DEFAULT -1,
          `Touche` int(11) DEFAULT NULL,
          `Parade` int(11) DEFAULT NULL,
          `Esquive` int(11) DEFAULT NULL,
          `Vitesse` int(11) DEFAULT NULL,
          `Attaque1` varchar(255) DEFAULT NULL,
          `Degat_attaque1` varchar(255) DEFAULT NULL,
          `Attaque2` varchar(255) DEFAULT NULL,
          `Degat_attaque2` varchar(255) DEFAULT NULL,
          `Attaque3` varchar(255) DEFAULT NULL,
          `Degat_attaque3` varchar(255) DEFAULT NULL,
          `Abilite` blob DEFAULT NULL,
          `APR` int(11) DEFAULT NULL,
          `Categorie` varchar(255) DEFAULT NULL,
          `Description` blob DEFAULT NULL,
          PRIMARY KEY (`id_Animal`),
          UNIQUE KEY `Nom_Animal_indx` (`Nom_Animal`)
        ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
        """
         
        
        creer_Table_animale_SQLITE ="""
        CREATE TABLE if not exists  Animal(
            id_Animal INTEGER PRIMARY KEY AUTOINCREMENT,
            Nom_Animal VARCHAR(255) NOT NULL UNIQUE,
            Point_de_Vie INTEGER,
            SDC INTEGER,
            MDC INTEGER DEFAULT -1,
            Touche INTEGER,
            Parade INTEGER,
            Esquive INTEGER,
            Vitesse INTEGER,
            Attaque1 VARCHAR(255),
            Degat_attaque1 VARCHAR(255),
            Attaque2 VARCHAR(255),
            Degat_attaque2  VARCHAR(255),
            Attaque3  VARCHAR(255),
            Degat_attaque3  VARCHAR(255),
            Abilite  VARCHAR(16777216),
            APR INTEGER,
            Categorie VARCHAR(255),
            Description Blob
            ); 
         """ 
         
        
        sql_animale_SQLITE =""" INSERT INTO Animal
                            (Nom_Animal, Point_de_Vie, SDC, MDC, Touche, Parade, Esquive, Vitesse, 
                            Attaque1, Degat_attaque1, Attaque2, Degat_attaque2, Attaque3, Degat_attaque3,
                             Abilite, APR, Categorie)
                        VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?);"""
           
        
        sql_animale_MDB =""" INSERT INTO Rifter.Animal
                             (Nom_Animal, Point_de_Vie, SDC, MDC, Touche, Parade, Esquive, Vitesse, 
                             Attaque1,Degat_attaque1, Attaque2, Degat_attaque2, Attaque3, Degat_attaque3,
                              Abilite, APR, Categorie)
                        VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?);"""
        
        sql_animale_MDB_1 =f""" INSERT INTO Rifter.Animal
                             (Nom_Animal, Point_de_Vie, SDC, MDC, Touche, Parade, Esquive, Vitesse, 
                             Attaque1,Degat_attaque1, Attaque2, Degat_attaque2, Attaque3, Degat_attaque3,
                              Abilite, APR, Categorie)
                        VALUES('{un_animal.Nom_Animal}' , 
                        '{un_animal.Point_de_Vie}' ,
                        '{un_animal.SDC}', 
                        '{un_animal.MDC}' ,
                        '{un_animal.Touche}' ,
                        '{un_animal.Parade}' ,
                        '{un_animal.Esquive}' ,
                        '{un_animal.Vitesse}' ,
                        '{un_animal.Attaque1}' ,
                        '{un_animal.Degat_attaque1}', 
                        '{un_animal.Attaque2}' ,
                        '{un_animal.Degat_attaque2}' ,
                        '{un_animal.Attaque3}' ,
                        '{un_animal.Degat_attaque3}' ,
                        '{un_animal.Abilite}' ,
                        '{un_animal.APR}' ,
                        '{un_animal.Categorie}' );"""
        
         
        # 17 champ 
        sql_animale_Base_Access = """ 
                                    SELECT `AnimalName`, HP, SDC, MDC, `Strike`, 
                                    `Parry`, `Dodge`, `Spd`, `Attack1`, `Attack1Damage`, 
                                    `Attack2`, `Attack2Damage`, `Attack3`,
                                    `Attack3Damage`, `Ability`, APR, `Category` FROM `Animals`;"""
                                    
        # lire la table  animal
        
        
        # Vérification des tables
        try:
            
            
            cur_Base_SQlite.execute(drop_Table_animale)
            connection_Base_SQlite.commit()
            cur_Base_SQlite.execute(creer_Table_animale_SQLITE)
            connection_Base_SQlite.commit()
        except  Exception as erreur:
            print("Erreur -SQLLITE base clone:" , erreur)
            connection_Base_SQlite.rollback()       
        
        try:
            #Base  Base_SQlite_fr
            cur_Base_SQlite_fr.execute(drop_Table_animale)
            connection_Basefr.commit()
            
            cur_Base_SQlite_fr.execute(creer_Table_animale_SQLITE)
            connection_Basefr.commit()
            
        except  Exception as erreur:
            print("Erreur -SQLLITE base française:" , erreur)
            connection_Basefr.rollback()     
        
        try:
            #Base  mariadb    
            cur_mariad.execute(drop_Table_animale)
            cur_mariad.execute(creer_Table_animale_MDB)
            
        except mariadb.Error as e:
            print("Creation de la table Animale ")
            print(f"Erreur de connexion avec MariaDB Platform: {e}")   
            connection_mariadb.rollback()
     
        cur_BaseOrigine.execute(sql_animale_Base_Access )
                 
        result = cur_BaseOrigine.fetchall()  # fetchall() : récupère toutes les lignes qui correspondent aux paramètres définis.
        for valeur in result:
            print("Charger animal")
            
            un_animal.charge_table_acess(valeur)
            #print(un_animal.imprimer())
            
            try:
                #Base  Base_SQlite
                cur_Base_SQlite.execute(sql_animale_SQLITE , valeur)
                connection_Base_SQlite.commit()
            except  Exception as erreur:
                print("Erreur -SQLLITE:" , erreur)
                connection_Base_SQlite.rollback()        
            try:
                #Base  Base_SQlite_fr
                cur_Base_SQlite_fr.execute(sql_animale_SQLITE , valeur)
                connection_Basefr.commit()
            except  Exception as erreur:
                print("Erreur -SQLLITE:" , erreur)
                connection_Basefr.rollback()        
             
            try:
                #Base  mariadb    
                #print(un_animal )
                #print(un_animal.insertion_db_mariam())
                 cur_mariad.execute(sql_animale_MDB, valeur )
    
                print(f"{cur_mariad.rowcount} details inserted")
    
            except mariadb.Error as e:
                print(f"Erreur d'insertion à la table Animale sur MariaDB  pour : {e}")   
                print(f"donnee : {valeur}")
                connection_mariadb.rollback()
     
      
    if __name__ == '__main__':
     
        
        try: 
                
            BaseOrigine = (
                r"DRIVER={Microsoft Access Driver (*.mdb, *.accdb)};"
                r"DBQ=E:\eclipse-workspace\RIFT\Base\rcg.mdb;")
            
            BaseSqllite_bg ='RCG-V2.sqllite'
            BaseSqllite_fr ='rcg-fr.sqllite'
    
            connection_BaseOrigine = pyodbc.connect(BaseOrigine)  # Connexion a la base Access
            cur_BaseOrigine = connection_BaseOrigine.cursor()     # Curseur  a la base Access        
            #
            try: 
                # ouverture Bese Sqllite anglise
                connection_Base_SQlite = sqlite3.connect(BaseSqllite_bg)
                cur_Base_SQlite = connection_Base_SQlite.cursor()
                print("Ouverture de la base de données: ",BaseSqllite_bg )
                
                try:
                    # ouverture Bese Sqllite française
                    connection_Basefr = sqlite3.connect(BaseSqllite_fr)
                    cur_Base_SQlite_fr = connection_Basefr.cursor()
                    print("Ouverture de la base de données: ",BaseSqllite_fr )
                    
                    try: 
                        # ouverture Bese mariadb
                        connection_mariadb = mariadb.connect(
                            user="toto",
                            password="mot-de-Passs",
                            host="machine",
                            port=3306,
                            database="tpz")
            
                        print("Ouverture de la base de mariadb")
                        
                        cur_mariad = connection_mariadb.cursor()
    
                        Tb_animal()
                        
                    except mariadb.Error as e:
                        print(f"Erreur de coneection avec MariaDB Platform: {e}")  
                    
                except  Exception as erreur:
                    print("Erreur:" , erreur)
                
            except  Exception as erreur:
                print("Erreur:" , erreur)
                 
        except  Exception as erreur:
            print("Erreur:" , erreur)
            
            
        finally:
            connection_BaseOrigine.close()
            connection_mariadb.close()
            connection_Basefr.close()
            connection_Base_SQlite.close()

    Cette fois j'obtiens

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
     
    Charger animal
    Erreur d'insertion à la table Animale sur MariaDB  pour : Data arguent nust be Tuple or List
    donnee : ('Bear: Grizzly', 120, 80, -1, 2, 2, 1, 16, 'Bite', '1DS+ 6 S.D.', 'Slashing and Tearing Claws', '2D6 + 8 S.D.', 'Pouncing/Ram(2 attacks), 62% chance of knocking its opponent down (victim loses initiative and 1 melee attack)', '2D6 + 4 S.D.', 'None', 4, 'Big')
    Charger animal
    Erreur d'insertion à la table Animale sur MariaDB  pour : Data arguent nust be Tuple or List
    donnee : ('Hawk', 16, 0, -1, 2, 2, 3, 50, 'Bite', '1D6 S.D.', 'Slashing Claws', '1D4 + 2 S.D.', 'Diving Claw (2 attacks)', '2D4 + 2 S.D.', 'Nightvision 300 feet (91.5 m), track by smell 65%.', 3, 'Small')
    Le Code d'inert est similiaire entre les base SLQLITE et MariamDB mais pour MaraimDB j'ai un soucis.

    Si quelqu'un une idéee ce serait super.

  2. #2
    Expert éminent sénior
    Avatar de Sve@r
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    février 2006
    Messages
    9 630
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Oise (Picardie)

    Informations professionnelles :
    Activité : Ingénieur développement logiciels
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : février 2006
    Messages : 9 630
    Points : 26 305
    Points
    26 305
    Billets dans le blog
    1
    Par défaut
    Bonjour
    Citation Envoyé par dedalios Voir le message
    Je ne parviens pas a voir ce qui provoque ce problème d'insertion.
    Moi quand j'ai des soucis dans mes ordres SQL, je les affiche via un print() pour pouvoir les copier/coller dans mon client sql voir si ça vient de la syntaxe (ma faute) ou d'un souci autre (tel le connecteur Psycopg2 pour Postgres qui n'est pas adapté à Postgres13). Ici il semble que ce soit un problème de syntaxe (cf le message d'erreur qui parle d'un souci sur "None" qui, entre parenthèses, n'est effectivement pas un mot clef SQL => le mot clef équivalent c'est "NULL")...
    Mon Tutoriel sur la programmation «Shell»
    Sinon il y en a pleins d'autres. N'oubliez pas non plus les différentes faq disponibles sur ce site

  3. #3
    Membre habitué Avatar de dedalios
    Homme Profil pro
    concepteur d'application
    Inscrit en
    février 2008
    Messages
    423
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Indre et Loire (Centre)

    Informations professionnelles :
    Activité : concepteur d'application
    Secteur : Santé

    Informations forums :
    Inscription : février 2008
    Messages : 423
    Points : 135
    Points
    135
    Par défaut une piste
    J'ai modifié le code de cette façon

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
    179
    180
    181
    182
    183
    184
    185
    186
    187
    188
    189
    190
    191
    192
    193
    194
    195
    196
    197
    198
    199
    200
    201
    202
    203
    204
    205
    206
    207
    208
    209
    210
    211
    212
    213
    214
    215
    216
    217
    218
    219
    220
    221
    222
    223
    224
    225
    226
    227
    228
    229
    230
    231
    232
    233
    234
    235
    236
    237
    238
    239
    240
    241
    242
    243
    244
    245
    246
    247
    248
    249
    250
    251
    252
    253
    254
    255
    256
    257
    258
    259
    260
    261
    262
    263
    264
    265
    266
    267
    268
    269
    270
    271
    272
    273
    274
    275
    276
    277
    278
    279
    280
    281
    282
    283
    284
    285
    286
    287
    288
    289
    290
    291
    292
    293
    294
    295
    296
    # coding: utf-8  
    
    # creattion des tables
    
    import mariadb
    import sqlite3
    import pyodbc 
    from dataclasses import InitVar, dataclass, fields
    
    
    
    @dataclass
    class animal :
        Nom_Animal : str = None
        Point_de_Vie : int = 0
        SDC : int = 0
        MDC : int = -1
        Touche : int = 0
        Parade : int = 0
        Esquive : int = 0
        Vitesse : int = 0
        Attaque1 : str = None
        Degat_attaque1 : str = None
        Attaque2 : str = None
        Degat_attaque2 : str = None
        Attaque3 : str = None
        Degat_attaque3 : str = None 
        Abilite : str = None
        APR : int = 0
        Categorie : str = None
        Description : str = None
        
            
        def charge_table_acess(self , valeur):
            self.Nom_Animal = valeur[0]
            self.Point_de_Vie =  int( valeur[1])
            self.SDC = int( valeur[2])
            self.MDC =  int( valeur[3])
            self.Touche = int(  valeur[4])
            self.Parade = int( valeur[5])
            self.Esquive = int( valeur[6])
            self.Vitesse = int( valeur[7])
            self.Attaque1 = valeur[8]
            self.Degat_attaque1 =  valeur[9]
            self.Attaque2 = valeur[10]
            self.Degat_attaque2 =  valeur[11]
            self.Attaque3 = valeur[12]
            self.Degat_attaque3 =  valeur[13]
            self.Abilite = valeur[14]
            self.APR =  int( valeur[15])
            self.Categorie = valeur[16]
    
    
        def imprimer(self):
            return f"""Donnée de la table Animal : 
    Nom_Animal : { self.Nom_Animal}  
    Point_de_Vie : { self.Point_de_Vie} 
    SDC : { self.SDC}
    MDC : { self.MDC}
    Touche : { self.Touche}
    Parade : { self.Parade}
    Esquive : { self.Esquive}
    Vitesse : { self.Vitesse}
    Attaque1 : { self.Attaque1}
    Degat_attaque1 : { self.Degat_attaque1}
    Attaque2 : { self.Attaque2}
    Degat_attaque2 : { self.Degat_attaque2}
    Attaque3 : { self.Attaque3} '/n'
    Degat_attaque3 : { self.Degat_attaque3}
    Abilite : { self.Abilite}
    APR : { self.APR}
    Categorie : { self.Categorie}
    Description : { self.Description}
                   """ 
    
        def donnee_fr(self):
            valeur = ( self.Nom_Animal,  self.Point_de_Vie , self.SDC , self.MDC  , self.Touche , self.Parade ,
                       self.Esquive , self.Vitesse  , self.Attaque1 , self.Degat_attaque1 , self.Attaque2  ,
                       self.Degat_attaque2 , self.Attaque3  ,  self.Degat_attaque3  , self.Abilite  , self.APR  , self.Categorie )
            return valeur
    
        def donnee_gb(self):
            valeur = ( self.Nom_Animal,  self.Point_de_Vie , self.SDC , self.MDC  , self.Touche , self.Parade ,
                       self.Esquive , self.Vitesse  , self.Attaque1 , self.Degat_attaque1 , self.Attaque2  ,
                       self.Degat_attaque2 , self.Attaque3  ,  self.Degat_attaque3  , self.Abilite  , self.APR  , self.Categorie )
            return valeur       
                
            
    def Tb_animal():
        
        un_animal = animal()
    
        drop_Table_animale = """ DROP TABLE if exists  Animal; """ 
    
        creer_Table_animale_MDB ="""
        CREATE TABLE  if not exists `Animal` (
          `id_Animal` int(11) NOT NULL AUTO_INCREMENT,
          `Nom_Animal` varchar(255) DEFAULT NULL,
          `Point_de_Vie` int(11) DEFAULT NULL,
          `SDC` int(11) DEFAULT NULL,
          `MDC` int(11) DEFAULT -1,
          `Touche` int(11) DEFAULT NULL,
          `Parade` int(11) DEFAULT NULL,
          `Esquive` int(11) DEFAULT NULL,
          `Vitesse` int(11) DEFAULT NULL,
          `Attaque1` varchar(255) DEFAULT NULL,
          `Degat_attaque1` varchar(255) DEFAULT NULL,
          `Attaque2` varchar(255) DEFAULT NULL,
          `Degat_attaque2` varchar(255) DEFAULT NULL,
          `Attaque3` varchar(255) DEFAULT NULL,
          `Degat_attaque3` varchar(255) DEFAULT NULL,
          `Abilite` blob DEFAULT NULL,
          `APR` int(11) DEFAULT NULL,
          `Categorie` varchar(255) DEFAULT NULL,
          `Description` blob DEFAULT NULL,
          PRIMARY KEY (`id_Animal`),
          UNIQUE KEY `Nom_Animal_indx` (`Nom_Animal`)
        ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
        """
         
        
        creer_Table_animale_SQLITE ="""
        CREATE TABLE if not exists  Animal(
            id_Animal INTEGER PRIMARY KEY AUTOINCREMENT,
            Nom_Animal VARCHAR(255) NOT NULL UNIQUE,
            Point_de_Vie INTEGER,
            SDC INTEGER,
            MDC INTEGER DEFAULT -1,
            Touche INTEGER,
            Parade INTEGER,
            Esquive INTEGER,
            Vitesse INTEGER,
            Attaque1 VARCHAR(255),
            Degat_attaque1 VARCHAR(255),
            Attaque2 VARCHAR(255),
            Degat_attaque2  VARCHAR(255),
            Attaque3  VARCHAR(255),
            Degat_attaque3  VARCHAR(255),
            Abilite  VARCHAR(16777216),
            APR INTEGER,
            Categorie VARCHAR(255),
            Description Blob
            ); 
         """ 
         
        
        sql_animale_SQLITE =""" INSERT INTO Animal
                            (Nom_Animal, Point_de_Vie, SDC, MDC, Touche, Parade, Esquive, Vitesse, 
                            Attaque1, Degat_attaque1, Attaque2, Degat_attaque2, Attaque3, Degat_attaque3,
                             Abilite, APR, Categorie)
                        VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?);"""
           
        
        sql_animale_MDB =""" INSERT INTO Rifter.Animal
                             (Nom_Animal, Point_de_Vie, SDC, MDC, Touche, Parade, Esquive, Vitesse, 
                             Attaque1,Degat_attaque1, Attaque2, Degat_attaque2, Attaque3, Degat_attaque3,
                              Abilite, APR, Categorie)
                        VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?);"""
         
        # 17 champ 
        sql_animale_Base_Access = """ 
                                    SELECT `AnimalName`, HP, SDC, MDC, `Strike`, 
                                    `Parry`, `Dodge`, `Spd`, `Attack1`, `Attack1Damage`, 
                                    `Attack2`, `Attack2Damage`, `Attack3`,
                                    `Attack3Damage`, `Ability`, APR, `Category` FROM `Animals`;"""
                                    
        # lire la table  animal
        
        
        # Vérification des tables
        try:
            cur_Base_SQlite.execute(drop_Table_animale)
            connection_Base_SQlite.commit()
            cur_Base_SQlite.execute(creer_Table_animale_SQLITE)
            connection_Base_SQlite.commit()
            
        except  Exception as erreur:
            print("Erreur -SQLLITE base clone:" , erreur)
            connection_Base_SQlite.rollback()       
        
        try:
            #Base  Base_SQlite_fr
            cur_Base_SQlite_fr.execute(drop_Table_animale)
            connection_Basefr.commit()
            
            cur_Base_SQlite_fr.execute(creer_Table_animale_SQLITE)
            connection_Basefr.commit()
            
        except  Exception as erreur:
            print("Erreur -SQLLITE base française:" , erreur)
            connection_Basefr.rollback()     
        
        try:
            #Base  mariadb    
            cur_mariad.execute(drop_Table_animale)
            cur_mariad.execute(creer_Table_animale_MDB)
            
        except mariadb.Error as e:
            print("Creation de la table Animale ")
            print(f"Erreur de connexion avec MariaDB Platform: {e}")   
            connection_mariadb.rollback()
     
        cur_BaseOrigine.execute(sql_animale_Base_Access )
                 
        result = cur_BaseOrigine.fetchall()  # fetchall() : récupère toutes les lignes qui correspondent aux paramètres définis.
        for valeur in result:
            print("Charger animal")
            
            un_animal.charge_table_acess(valeur)
     
            try:
                #Base  Base_SQlite  
                cur_Base_SQlite.execute(sql_animale_SQLITE , un_animal.donnee_gb())
                connection_Base_SQlite.commit()
            except  Exception as erreur:
                print("Erreur -SQLLITE:" , erreur)
                connection_Base_SQlite.rollback()        
            try:
                #Base  Base_SQlite_fr
    
                cur_Base_SQlite_fr.execute(sql_animale_SQLITE , un_animal.donnee_fr())
                connection_Basefr.commit()
            except  Exception as erreur:
                print("Erreur -SQLLITE:" , erreur)
                connection_Basefr.rollback()        
             
            try:
                #Base  mariadb    
              
                cur_mariad.execute(sql_animale_MDB , un_animal.donnee_gb())
                print(un_animal.donnee_gb())
                print(f"{cur_mariad.rowcount} enregistrement inserer")
    
            except mariadb.Error as e:
                print(f"Erreur d'insertion à la table Animale sur MariaDB  pour : {e}")
                connection_mariadb.rollback()
    
    if __name__ == '__main__':
     
        
        try: 
                
            BaseOrigine = (
                r"DRIVER={Microsoft Access Driver (*.mdb, *.accdb)};"
                r"DBQ=E:\eclipse-workspace\RIFT\Base\rcg.mdb;")
            
            BaseSqllite_bg ='RCG-V2.sqllite'
            BaseSqllite_fr ='rcg-fr.sqllite'
    
            connection_BaseOrigine = pyodbc.connect(BaseOrigine)  # Connexion a la base Access
            cur_BaseOrigine = connection_BaseOrigine.cursor()     # Curseur  a la base Access        
            #
            try: 
                # ouverture Bese Sqllite anglise
                connection_Base_SQlite = sqlite3.connect(BaseSqllite_bg)
                cur_Base_SQlite = connection_Base_SQlite.cursor()
                print("Ouverture de la base de données: ",BaseSqllite_bg )
                
                try:
                    # ouverture Bese Sqllite française
                    connection_Basefr = sqlite3.connect(BaseSqllite_fr)
                    cur_Base_SQlite_fr = connection_Basefr.cursor()
                    print("Ouverture de la base de données: ",BaseSqllite_fr )
                    
                    try: 
                        # ouverture Bese mariadb
                        connection_mariadb = mariadb.connect(
                            user="toto",
                            password="toto",
                            host="toto",
                            port=3306,
                            database="Rifter")
                        print("Ouverture de la base de mariadb")
                        
                        cur_mariad = connection_mariadb.cursor()
    
                        Tb_animal()
                        
                    except mariadb.Error as e:
                        print(f"Erreur de coneection avec MariaDB Platform: {e}")  
                    
                except  Exception as erreur:
                    print("Erreur:" , erreur)
                
            except  Exception as erreur:
                print("Erreur:" , erreur)
                 
        except  Exception as erreur:
            print("Erreur:" , erreur)
            
            
        finally:
            connection_BaseOrigine.close()
            connection_mariadb.close()
            connection_Basefr.close()
            connection_Base_SQlite.close()

    j'ai modifié mon code .
    Celui-ci semble a priori fonctionner sauf que lorsque le regarde les 3 bases , j'ai bien des données sur les bases SQLLITE mais pour ce qui est des données mariamdb celle-ci est vide?


    Voici ce que donne les print , il y a des données dans l'insertion

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    Ouverture de la base de données:  RCG-V2.sqllite
    Ouverture de la base de données:  rcg-fr.sqllite
    Ouverture de la base de mariadb
    Charger animal
    ('Gorilla', 80, 80, -1, 3, 3, 1, 12, 'Bite', '2D4 S.D.', 'Slashing and Tearing hands', '2D6 + 6 S.D.', None, None, 'Nightvision 15 feet (4.6 m), climb 40%, and prowl 40%.', 4, 'Medium')
    1 enregistrement inserer
    Charger animal
    ('Badger', 30, 10, -1, 1, 1, 3, 12, 'Bite or Slashing claws', '1D6 + 2 S.D.', None, None, None, None, 'Nightvision 50 Feet (4.6 m), climb 60%, leap up to 10 feet (3 m). Dig 5 feet (1.5 m) per minute, track by smell 65%.', 3, 'Small')
    1 enregistrement inserer

  4. #4
    Expert éminent sénior
    Homme Profil pro
    Architecte technique retraité
    Inscrit en
    juin 2008
    Messages
    18 646
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Manche (Basse Normandie)

    Informations professionnelles :
    Activité : Architecte technique retraité
    Secteur : Industrie

    Informations forums :
    Inscription : juin 2008
    Messages : 18 646
    Points : 32 194
    Points
    32 194
    Par défaut
    Salut,

    Avant d'écrire 300 lignes de code, il est bon de fabriquer un petit exemple où on teste les fonctionnalités dont on va avoir besoin... histoire de s'assurer qu'elles feront ce qu'on attend *et* d'avoir une référence à comparer au cas où.

    Après bien sûr quand on s'est embarqué un peu trop vite à coder on peut toujours demander de l'aide... mais 300 lignes de code pas facile à lire qu'on ne peut pas faire fonctionner sans les données ni les bases de données sous la main (à installer...) faut pas rêver!

    Je dirais que si çà marche "bien" et qu'on ne retrouve pas les données dans la BD, c'est qu'on a probablement oublié des "commit".

    - W
    Architectures post-modernes.
    Python sur DVP c'est aussi des FAQs, des cours et tutoriels

  5. #5
    Membre habitué Avatar de dedalios
    Homme Profil pro
    concepteur d'application
    Inscrit en
    février 2008
    Messages
    423
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Indre et Loire (Centre)

    Informations professionnelles :
    Activité : concepteur d'application
    Secteur : Santé

    Informations forums :
    Inscription : février 2008
    Messages : 423
    Points : 135
    Points
    135
    Par défaut Commit
    Effectivement le commit. , merci


    J'ai trouvé le pourquoi de cette histoire de None.
    Dans la base d'Origine il existe dans champ contenant le terme 'None' .



    voici par ailleurs la version du code qui ne fait que le transfert des données vers la base Mariamdb pour réduire au minima comme demandé.
    Le code fonctionne et fait que qui doit être.


    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
    179
    180
    181
    182
    183
    184
    185
    186
    187
    188
    189
    190
    191
    192
    193
    194
    195
    # coding: utf-8  
     
    # creattion des tables
     
    import mariadb
     
    import pyodbc 
    from dataclasses import   dataclass 
     
    @dataclass
    class animal:
        Nom_Animal : str = None
        Point_de_Vie : int = 0
        SDC : int = 0
        MDC : int = -1
        Touche : int = 0
        Parade : int = 0
        Esquive : int = 0
        Vitesse : int = 0
        Attaque1 : str= None
        Degat_attaque1 : str= None
        Attaque2 : str = None
        Degat_attaque2 : str = None
        Attaque3 : str = None
        Degat_attaque3 : str = None
        Abilite : str = None
        APR : int = 0
        Categorie : str = None
        Description : str = None 
     
     
        def imprimer(self) -> str:
            return f"""Donnée de la table Animal : 
    Nom_Animal : { self.Nom_Animal}  
    Point_de_Vie : { self.Point_de_Vie} 
    SDC : { self.SDC}
    MDC : { self.MDC}
    Touche : { self.Touche}
    Parade : { self.Parade}
    Esquive : { self.Esquive}
    Vitesse : { self.Vitesse}
    Attaque1 : { self.Attaque1}
    Degat_attaque1 : { self.Degat_attaque1}
    Attaque2 : { self.Attaque2}
    Degat_attaque2 : { self.Degat_attaque2}
    Attaque3 : { self.Attaque3} 
    Degat_attaque3 : { self.Degat_attaque3}
    Abilite : { self.Abilite}
    APR : { self.APR}
    Categorie : { self.Categorie}
    Description : { self.Description}
                   """ 
     
     
        def donnee_gb(self):
            valeur = ( self.Nom_Animal,  self.Point_de_Vie , self.SDC , self.MDC  , self.Touche , self.Parade ,
                       self.Esquive , self.Vitesse  , self.Attaque1 , self.Degat_attaque1 , self.Attaque2  ,
                       self.Degat_attaque2 , self.Attaque3  ,  self.Degat_attaque3  , self.Abilite  , self.APR  , self.Categorie )
            return valeur       
     
     
    def Tb_animal():
     
     
     
        drop_Table_animale = """ DROP TABLE if exists  Animal; """ 
     
        creer_Table_animale_MDB ="""
        CREATE TABLE  if not exists `Animal` (
          `id_Animal` int(11) NOT NULL AUTO_INCREMENT,
          `Nom_Animal` varchar(255) DEFAULT NULL,
          `Point_de_Vie` int(11) DEFAULT 0,
          `SDC` int(11) DEFAULT 0,
          `MDC` int(11) DEFAULT -1,
          `Touche` int(11)  DEFAULT NULL,
          `Parade` int(11) DEFAULT NULL,
          `Esquive` int(11) DEFAULT NULL,
          `Vitesse` int(11) DEFAULT 0,
          `Attaque1` varchar(255) DEFAULT NULL,
          `Degat_attaque1` varchar(255) DEFAULT NULL,
          `Attaque2` varchar(255) DEFAULT NULL,
          `Degat_attaque2` varchar(255) DEFAULT NULL,
          `Attaque3` varchar(255) DEFAULT NULL,
          `Degat_attaque3` varchar(255) DEFAULT NULL,
          `Abilite` blob DEFAULT NULL,
          `APR` int(11) DEFAULT NULL,
          `Categorie` varchar(255) DEFAULT NULL,
          `Description` blob DEFAULT NULL,
          PRIMARY KEY (`id_Animal`),
          UNIQUE KEY `Nom_Animal_indx` (`Nom_Animal`)
        ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
        """
     
     
     
        sql_animale_MDB =""" INSERT INTO Rifter.Animal
                             (Nom_Animal, Point_de_Vie, SDC, MDC, Touche, Parade, Esquive, Vitesse, 
                             Attaque1,Degat_attaque1, Attaque2, Degat_attaque2, Attaque3, Degat_attaque3,
                              Abilite, APR, Categorie)
                        VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?);"""
     
        # 17 champ 
        sql_animale_Base_Access = """ 
                                    SELECT `AnimalName`, HP, SDC, MDC, `Strike`, 
                                    `Parry`, `Dodge`, `Spd`, `Attack1`, `Attack1Damage`, 
                                    `Attack2`, `Attack2Damage`, `Attack3`,
                                    `Attack3Damage`, `Ability`, APR, `Category` FROM `Animals`;"""
     
        # lire la table  animal
     
     
     
        try:
            #Base  mariadb    
            cur_mariad.execute(drop_Table_animale)
            cur_mariad.execute(creer_Table_animale_MDB)
     
        except mariadb.Error as e:
            print("Creation de la table Animale ")
            print(f"Erreur de connexion avec MariaDB Platform: {e}")   
            connection_mariadb.rollback()
     
        cur_BaseOrigine.execute(sql_animale_Base_Access )
     
        result = cur_BaseOrigine.fetchall()  # fetchall() : récupère toutes les lignes qui correspondent aux paramètres définis.
        print("Charger animal")
        for valeur in result:
            un_animal =  animal(valeur[0] , 
             int( valeur[1]) ,   
             int( valeur[2]) ,
             int( valeur[3]) ,
             int( valeur[4]) ,
             int( valeur[5]) ,
             int( valeur[6]) , 
             int( valeur[7]) , 
             valeur[8] ,
             valeur[9] ,
             valeur[10] ,
             valeur[11] , 
             valeur[12], 
             valeur[13] ,
             valeur[14] ,
             int( valeur[15]) ,
             valeur[16]) 
     
            print(un_animal.imprimer())
            try:
                #Base  mariadb    
     
                cur_mariad.execute(sql_animale_MDB , un_animal.donnee_gb())
                #print(un_animal.donnee_gb())
                print(f"{cur_mariad.rowcount} enregistrement inserer")
                connection_mariadb.commit()
     
            except mariadb.Error as e:
                print(f"Erreur d'insertion à la table Animale sur MariaDB  pour : {e}")
                connection_mariadb.rollback()
     
    if __name__ == '__main__':
     
     
        try: 
     
            BaseOrigine = (
                r"DRIVER={Microsoft Access Driver (*.mdb, *.accdb)};"
                r"DBQ=E:\eclipse-workspace\RIFT\Base\rcg.mdb;")
     
            connection_BaseOrigine = pyodbc.connect(BaseOrigine)  # Connexion a la base Access
            cur_BaseOrigine = connection_BaseOrigine.cursor()     # Curseur  a la base Access        
            #
     
            try: 
                # ouverture Bese mariadb
                connection_mariadb = mariadb.connect(
                user="Rifter",
                password="&Sylver+1951",
                host="opal-sam",
                port=3306,
                database="Rifter")
                print("Ouverture de la base de mariadb")
     
                cur_mariad = connection_mariadb.cursor()
     
                Tb_animal()
     
            except mariadb.Error as e:
                print(f"Erreur de coneection avec MariaDB Platform: {e}")  
     
        except  Exception as erreur:
            print("Erreur:" , erreur)
     
     
        finally:
            connection_BaseOrigine.close()
            connection_mariadb.close()

    Sur ce code on a un objet creer avec la solution des dataclass

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
     
    from dataclasses import   dataclass 
    @dataclass
    class animal:
        Nom_Animal : str = None
        Point_de_Vie : int = 0
        SDC : int = 0
        MDC : int = -1
        Touche : int = 0
        Parade : int = 0
        Esquive : int = 0
        Vitesse : int = 0
        Attaque1 : str= None
        Degat_attaque1 : str= None
        Attaque2 : str = None
        Degat_attaque2 : str = None
        Attaque3 : str = None
        Degat_attaque3 : str = None
        Abilite : str = None
        APR : int = 0
        Categorie : str = None
        Description : str = None

    je m’aperçois que si j'écris la classe de cette façon

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    # coding: utf-8  
    from dataclasses import   dataclass 
    @dataclass
    class animal:
        Nom_Animal : str 
        Point_de_Vie : int = 0
        SDC : int = 0
        MDC : int = -1
        Touche : int = 0
        Parade : int = 0
        Esquive : int = 0
        Vitesse : int = 0
        Attaque1 : str 
        Degat_attaque1 : str 
        Attaque2 : str  
        Degat_attaque2 : str  
        Attaque3 : str  
        Degat_attaque3 : str  
        Abilite : str  
        APR : int = 0
        Categorie : str 
        Description : str

    Lors de l'exécution de ce petit bout de code j'obtiens un message de rejet pour le 1ier champ de type str positionné après un entier.... Eclipse semble mécontent car il générè une erreur

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    Traceback (most recent call last):
      File "E:\eclipse-workspace\RIFT\Base\__init__.py", line 4, in <module>
        class animal:
      File "G:\Python39\lib\dataclasses.py", line 1021, in dataclass
        return wrap(cls)
      File "G:\Python39\lib\dataclasses.py", line 1013, in wrap
        return _process_class(cls, init, repr, eq, order, unsafe_hash, frozen)
      File "G:\Python39\lib\dataclasses.py", line 927, in _process_class
        _init_fn(flds,
      File "G:\Python39\lib\dataclasses.py", line 504, in _init_fn
        raise TypeError(f'non-default argument {f.name!r} '
    TypeError: non-default argument 'Attaque1' follows default argument

  6. #6
    Expert éminent sénior
    Homme Profil pro
    Architecte technique retraité
    Inscrit en
    juin 2008
    Messages
    18 646
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Manche (Basse Normandie)

    Informations professionnelles :
    Activité : Architecte technique retraité
    Secteur : Industrie

    Informations forums :
    Inscription : juin 2008
    Messages : 18 646
    Points : 32 194
    Points
    32 194
    Par défaut
    Citation Envoyé par dedalios Voir le message
    ceci étant je ne comprendre pas a pourquoi sqllite accepte d’insérer un champ portant la valeur "None"
    Lorsqu'on utilise la substitution de paramètres de l'API (plutôt que de construire la chaine de caractère de la requête SQL complète), la bibliothèque convertit le type Python en type de la base de données.

    Pour SQLITE, la conversion de None (python) en NULL (sqlite) est documentée.

    Pour MariaDB, ça devrait l'être aussi (je ne vais pas chercher dans la documentation pour vous!) et en cas d'oubli, vous pouvez toujours demander une amélioration aux développeurs.

    - W
    Architectures post-modernes.
    Python sur DVP c'est aussi des FAQs, des cours et tutoriels

  7. #7
    Membre habitué Avatar de dedalios
    Homme Profil pro
    concepteur d'application
    Inscrit en
    février 2008
    Messages
    423
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Indre et Loire (Centre)

    Informations professionnelles :
    Activité : concepteur d'application
    Secteur : Santé

    Informations forums :
    Inscription : février 2008
    Messages : 423
    Points : 135
    Points
    135
    Par défaut Quid en utilisant sqlalcheny
    bonjour finaliement je vais opte pour Alchemy

    Ceici etant je veux creer une relation de type 1;n entre ma table Animal et T_Attaque_Animal.
    avec une ForeignKey entre ces 2 tables.


    soucis
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
     Id_Animal  = Column(Integer ,  ForeignKey(T_Animal.Id_Animal ))
    NameError: name 'ForeignKey' is not defined
    je regarde plusieurs exemple qui ulise la creation de ForeignKey


    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    # coding: utf-8  
     
    import time
    from sqlalchemy import Column, Integer, Text ,  String,  create_engine 
    from sqlalchemy.orm import scoped_session, sessionmaker
    from sqlalchemy.ext.declarative import declarative_base
     
    # Base class used by my classes (my entities)
    Base = declarative_base()    # Required
     
    # Definition of the Contact class
     
    class T_Animal( Base ):
        __tablename__ = 'Animal'
        Id_Animal = Column(Integer, primary_key=True)
        Nom_Animal = Column(String(255) , unique =True )
        Point_de_Vie = Column(Integer)
        SDC = Column(Integer)
        MDC =  Column(Integer)
        Touche = Column(Integer)
        Parade = Column(Integer)
        Esquive = Column(Integer)
        Vitesse = Column(Integer)
        Abilite = Column(String(1500000))
        Apr =Column(Integer)
        Categorie =Column(String(255) )
        Description =  Column(String(1500000))
     
     
    class T_Attaque_Animal( Base ):
        __tablename__ = 'Attaque_Animal'
        Id_Attaque  = Column(Integer, primary_key=True)    
        Id_Animal  = Column(Integer ,  ForeignKey(T_Animal.Id_Animal ))
        Arme = Column(String(255) )
        Degat = Column(String(255) )
        Description = Column(String(255) )
     
        Id_Animal_relation  = relationship('T_Animal', foreign_keys='T_Attaque_Animal.Id_Animal')
     
     
     
    # The main part
    if __name__ == '__main__':
     
        engine = create_engine("mariadb+mariadbconnector://Rifter:toto@mabas:3306/Exercices", echo=False)
     
        print("--- Construire toutes les tables de la base de données (ici juste une table) ---" )
        Base.metadata.create_all(engine)    # Only for the first time
     
     
        print( "--- Créer trois nouveaux contacts et les pousser dans la base de données. ---" )
        Session = sessionmaker(bind=engine)
        session = Session()
     
        session.commit()
    quelqu'un a une idee , merci ?

  8. #8
    Expert éminent sénior
    Homme Profil pro
    Architecte technique retraité
    Inscrit en
    juin 2008
    Messages
    18 646
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Manche (Basse Normandie)

    Informations professionnelles :
    Activité : Architecte technique retraité
    Secteur : Industrie

    Informations forums :
    Inscription : juin 2008
    Messages : 18 646
    Points : 32 194
    Points
    32 194
    Par défaut
    Salut,

    Citation Envoyé par dedalios Voir le message
    quelqu'un a une idee , merci ?
    Lorsque le programmeur Python rencontre l'erreur "NameError: name 'ForeignKey' is not defined", il sait que la variable globale "ForeignKey" n'a pas été définie... Et si elle est supposée venir d'une bibliothèque externe, il vérifie ses "import".

    Et si le petit monstre qu'est sqlalchemy vous déstabilise tant que ça, il va peut être falloir y aller plus doucement (il y a des tutos!).

    - W
    Architectures post-modernes.
    Python sur DVP c'est aussi des FAQs, des cours et tutoriels

  9. #9
    Membre habitué Avatar de dedalios
    Homme Profil pro
    concepteur d'application
    Inscrit en
    février 2008
    Messages
    423
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Indre et Loire (Centre)

    Informations professionnelles :
    Activité : concepteur d'application
    Secteur : Santé

    Informations forums :
    Inscription : février 2008
    Messages : 423
    Points : 135
    Points
    135
    Par défaut
    une majorité d'exemple omet cet import

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    # coding: utf-8  
    
    import time
    from sqlalchemy import Column, Integer, Text ,  String,  create_engine , ForeignKey  ], BLOB
    from sqlalchemy.orm import scoped_session, sessionmaker, relationship
    from sqlalchemy.ext.declarative import declarative_base
     
    # Base class used by my classes (my entities)
    Base = declarative_base()    # Required
    
    # Definition of the Contact class
    
    class T_Animal( Base ):
        __tablename__ = 'Animal'
        Id_Animal = Column(Integer, primary_key=True)
        Nom_Animal = Column(String(255) , unique =True )
        Point_de_Vie = Column(Integer)
        SDC = Column(Integer)
        MDC =  Column(Integer)
        Touche = Column(Integer)
        Parade = Column(Integer)
        Esquive = Column(Integer)
        Vitesse = Column(Integer)
        Abilite = Column(BLOB)
        Apr =Column(Integer)
        Categorie =Column(String(255) )
        Description =  Column(BLOB)
        
    
    class T_Attaque_Animal( Base ):
        __tablename__ = 'Attaque_Animal'
        Id_Attaque  = Column(Integer, primary_key=True)    
        Id_Animal  = Column(Integer ,  ForeignKey(T_Animal.Id_Animal ))
        Arme = Column(String(255) )
        Degat = Column(String(255) )
        Description = Column(String(255) )
    
        Id_Animal_relation  = relationship('T_Animal', foreign_keys='T_Attaque_Animal.Id_Animal')
    
    
    
    # The main part
    if __name__ == '__main__':
    
     engine = create_engine("mariadb+mariadbconnector://ttt:ttttttt@opal-sam:3306/Exercices", echo=False)
     
        
        print("--- Construire toutes les tables de la base de données (ici juste une table) ---" )
        Base.metadata.create_all(engine)    # Only for the first time
    
        
        print( "--- Créer trois nouveaux contacts et les pousser dans la base de données. ---" )
        Session = sessionmaker(bind=engine)
        session = Session()
     
        session.commit()        # Mandatory
       # Mandatory

  10. #10
    Expert éminent sénior
    Homme Profil pro
    Architecte technique retraité
    Inscrit en
    juin 2008
    Messages
    18 646
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Manche (Basse Normandie)

    Informations professionnelles :
    Activité : Architecte technique retraité
    Secteur : Industrie

    Informations forums :
    Inscription : juin 2008
    Messages : 18 646
    Points : 32 194
    Points
    32 194
    Par défaut
    Citation Envoyé par dedalios Voir le message
    une majorité d'exemple omet cet import
    Je ne vois pas l'intérêt d'aller à la pêche sans avoir regardé le tuto. qui vient avec SQLAchemy.
    Là où ça commence à parler de "contraintes", l'import n'est pas omis.

    Ceci dit, le "NameError" signale cette omission...

    - W
    Architectures post-modernes.
    Python sur DVP c'est aussi des FAQs, des cours et tutoriels

  11. #11
    Membre habitué Avatar de dedalios
    Homme Profil pro
    concepteur d'application
    Inscrit en
    février 2008
    Messages
    423
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Indre et Loire (Centre)

    Informations professionnelles :
    Activité : concepteur d'application
    Secteur : Santé

    Informations forums :
    Inscription : février 2008
    Messages : 423
    Points : 135
    Points
    135
    Par défaut quid de l'option d'insertion
    bonjour

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    # coding: utf-8  
    from sqlalchemy import Column, Integer, Text ,  String,  create_engine ,ForeignKey , BLOB , Float, BigInteger
    from sqlalchemy.orm import scoped_session, sessionmaker, relationship
    from sqlalchemy.ext.declarative import declarative_base
    from sqlalchemy.ext.compiler import compiles
    from sqlalchemy import delete, insert , update ,  func ,select
    from sqlalchemy.schema import CreateTable
     
     
     
    from dataclasses import InitVar, dataclass, fields
    import pyodbc  
    from tkinter.constants import MULTIPLE
    from sqlalchemy.exc import MultipleResultsFound
     
     
    #Preresquis sqllite 
    class SLBigInteger(BigInteger):
        pass 
     
    # Base class used by my classes (my entities)
    Base = declarative_base()    # Required
     
     
    class T_Category_bionic( Base ):
        __tablename__ = 'Category_bionic'
        Id_Category_bionic = Column(Integer, primary_key=True,  autoincrement=True)
        Nom_Category_bionic = Column(String(255) , unique =True ,index =True ) 
     
    class T_Bionics( Base ):
        __tablename__ = 'Bionics'
        Id_Bionics =  Column(Integer, primary_key=True,  autoincrement=True) 
        Nom_Bionics = Column(String(255) , unique =True ,index =True )
        Id_Category_bionic  =  Column(Integer, ForeignKey(T_Category_bionic.Id_Category_bionic ))
        Cost = Column(Float ,default = 0.0)
        Cat =  Column(String(1))
        Location =  Column(String(255)) 
        Description =  Column(Text)
     
        # Id_Category_bionic_relation  = relationship('T_Bionics', foreign_keys='T_Category_bionic.Id_Category_bionic')
     
     
     
     
    def init_sqlalchemy_rcg_fr():  # Base sqllite-fr
        global engine_rcg_fr
        global Base_rcg_fr 
        global DBSession_rcg_fr 
     
        Base_rcg_fr = declarative_base()
        DBSession_rcg_fr = scoped_session(sessionmaker())
        BaseSqllite_fr = 'Animal.db'
        dbname = 'sqlite:///' + BaseSqllite_fr
        engine_rcg_fr = create_engine(dbname, echo=False)
        Base.metadata.create_all(engine_rcg_fr)      # uniquement à la creation installe les tables
        DBSession_rcg_fr.remove()
        DBSession_rcg_fr.configure(bind=engine_rcg_fr, autoflush=False, expire_on_commit=False)
        Base_rcg_fr.metadata.drop_all(engine_rcg_fr)
        Base_rcg_fr.metadata.create_all(engine_rcg_fr)
     
    if __name__ == '__main__':
        BaseOrigine = (
            r"DRIVER={Microsoft Access Driver (*.mdb, *.accdb)};"
            r"DBQ=Z:\Base\rcg.mdb;")
     
            # 17 champ 
        sql_Bionics_Base_Access = """ 
                                   SELECT `Category`, `ItemName`, `Cost`, `Cat`, `Location`, `Description` FROM `Bionics`;
                                    """
     
        sql_Bionics_Category_Base_Access = """ 
                                   SELECT DISTINCT `Category` FROM `Bionics`;
                                    """                                
        try :
     
            init_sqlalchemy_rcg_fr()
     
            connection_BaseOrigine = pyodbc.connect(BaseOrigine)  # Connexion a la base Access
            # now locks are removed
     
            cur_BaseOrigine = connection_BaseOrigine.cursor()     # Curseur  a la base Access     
     
     
     
     
     
            cur_BaseOrigine.execute(sql_Bionics_Category_Base_Access )
            print("Charger Table  ")
            result = cur_BaseOrigine.fetchall()  # fetchall() : r&#65533;cup&#65533;re toutes les lignes qui correspondent aux param&#65533;tres d&#65533;finis.
            for Category    in result:
                #print(Category[0])
                stmt = (insert(T_Category_bionic).values(Nom_Category_bionic = Category[0] ))
                #print(stmt)
                try:
                    DBSession_rcg_fr.execute(stmt)
                except  Exception as erreur:
                    print(erreur)
                finally:
                    DBSession_rcg_fr.commit()
     
     
            # lire la table  Category_bionic
     
            result = DBSession_rcg_fr.query(T_Category_bionic ).all()
     
            for row in result:
                 print ("Id_Category_bionic: ",row.Id_Category_bionic, "Nom_Category_bionic:",row.Nom_Category_bionic )
     
            print("-------------------------------------------------------")
     
            resultat = DBSession_rcg_fr.execute(select(T_Category_bionic.Id_Category_bionic).where(T_Category_bionic.Nom_Category_bionic == "Bionic Eyes & Sensors"))
            for donnee ,  in resultat:
                print(donnee)
     
     
     
            cur_BaseOrigine.execute(sql_Bionics_Base_Access )
            print("Charger Table 2")
            result = cur_BaseOrigine.fetchall()  #fetchall() : récupère toutes les lignes qui correspondent aux paramêtres définis.
            for Category, ItemName, Cost, Cat, Location, Description    in result:
     
                resultat = DBSession_rcg_fr.execute(select(T_Category_bionic.Id_Category_bionic).where(T_Category_bionic.Nom_Category_bionic == Category))
                for donnee ,  in resultat:
                    print(donnee) 
                print(ItemName)    
     
     
     
     
        except  Exception as erreur:
            print("Erreur:" , erreur)
     
        finally:    
            pass
    la procédure de la sélection fonctionne pour autant, je ne trouve pas cette solution pertinente, utiliser une boucle for pour obtenir une valeur qui ne être qu'unique le semble farfelue!


    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
               resultat = DBSession_rcg_fr.execute(select(T_Category_bionic.Id_Category_bionic).where(T_Category_bionic.Nom_Category_bionic == Category))
                for donnee ,  in resultat:
                    print(donnee)

    Par ailleurs, je souhaitais utiliser les filtre de sqlalcmey
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
            result = DBSession_rcg_fr.query(T_Category_bionic).filter(T_Category_bionic.Nom_Category_bionic == "Bionic Eyes & Sensors")
     
            print(result)
    Le print retourne la requête mais pas les données!

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    SELECT "Category_bionic"."Id_Category_bionic" AS "Category_bionic_Id_Category_bionic", "Category_bionic"."Nom_Category_bionic" AS "Category_bionic_Nom_Category_bionic" 
    FROM "Category_bionic" 
    WHERE "Category_bionic"."Nom_Category_bionic" = ?
    alors que la commande all() utlisant les même règles présent sur la documentation d'SQLALCHEMY retourne les données

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
            result = DBSession_rcg_fr.query(T_Category_bionic ).all()
     
            for row in result:
                 print ("Id_Category_bionic: ",row.Id_Category_b
    donne pour résultat

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    Id_Category_bionic:  1 Nom_Category_bionic: Bionic Eyes & Sensors
    Id_Category_bionic:  2 Nom_Category_bionic: Bionic Hands Weapons and Tools
    Id_Category_bionic:  3 Nom_Category_bionic: Cyborg Armor

  12. #12
    Membre habitué Avatar de dedalios
    Homme Profil pro
    concepteur d'application
    Inscrit en
    février 2008
    Messages
    423
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Indre et Loire (Centre)

    Informations professionnelles :
    Activité : concepteur d'application
    Secteur : Santé

    Informations forums :
    Inscription : février 2008
    Messages : 423
    Points : 135
    Points
    135
    Par défaut recherche dans SQLalchemy d'une selection de donnée unique
    Ma table

    Code SQL : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    -- Category_bionic definition
     
    CREATE TABLE "Category_bionic" (
    	"Id_Category_bionic" INTEGER NOT NULL, 
    	"Nom_Category_bionic" VARCHAR(255), 
    	PRIMARY KEY ("Id_Category_bionic")
    );
     
    CREATE UNIQUE INDEX "ix_Category_bionic_Nom_Category_bionic" ON "Category_bionic" ("Nom_Category_bionic");

    la version SQLalchemy

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    class T_Category_bionic( Base ):
        __tablename__ = 'Category_bionic'
        Id_Category_bionic = Column(Integer, primary_key=True,  autoincrement=True)
        Nom_Category_bionic = Column(String(255) , unique =True ,index =True )
    la recherche de données equivalente à la reqûete

    Code SQL : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    SELECT Id_Category_bionic
    FROM Category_bionic
    where   Nom_Category_bionic ='Leg Weapons and Accessories'


    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
            o_Category='Leg Weapons and Accessories'   
            resultat = DBSession_rcg_fr.execute(select(T_Category_bionic.Id_Category_bionic).where(T_Category_bionic.Nom_Category_bionic == o_Category)).first()
            print(resultat)
    Le résultat de la commande sqlalchemy renvoi "(6,)" dommage qu'il ne donne pas simplement la valeur "6" dommage.

    Peut être est-ce aussi une erreur dans l'expression sqlalchmy utilisée...

  13. #13
    Expert éminent sénior
    Homme Profil pro
    Architecte technique retraité
    Inscrit en
    juin 2008
    Messages
    18 646
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Manche (Basse Normandie)

    Informations professionnelles :
    Activité : Architecte technique retraité
    Secteur : Industrie

    Informations forums :
    Inscription : juin 2008
    Messages : 18 646
    Points : 32 194
    Points
    32 194
    Par défaut
    Citation Envoyé par dedalios Voir le message
    Le résultat de la commande sqlalchemy renvoi "(6,)" dommage qu'il ne donne pas simplement la valeur "6" dommage.
    SQLAlchemy ou pas, un SELECT retourne toujours les lignes qui matchent la sélection. On a donc une séquence de... qui seront aussi des séquences si on récupère plusieurs colonnes sur chaque ligne.

    Essayez avec SQLite3 pour le vérifier.

    Et arrêtez d'espérer que ça fasse ce que çà ne fait pas.

    - W
    Architectures post-modernes.
    Python sur DVP c'est aussi des FAQs, des cours et tutoriels

  14. #14
    Expert éminent sénior
    Avatar de Sve@r
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    février 2006
    Messages
    9 630
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Oise (Picardie)

    Informations professionnelles :
    Activité : Ingénieur développement logiciels
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : février 2006
    Messages : 9 630
    Points : 26 305
    Points
    26 305
    Billets dans le blog
    1
    Par défaut
    Citation Envoyé par dedalios Voir le message
    Le résultat de la commande sqlalchemy renvoi "(6,)" dommage qu'il ne donne pas simplement la valeur "6" dommage.
    Un résultat de requête peut contenir plusieurs colonnes. Tester "une colonne/plusieurs colonnes" à chaque requête prendrait du temps de calcul pour bien peu de plus-value.
    Mon Tutoriel sur la programmation «Shell»
    Sinon il y en a pleins d'autres. N'oubliez pas non plus les différentes faq disponibles sur ce site

Discussions similaires

  1. Réponses: 4
    Dernier message: 10/05/2009, 11h18
  2. [AC-2000] Problème de chargement base de données cause format?
    Par francky42 dans le forum VBA Access
    Réponses: 14
    Dernier message: 17/04/2009, 14h44
  3. Problême d'ouverture base de données
    Par comment_ca dans le forum Oracle
    Réponses: 20
    Dernier message: 14/12/2004, 13h39
  4. Problème de chargement de police de caractères
    Par Laurent Gomila dans le forum Windows
    Réponses: 4
    Dernier message: 19/08/2004, 17h11
  5. problème de lecture base de registre
    Par pafounet3 dans le forum MFC
    Réponses: 10
    Dernier message: 31/12/2003, 15h06

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo