1. Développement de la base de données
1.1 Données et gestion des données
Qu'est-ce qu'une information ?
L'information fait référence à la réponse à la manière d'être ou à l'état de mouvement du monde réel.
Qu'est-ce que les données ?
Les données font référence à des symboles physiques stockés sur un certain support qui peut être reconnu ;
le concept de données s'est considérablement élargi dans le domaine du traitement des données, comprenant non seulement des données sous forme de texte composé de caractères, mais également d'autres types de données ( tels que l'audio, la vidéo, etc.)
la relation entre l'information et les données :
l'information et les données sont interdépendantes, les données sont le support de l'information et l'information est la connotation des données ;
le traitement des données fait référence au processus de conversion mutuelle entre les données et l'information Du
point de vue du traitement des données, l'information est un type de données qui a été traité sous une forme spécifique.
Traitement des données
Le cœur du traitement des données est la technologie de gestion des données, dans laquelle la technologie de gestion des données fait référence à la technologie de classification, d'organisation, de codage, de stockage, de récupération et de maintenance des données.
Le développement de la technologie de gestion des données est passé par plusieurs étapes : étape de la gestion manuelle, étape du système de fichiers, étape du système de base de données.
1.2 Système de base de données
Définition : le système de base de données (DBS) fait référence à la composition du système après l'introduction de la base de données dans l'ordinateur.
Composition : base de données, système d'exploitation, système de gestion de base de données, système d'application de gestion de base de données, administrateur de base de données (DBA), utilisateur
1.3 Modèle de système de base de données
Le système de gestion de base de données stocke et gère les données en fonction du modèle de données.
Le modèle de données doit répondre à trois exigences :
premièrement, il peut simuler de manière plus réaliste le monde réel ;
deuxièmement, il est facile à comprendre pour les gens ;
troisièmement, il est facile à réaliser sur l'ordinateur.
La structure des données, le fonctionnement des données et les contraintes d'intégrité sont les trois éléments qui constituent le modèle de données. Parmi elles, la contrainte d'intégrité des données consiste à entrer dans la base de données afin d'y mettre les données non conformes à la spécification.
Lorsqu'un utilisateur insère, modifie ou supprime des données, le SGBD surveille automatiquement les données selon certaines contraintes, afin que les données qui ne répondent pas aux spécifications ne puissent pas entrer dans la base de données, afin de s'assurer que les données stockées dans la base de données sont correctes, efficace et compatible.
Modèle de données du système de gestion de base de données :
les modèles de données utilisés par le système de gestion de base de données comprennent principalement : le modèle hiérarchique, le modèle de réseau et le modèle relationnel.
Le modèle hiérarchique est une structure arborescente typique, et ses caractéristiques sont :
1. Il y a un et un seul nœud sans nœud parent, et ce nœud est appelé le nœud racine ;
2. Les autres nœuds ont un et un seul nœud parent ;
3 Le même parent Les nœuds enfants d'un nœud sont appelés nœuds frères
4. Les nœuds sans nœuds enfants sont appelés nœuds feuilles.
Le modèle de réseau constitue une structure de réseau plus complexe que le modèle de structure hiérarchique, et ses caractéristiques sont :
1. Plus d'un nœud est autorisé à n'avoir aucun nœud parent
2. Un nœud peut avoir plusieurs nœuds parents ;
La structure logique des données du modèle relationnel est une table à deux dimensions, une ligne est un membre d'objet et chaque colonne est un attribut de l'objet. Ses caractéristiques sont :
1. Les composants de chaque colonne peuvent être du même type de données
2. L'ordre des colonnes peut être arbitraire
3. L'ordre des lignes peut être arbitraire
4. Les composants du tableau sont les plus petits les données qui ne peuvent pas être divisées, c'est-à-dire que les sous-tableaux ne sont pas autorisés dans la table.
Les bases de données relationnelles utilisent un modèle relationnel comme mode d'organisation des données. La base de données relationnelle est reconnue comme le système de gestion de base de données le plus prometteur en raison de sa théorie mathématique stricte, de son utilisation simple et flexible et de sa forte indépendance des données. Elle est devenue le système de gestion de base de données dominant à l'heure actuelle.
1.4 Bases de données communes
Les bases de données courantes sont :
ORACLE, MySQL, SQL Server, Access, Sybase, SQLite
1, ORACLE :
ORACLE est une base de données développée par Oracle Corporation, et est un système de gestion de base de données relationnelle adapté aux grands, moyens et micro-ordinateurs. Il utilise le langage SQL comme son langage de la base de données.
2. MySQL
MySQL est un système de gestion de base de données relationnelle open source à petite échelle. Le développeur est la société suédoise MySQL AB. À l'heure actuelle, MySQL est largement utilisé dans les sites Web de petite et moyenne taille sur Internet. Il a une petite taille, une vitesse rapide , faible coût et spécialité de code source ouvert.
3. Le serveur SQL
est une véritable architecture client/serveur, un logiciel de base de données produit par Microsoft, avec une interface graphique, ce qui rend la gestion du système et la gestion de la base de données plus intuitives/simples, il a une bonne évolutivité et peut s'étendre de l'exécution de type Windows 95/98 ordinateurs aux grands multiprocesseurs exécutant Windows 2000 et d'autres plates-formes.
4. Access
Access est un système de gestion de base de données relationnelle publié par Microsoft. Il combine les deux caractéristiques du moteur de base de données MicrosoftJet et de l'interface utilisateur graphique, et est l'un des programmes système de Microsoft Office. C'est une base de données de bureau, qui ne convient qu'aux applications avec une petite quantité de données. Elle est très bonne et efficace lorsqu'elle traite une petite quantité de données et de bases de données accessibles par un seul ordinateur, mais elle ne peut pas accéder à plus de 4 clients à la fois. le même temps. La base de données Access a une certaine limite. Si les données atteignent environ 100 Mo, il est facile de geler le serveur IIS ou de consommer la mémoire du serveur et de provoquer le plantage du serveur.
5. Sybase
Les produits de base de données Sybase ont principalement trois versions, l'une est la version fonctionnant sous le système d'exploitation UNIX, l'autre est la version fonctionnant sous l'environnement Novell Netware et la troisième est la version fonctionnant sous l'environnement Windows NT. Caractéristiques de la base de données Sybase :
1. Base de données basée sur une architecture client/serveur
2. C'est une base de données véritablement ouverte et facile à transplanter
3. C'est une base de données performante.
1.5 Base de données SQLite
1.5.1 Introduction à la base de données SQLite
SQLite est une base de données relationnelle embarquée open source.La première version est née en mai 2000, et la version la plus récente actuelle est SQLite3.
Adresse de téléchargement : https://www.sqlite.org/download.html
Méthode d'installation (sous Ubuntu)
sudo apt-get install sqlite3
Méthode d'installation (combiné avec C++ sous windows)
Télécharger sqlite-amalgamation-3410200.zip (fichier d'en-tête après décompression), sqlite-dll-win64-x64-3410200.zip et sqlite-dll-win64-x64-3410200.zip Trois fichiers, puis décompressez-les dans le même dossier Sqlite3, voir la figure ci-dessous pour plus de détails (je n'inclus pas le fichier d'en-tête décompressé du premier fichier ici) puis
générez le fichier sqlite.lib à partir du fichier sqlite3.def.Le processus principal est : Ouvrez d'abord le "VS20xx Developer Command Prompt", puis entrez dans la ligne de commande à tour de rôle :
cd D:/Sqlite3
LIB /DEF:sqlite3.def /MACHINE:X64
Vous pouvez obtenir le fichier sqlite.lib, puis vous pouvez opérer étape par étape selon la manière de configurer la bibliothèque.
Caractéristiques de SQLite :
1. Aucune configuration ;
2. Portable ;
3. Compact ;
4. Simple ;
5. Flexible ;
6. Fiable
; 7. Facile à utiliser.
1.5.2 Principes de base des instructions SQL
SQL est l'acronyme de Structured Query Language, et SQL est un langage spécialement utilisé pour communiquer avec les bases de données. Actuellement, SQL est devenu le langage de base de données le plus utilisé. SQL a été adopté par de nombreux produits de système de gestion de base de données commerciaux, et différents systèmes de gestion de base de données ont apporté certaines adaptations et extensions à la spécification SQL dans leur pratique. Par conséquent, le langage SQL entre différents systèmes de gestion de base de données ne peut pas être pleinement utilisé les uns avec les autres.
Type de données SQLite :
les données générales utilisent un type de données statique fixe, tandis que SQLite utilise un type de données dynamique, qui sera automatiquement jugé en fonction de la valeur stockée. SQLite a les cinq types de données de base suivants : 1. entier : entier signé (jusqu'à 64 bits) ; 2. réel : type à virgule flottante représenté par 8 octets ; 3. texte : type de caractère, prenant en charge plusieurs encodages (tels que UTF- 8, UTF-16), taille illimitée ; 4, blob : tout type de données, taille illimitée. BLOB (binary large object) grand objet binaire, utilisant le binaire pour enregistrer les données. 5. Null : indique une valeur nulle.
Instruction SQL pour le fichier de base de données :
1. Créez et ouvrez la base de données : invite sqlite3 .db : lorsque le fichier .db n'existe pas, sqlite créera et ouvrira le fichier de base de données ; lorsque le fichier .db existe, sqlite ouvrira la base de données 2. Quittez la commande base de données : .quit ou .exit
Format d'instruction SQL :
toutes les instructions SQL se terminent par un point-virgule et les instructions SQL ne sont pas sensibles à la casse. Deux signes moins "–" représentent des commentaires. Les opérations de base des données relationnelles incluent principalement : 1. Créer, modifier et supprimer des tables ; 2. Ajouter, modifier et supprimer des lignes ; 3. Rechercher des tables.
1. Créer une table : créer une déclaration
//语法：create table 表名称(列名称1 数据类型，列名称2 数据类型，列名称3 数据类型，...)；
//例子：创建一表格，该表包含3列，列名分别是："id"、"name"、"addr"
//在终端下输入：
sqlite> create tabel persons(id integer, name text, addr text);
2. Créer une table : créer une instruction (définir la clé primaire)
Lors de la conception d'une table avec sqlite, chaque table peut définir manuellement la clé primaire via la clé primaire. Chaque table ne peut avoir qu'une seule clé primaire et les données de la colonne sont définies comme clé primaire. la touche ne peut pas être répétée.
//语法：create table 表名称(
列名称1 数据类型 primary key，
列名称2 数据类型，
列名称3 数据类型，...)；
//例子：创建一表格，该表包含3列，列名分别是："id"、"name"、"addr"
//在终端下输入：
sqlite> create tabel persons(id integer primary key, name text, addr text);
3. Modifier la table
Ajoutez des colonnes à la table existante et modifiez le nom de la table.
//语法： alter table 表名 add 列名 数据类型
sqlite> alter table persons add sex text;
//语法： alter table 表名 rename 表名
sqlite> alter table persons rename stu;
4. Supprimer la table
est utilisé pour supprimer la table (la structure, les attributs et l'index de la table seront également supprimés)
//语法： drop table 表名；
sqlite> drop table persons;
5. Insérez une nouvelle ligne : l'instruction d'insertion dans (toutes les affectations)
attribue des valeurs à toutes les colonnes d'une ligne.
//语法：insert into 表名 values(列值1，列值2，列值3，列值4，...);
//注意，当列值为字符串时要加上' '号
sqlite> create table persons (id integer, name text, addr text);
sqlite> insert into persons values(1,'lucky','beijing');
6. Modifiez les données dans le tableau : l'instruction de mise à jour
utilise où trouver une ou plusieurs lignes en fonction des conditions de correspondance, et modifie le nombre de colonnes dans la ligne correspondante dans le tableau en fonction des résultats de la recherche (la colonne à modifier est spécifié par le nom de la colonne).
//语法：update 表名 set 列1 = 值1 [,列2 = 值2,...][匹配条件]
//匹配：where子句
// where子句用于规定匹配的条件。
//操作符 描述
// = 等于
// <> 不等于
// > 大于
// < 小于
// >= 大于等于
// <= 小于等于
//匹配条件语法： where 列名 操作符 列值
sqlite> update persons set id=2, addr = 'tianjin' where name = 'peter';
7. Supprimez les données de la table : l'instruction de suppression
utilise où trouver une ou plusieurs lignes en fonction des conditions de correspondance et supprime les lignes trouvées dans la table en fonction des résultats de la recherche.
//语法：delete from 表名 [匹配条件]
//注意：当表中由多列、多行符合匹配条件时会删除相应的多行
sqlite> delete from person where name = 'peter';
8. Requête : L'instruction select (de base)
est utilisée pour sélectionner des données dans la table, et le résultat est stocké dans une table de résultats (appelée ensemble de résultats)
//语法1：select * from 表名 [匹配条件]；
//语法2：select 列名1[,列名2，...] from 表名 [匹配条件];
//提示：星号(*)是选取所有列的通配符
sqlite> select * from persons;
sqlite> select name from person where id = 1;
8. Syntaxe des conditions de correspondance : (améliorée)
La base de données fournit une multitude d'opérateurs avec des clauses where pour obtenir une variété de méthodes de correspondance.
Tels que : (1) dans l'opérateur (2) et l'opérateur (3) ou l'opérateur (4) entre et l'opérateur (5) comme l'opérateur (6) pas l'opérateur
// in允许我们在where子句中规定多个值
// 匹配条件语法：where 列名 in (列值1，列值2，...)
// 例：1、select * from 表名 where 列名 in (值1，值2，...);
// 2、select 列名1[,列名2,...] from 表名 where 列名 in(列值1,列值2，...);
sqlite> select * from persons where id in (1,2);
sqlite> select name from persons where id in (1,2);
// and 可在where子语句中把两个或多个条件结合起来(多个条件之间是与的关系)
// 匹配条件语法：where 列1 = 值1 [and 列2 = 值2 and...]
// 例： 1、select * from 表名 where 列1 = 值1 [and 列2 = 值2 and ...];
// 2、select 列名1[,列名2,...] from 表名 where 列1 = 值1 [and 列2 = 值2 and ...];
sqlite> select * from persons where id = 1 and addr = 'beijing';
sqlite> select name from persons where id = 1 and addr = 'beijing';
//or可在where子语句中把两个或多个条件结合起来(多个条件之间是或的关系)
// 匹配条件语法：where 列1 = 值1 [or 列2 = 值2 or...]
// 例： 1、select * from 表名 where 列1 = 值1 [or 列2 = 值2 or ...];
// 2、select 列名1[,列名2,...] from 表名 where 列1 = 值1 [or 列2 = 值2 or ...];
sqlite> select * from persons where id = 1 or addr = 'beijing';
sqlite> select name from persons where id = 1 or addr = 'beijing';
//操作符between A and B会选介于A、B之间的数据范围。这些值可以是数值、文本或日期
//注意：不同的数据库对between A and B操作符的处理方式是有差异的（有的包含A,B，有的不包含A,B,有的只包含一边）
// 匹配条件语法：where 列名 between A and B
// 例： 1、select * from 表名 where 列名 between A and B;
// 2、select 列名1[,列名2,...] from 表名 where 列名 between A and B;
// 注：匹配字符串时会以ascii顺序匹配
sqlite> select * from persons where id between 1 and 3;
sqlite> select name from persons where id between 1 and 3;
//like 用于模糊查找
// 匹配条件语法：where 列名 like 列值
// 若列值为数字，相当于列名=列值
// 若列值为字符串，可以用通配符“%”代表缺少的字符（一个或多个）
sqlite> select * from persons where id like 3;
sqlite> select * from persons where addr like "%jing%";
//not 可取出原结果集的补集
//匹配条件语法：where 列名 not in 列值 等
//例： 1、where 列名 not in (列值1,列值2,...);
// 2、where not(列1 = 值1 [and 列2 = 值2 and...])
// 3、where not(列1 = 值1 [or 列2 = 值2 or...])
// 4、where 列名 not between A and B
// 5、where 列名 not like 列值
// order by 语句根据指定的列对结果集进行排序(默认按照升序对结果集进行排序，可使用desc关键字按照降序对结果集进行排序)
// 例：升序
// select * from 表名 order by 列名
// 降序
// select * from 表名
Neuf, copiez le tableau et modifiez la structure du tableau
//1、复制一张表
create table tbl2 as select * from tbl1;
//2、复制一张表的部分内容
create table tbl2 as select * from tbl1 where id =104;
//3、修改表的结构
//第一步：创建新表
create table ntbl(id interger,name text,addr text);
//第二步：导入数据(如果有主键，要注意数据不要重复)
insert into ntbl(id,name,addr) select id,name,addr from tbl1;
//第三步：修改表名
alter table ntbl rename tbl1;
10. Transactions
Les transactions peuvent être lancées à l'aide de la commande BEGIN TRANSACTION ou d'une simple commande BEGIN. Ces transactions continuent généralement à s'exécuter jusqu'à ce que la prochaine commande COMMIT ou ROLLBACK soit rencontrée. Cependant, les transactions sont également annulées lorsque la base de données est fermée ou qu'une erreur se produit. Voici la syntaxe simple pour démarrer une transaction :
Dans SQLite, par défaut, chaque instruction SQL est sa propre transaction. begin : démarre une transaction et toutes les opérations suivantes peuvent être annulées commit : confirme toutes les commandes après le début rollback : annule toutes les opérations après le début Exemples : sqlite->begin; sqlite->delete from persons
1.5.3 Instruction SQL avancée
1. Fonctions et
fonctions d'agrégation : les instructions SQL prennent en charge l'utilisation de fonctions pour traiter les données. Les fonctions sont généralement exécutées sur les données, ce qui facilite la conversion et le traitement des données.
Les fonctions de traitement de texte couramment utilisées sont : length() renvoie la longueur de la chaîne lower () convertit la chaîne en minuscules upper() convertit la chaîne en majuscules Utilisez des fonctions d'agrégation pour récupérer des données pour l'analyse et la génération de rapports avg() renvoie la valeur moyenne d'une colonne count() renvoie le nombre de lignes dans une colonne max() renvoie la valeur maximale d'une colonne min() renvoie la valeur minimale de une colonne La valeur sum() renvoie la somme des valeurs d'une certaine colonne.2. Regroupement de données regrouper en regroupant les données afin qu'un sous-ensemble du contenu du tableau puisse être résumé, souvent utilisé en conjonction avec des fonctions d'agrégation. Par exemple, interrogez le nombre de personnes dans chaque classe, le nombre moyen, etc. Utilisation : sélectionnez le nom de la colonne 1[, le nom de la colonne 2,...] dans le groupe de noms de table par nom de colonne
sqlite>select class,count(*) from persons group by class;
3. Regroupement de filtres
En plus d'utiliser le groupe par pour regrouper les données, vous pouvez également utiliser le fait de savoir quels groupes sont inclus et quels groupes sont exclus.
Utilisation : sélectionnez le nom de la fonction (nom de colonne 1 [), nom de colonne 2,...] à partir du nom de la table, groupez par nom de colonne ayant une valeur limite de nom de fonction
//查看班级平均分大于90的班级
sqlite>select class,avg(score) from persons group by class having avg(score) >= 90
4. Gestion des contraintes Règles d'insertion ou de traitement des données de la base de données Classification commune des
contraintes , contrainte contrainte uniqueprimaire
: vérification , colonne de temps de modification, etc. La clé primaire doit être générée automatiquement par l'ordinateur (pour garantir l'unicité) Syntaxe : créer une table nom de table ( clé primaire de type de données nom de colonne 1, type de données nom de colonne 2, type de données nom de colonne 3,. ..);
Contrainte d'unicité :
utilisée pour garantir que les données d'une colonne (ou d'un groupe de colonnes) sont uniques, similaires à la clé primaire, mais différentes de la clé primaire. Une table peut
contenir plusieurs contraintes d'unicité, mais une seule
contrainte d'unicité de clé primaire la colonne peut être modifiée ou mise à jour
lors de la création d'une table, définissez la syntaxe par unique
: create table table name (column name 1 data type unique[, column name 2 data type unique,...]);
Contraintes de vérification :
utilisées pour garantir que les données d'une colonne (ou d'un ensemble de colonnes) satisfont à un ensemble de conditions spécifiées.
Spécifiez la plage, vérifiez la plage maximale ou minimale et implémentez
le nom de la table de création de table (vérification du type de données du nom de la colonne (instruction de jugement)) via la vérification ;
5.
Le concept de table de jonction (opération multi-tables) : lors de la sauvegarde des données, toutes les données ne sont souvent pas stockées dans une table, mais stockées dans plusieurs tables. La table de jonction consiste à interroger les données de plusieurs tables. Il n'est pas propice à la décomposition des données dans une table, et il est facile de faire apparaître plusieurs fois les mêmes données, gaspillant de l'espace de stockage ; il est plus intuitif d'utiliser une table de jonction pour visualiser chaque donnée, ce qui facilite le traitement des données .
Par exemple, les résultats des tests annuels des étudiants et les informations personnelles des étudiants sont fondamentalement fixes (y compris le numéro d'étudiant, le nom, l'adresse, etc.); mettre toutes les informations dans le même tableau entraînera inévitablement la duplication des informations de base telles que le numéro d'étudiant.
Avantages des sous-tableaux :
stockage séparé des informations et des notes des étudiants, gain de place, traitement simple et efficacité accrue, en particulier lors du traitement de grandes quantités de données ;
en utilisant une base de données relationnelle pour stocker les données, la conception de chaque table est très importante, bonne table design , peut simplifier le traitement des données, améliorer l'efficacité et améliorer la robustesse de la base de données.
Utiliser join :
toutes les tables à joindre par l'instruction select et leur clé
Instructions couramment utilisées :
sélectionnez le nom de la colonne 1, le nom de la colonne 2, ... de la table 1, de la table 2... où l'instruction de jugement ;
sélectionnez * de tbl1, tbl2 où tbl1.id = tbl2.id
sqlite> select name, addr, score, year from persons, grade where persons.id = grade.id and name = 'lucy';
6. Les vues (tables virtuelles)
réutilisent les instructions SQL ;
simplifient les opérations SQL complexes (telles que la requête multi-tables précédente)
sqlite> select name, addr, score, year from persons, grade where persons.id = grade.id and name = 'lucy';
Utilisez une vue pour encapsuler l'intégralité de la requête dans une table virtuelle nommée PersonGrade, ce qui simplifie l'instruction SQL de la requête :
sqlite> create view PersonGrade as select name, addr, score, year from persons, grade where persons.id = grade.id and name = 'lucy';
sqlite> select * from PersonGrade;
Supprimer une vue : Syntaxe : drop view nom de la vue ; résumé : 1. La vue ne contient pas de données, donc chaque fois que la vue est utilisée, la requête doit effectivement être exécutée ; 2. La vue est équivalente à l'instruction SQL after as when 3. Récupérez la vue à partir des informations de résultat renvoyées (vue), qui sont identiques à celles de la table
7.
Concept de déclencheur : le déclencheur de SQLite est la fonction de rappel de la base de données, qui exécutera automatiquement l'appel lorsque l'événement de base de données spécifié se produit ; 1. Ce n'est que lorsque l'opération de suppression, d'insertion ou de mise à jour est exécutée qu'il déclenchera et exécutera l'événement spécifié. ou plusieurs instructions SQL. (Par exemple, des déclencheurs peuvent être définis pour supprimer automatiquement les informations relatives à lucy dans le tableau des notes lors de la suppression des informations de lucy dans le tableau des personnes) 2. Les déclencheurs sont souvent utilisés pour assurer la cohérence des données , et chaque fois qu'un tableau est mis à jour ou supprimé, il sera être enregistré Écrire dans la table de journal Créer un déclencheur : Syntaxe : créer un déclencheur nom du déclencheur [avant/après] [insérer|mettre à jour|supprimer] sur le nom de la table début de l'instruction ; fin ; Par exemple : description : lors de l'exécution : supprimer des personnes où id = 1 ; lorsqu'une instruction est faite, un événement est déclenché et l'instruction SQL entre le début et la fin (c'est-à-dire la fonction de rappel) est exécutée. Remarque : old.id est équivalent à persons.id, mais persons.id ne peut pas être écrit ici, et old.id représente l'id de la ligne supprimée ( id représente la colonne associée des deux tables)
create trigger tg_delete after delete on persons begin delete from grade where id = old.id;
8. Les opérations de journal SQLite et les opérations d'index qui améliorent l'efficacité des requêtes
sont écrites dans les journaux : sqlite> create table log (time text, data text);
notez ici que deux fonctions time('now') et date('now') sont utilisées lors de l'insertion. Par exemple
: sqlite> insert into log values(time('now'),date('now'));
souvent utilisé conjointement avec des déclencheurs, utiliser Pour enregistrer l'heure de changement de fonctionnement.
Index d'optimisation de requête : une grande quantité de données est souvent stockée dans la base de données et la méthode par défaut d'une requête ordinaire consiste à appeler une analyse séquentielle. Par exemple, une telle requête : select * from table where id = 10000 ; s'il n'y a pas d'index, la table entière doit être parcourue jusqu'à ce que la ligne avec l'ID égal à 10000 soit trouvée. Afin d'améliorer l'efficacité de la requête, vous pouvez utiliser l'index ;
qu'est-ce que l'index ? Un index est une structure qui trie les valeurs d'une ou plusieurs colonnes d'une table de base de données. À l'aide d'un index, vous pouvez accéder rapidement à des informations spécifiques dans la table de données ; un index est un tri approprié, optimisé par un certain algorithme, donc que le nombre de recherches est bien moindre ; Inconvénients : les données d'indexation peuvent occuper beaucoup d'espace de stockage, toutes les données ne sont donc pas adaptées à l'indexation ; l'indexation améliore les performances des opérations de récupération, mais réduit les performances d'insertion, de modification, et suppression ; création d'un index : Syntaxe : créer un index nom de l'index sur le nom de la table (nom de la colonne) ; afficher l'index : .indices supprimer l'index : supprimer le nom de l'index de l'index ; saisir dans le terminal (la colonne id crée l'index et trie) : créer un index : 1. Sur la colonne comme clé primaire ; 2, Créer des index sur les colonnes qui doivent souvent être triées ; 3, Créer des index sur les colonnes qui sont souvent utilisées dans la clause WHERE pour accélérer le jugement des conditions.
create index id_index on persons(id);
Évitez d'utiliser des index : 1. La quantité de données dans la table n'est pas importante ; 2. La plupart des opérations sur la table ne sont pas des requêtes ; 3. Un grand nombre de valeurs NULL apparaissent
1.6 Programmation SQLite C
1.6.1 Fonctions d'ouverture et de fermeture de la base de données
int sqlite3_open(char *db_name, sqlite3 **db);
功能：
打开数据库
参数：
db_name: 数据库文件名，若文件名包含ASCII码表范围之外的字符，则其必须是utf-8编码
sqlite3: 数据库标识，此结构体为数据库操作句柄。通过此句柄可对数据库文件进行相应操作。
返回值：
成功返回SQLITE_OK,失败返回非SQLITE_OK
int sqlite3_close(sqlite3 *db);
功能：
关闭数据库、释放打开数据库时申请的资源
参数：
db: 数据库的标识
返回值：
成功返回SQLITE_OK
失败返回非SQLITE_OK
注意：
sqlite3使用了两个库:pthread、dl，故链接时应加上-lpthread和-ldl
1.6.2 La méthode d'exécution de l'instruction SQL dans sqlite3 (méthode de rappel)
sqlite3_exec函数：
int sqlite3_exec(sqlite3 *db,const char *sql,exechandller_t callback,void *arg,char **errmsg);
功能：
执行sql执向的SQL语句，若结果集不为空，函数会调用函数指针callback所指向的函数。
参数：
db: 数据库的标识
sql: SQL语句(一条或多条)，以‘;’结尾
callback: 是回调函数指针，当这条语句执行之后，sqlite3会去调用你提供的这个函数
arg： 当执行sqlite_exec的时候传递给回调函数的参数；
errmsg： 存放错误信息的地址，执行失败后可以查阅这个指针；
打印错误信息方法：printf("%s\n",errmsg);
返回：
回调函数指针：
typedef int (*exechandller_t)(void *para,int n_column,char ** column_value,char **column_name);
功能：
此函数由用户定义，当sqlite3_exec函数执行sql语句后，结果集不为空时，sqlite3_exec函数会自动调用此函数，每次调用此函数时会把结果集的一行信息传递给此函数。
参数：
para: sqlite3_exec传给此函数的参数，para为任意数据类型的地址；
n_column: 结果集的列数；
column_value: 指针数据的地址，其存放一行信息中各个列值的首地址；
column_name:指针数据的地址，其存放一行信息中各个列值对应列名的首地址
返回值：
若为非0值，则通知sqlite3_exec终止回调
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include "sqlite3.h"
int loadinfo(void *data,int col, char **col_val,char **name){
static int row = 1;
printf("row= %d\n",row++);
for(int i = 0; i < col; i++)
{
printf("%s = %s \n",name[i], val[i]);
}i
return SQLITE_OK;
}
int main(int argc, char ** argv){
sqlite3 *db = NULL;
int ret;
char *err = NULL;
char *sql;
int arg = 33;
ret = sqlite3_open("stu.db", &db);
if(ret != SQLITE_OK){
printf("open error\n");
return -1;
}
sql = "insert into info values(120,'zz','ts')";
sqlite3_exec(db, sql, loadinfo,&arg,&err);
if(err){
printf("err:%s\n",err);
}
sqlite3_close(db);
return 0;
}
1.6.3 La méthode d'exécution de l'instruction SQL dans sqlite3 (méthode sans rappel)
sqlite3_get_table函数
int sqlite3_get_table(sqlite3 *db,const char *sql,char ***resultp,int *nrow,int *ncolumn,char **errmsg);
功能：
执行sql指向的sql语句，函数将结果集相关的数据的地址保存在函数的参数中。
参数：
db: 数据库的标识；
sql: SQL语句(一条或多条)，以’;‘结尾；
resultp: 指针数据的地址，其记录了结果集的数据。内存布局:先依次存放各列的列名，然后是每一行各列的值
nrow: 结果集的行数(不包含列名)
ncolumn: 结果集的列数
errmsg: 错误信息
sqlite3_free_table函数：
void sqlite3_free_table(char (** resultp);
功能：
释放sqlite3_get_table分配的内容
参数：
结果集数据的首地址
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include "sqlite3.h"
int main(int argc, char ** argv){
sqlite3 *db = NULL;
int ret;
char *err = NULL;
char *sql;
char **result;
int row,col;
ret = sqlite3_open("stu.db", &db);
if(ret != SQLITE_OK){
printf("open error\n");
return -1;
}
sql = "insert into info values(120,'zz','ts')";
sqlite3_get_table(db, sql, &result,&row,&col,&err);
if(err){
printf("err:%s\n",err);
sqlite3_close(db);
return -1;
}
//处理读取到的数据
for(int i = 0; i < row * col; i++){
printf("result[%d] = %s\n", i , result[i]);
}
sqlite3_free_table(result);
sqlite3_close(db);
return 0;
}