Contenu lié à SQLLite

Hmm. . . Connaissance commune compilée il y a quelques temps :

SQLLiteStudy Notes

SQLite, est un outil léger La base de données est un système de gestion de base de données relationnelle conforme à ACID et contenu dans une bibliothèque C relativement petite. Il peut prendre en charge les systèmes d'exploitation courants tels que Windows/Linux/Unix et peut être combiné avec de nombreux langages de programmation, tels que Tcl, C#, PHP, Java, etc. Sa vitesse de traitement est très rapide.

1. Opérations de base

Créer un tableau :

Mots clés : AUTOINCREMENT peut être utilisé pour incrémenter automatiquement la valeur d'une certaine colonne. Il ne peut être utilisé que pour les champs en plastique. Vous pouvez ajouter ce mot-clé lors de la création du tableau

Supprimer le tableau :

Insérer de nouvelles données dans le tableau

ou

La deuxième façon d'écrire doit garantir que l'ordre des valeurs est cohérent avec l'ordre des colonnes dans le tableau

Après avoir interrogé la table

Vous pouvez effectuer une requête conditionnelle avec WHERE, "*" signifie toutes les colonnes de la table de requête, ou vous pouvez le faire

--sous-requête ou requête interne ou requête imbriquée, intégrée dans la sous-requête Where dans une autre requête SQL spéciale. Vous devez interroger la phrase.

Voici plusieurs règles que les sous-requêtes doivent suivre :

· Les sous-requêtes doivent être placées entre parenthèses.

·  Une sous-requête ne peut avoir qu'une seule colonne dans la clause SELECT sauf s'il y en a une dans la requête principale Plusieurs colonnes, par rapport aux colonnes sélectionnées de la sous-requête.

· ORDER BY ne peut pas être utilisé dans une sous-requête, bien que la requête principale puisse utiliser ORDER BY . Vous pouvez utiliser GROUP BY dans les sous-requêtes, qui a la même fonction que ORDER BY .

·  la sous-requête renvoie plus d'une ligne et ne peut être utilisée qu'avec des opérateurs à valeurs multiples, tels que IN opérateur. L'opérateur

· BETWEEN ne peut pas être utilisé avec des sous-requêtes, cependant, BETWEEN peut être utilisé dans les sous-requêtes.

Modifier les données du tableau

Supprimer les données du tableau

2. Opérateurs

Supposer la variable a=10, variable b. =20, puis :

opérateur arithmétique

opérateur	Description	Instance
+	Ajout - Ajouter les valeurs des deux côtés de l'opérateur	a + b en obtiendra 30
-	Soustraction - Opérande gauche moins opérande droit	a - b obtiendra -10
*	Multiplication - Multiplier le les valeurs des deux côtés de l'opérateur	a * b obtiendront 200
/	Division - Opérande gauche divisé par l'opérande droit	b/a obtiendra 2
%	Modulo - Le reste obtenu après division de l'opérande de gauche par l'opérande de droite	b % a donnera 0

Opérateurs de comparaison

Opérateurs	Description	Instance
==	Vérifie si les valeurs des deux opérandes sont égales. Si elles sont égales, la condition est vraie.	(a == b) n'est pas vrai.
=	Vérifiez la valeur des deux opérandes. ils sont égaux, si c’est le cas, la condition est vraie.	(a = b) n'est pas vrai.
!=	Vérifiez si les deux opérandes les valeurs sont égales, sinon la condition est vraie.	(a != b) est vrai.
a8093152e673feb7aba1828c43532094	Vérifier si deux opérations les valeurs des nombres sont égales, sinon la condition est vraie.	(a a8093152e673feb7aba1828c43532094 b) est vrai.
>	Vérifiez la valeur de la gauche opérande Est-il supérieur à la valeur de l’opérande de droite ? Si oui, la condition est vraie.	(a > b) n'est pas vrai.
af6d527abe773c2d2495fb88c78ed14d=	Vérifiez l'opérande de gauche Si la valeur est supérieure ou égale à la valeur de l'opérande de droite, si c'est le cas, la condition est vraie.	(a >= b) n'est pas vrai.
bbb99ad2805967cccfa5530f134deb19	Vérifie si la valeur de l'opérande de gauche n'est pas supérieure à la valeur de l'opérande de droite, si c'est le cas alors la condition est vraie.	(a !> b) est vrai.

Opérateurs logiques

Opérateurs	Description
AND	AND opérateur Plusieurs conditions sont autorisé dans la clause WHERE d'une instruction SQL . L'opérateur
ENTRE	ENTRE est utilisé Recherche une valeur dans une plage de valeurs dans une plage minimale et maximale donnée.
EXISTE	EXISTE Les opérateurs sont utilisés pour rechercher l'existence de lignes dans une table spécifiée qui remplissent certaines conditions.
EN	EN Les opérateurs sont utilisés pour comparer une valeur à une liste de valeurs spécifiée.
PAS DANS	DANS , utilisé pour comparer une valeur avec des valeurs qui ne figurent pas dans une liste spécifiée.
AIMEZ	AIMEZ Les opérateurs sont utilisés pour comparer une valeur avec des valeurs similaires à l'aide d'opérateurs génériques.
GLOB	GLOB Les opérateurs sont utilisés pour comparer une valeur avec des valeurs similaires à l'aide d'opérateurs génériques. GLOB diffère de LIKE en ce qu'il est sensible à la casse.
NON	NON est Le l’opposé de l’opérateur logique utilisé. Par exemple, NOT EXISTS, NOT BETWEEN, NOT IN, etc. C'est l'opérateur de négation. L'opérateur
OU	OU est utilisé Pour combiner plusieurs conditions dans la clause WHERE d'une instruction SQL .
EST NULL	NULL Opérateur utilisé pour comparer une valeur avec une valeur NULL .
IS	IS avec = Similaire.
N'EST PAS	N'EST PAS opération Le symbole est similaire à != .
||	Concaténer deux chaînes différentes pour obtenir une nouvelle chaîne .
UNIQUEL'opérateur	UNIQUE recherche chaque ligne de la table spécifiée, garantissant l'unicité (pas de doublons).

1. Opérateurs de bits

Le tableau suivant répertorie les opérations sur les bits prises en charge par le symbole de langage SQLite . Supposons que la variable A=60 et la variable B=13, alors :

运算符	描述	实例
&	如果同时存在于两个操作数中，二进制 AND 运算符复制一位到结果中。	(A & B) 将得到 12，即为 0000  1100
|	如果存在于任一操作数中，二进制 OR 运算符复制一位到结果中。	(A | B) 将得到 61，即为 0011  1101
~	二进制补码运算符是一元运算符，具有"翻转"位效应，即0变成1，1变成0。	(~A ) 将得到 -61，即为 1100 0011，一个有符号二进制数的补码形式。
205bde70aa77c2774fc560ace1ececa7>	二进制右移运算符。左操作数的值向右移动右操作数指定的位数。	A >> 2 将得到 15，即为 0000  1111

OpérateurDescription Instance & L'opérateur binaire AND copie un bit dans le résultat s'il est présent dans les deux opérandes. (A & B) obtiendra 12, soit 0000 1100 | S'il est présent dans l'un ou l'autre des opérandes, l'opérateur binaire OR en copie un dans le résultat . (A | B) obtiendra le 61, soit 0011 1101 ~L'opérateur complément à deux est un opérateur unaire avec " Effet de bit Flip", c'est-à-dire que 0 devient 1 et 1 devient 0. (~A ) obtiendra -61, soit 1100 0011, le complément d'un nombre binaire signé forme de code. b8f2e3bf68b279fe466c06d049147410> Opérateur de décalage binaire à droite. La valeur de l'opérande de gauche est décalée vers la droite du nombre de bits spécifié par l'opérande de droite. A >> 2 obtiendra 15, soit 0000 1111

3. Clauses rarement utilisées

1. GLOB

Dans notre SQL quotidien, GLOB n'est pas couramment utilisé. La fonction de GLOB est fondamentalement la même que celle de LIKE. est sensible à la casse GLOB. L'astérisque (*) représente zéro, un ou plusieurs chiffres ou caractères. Le point d'interrogation (?) représente un seul chiffre ou caractère.

Comparaison avec LIKE : les GLOB * ont le même effet que les %

GLOB de LIKE ? Conformément à la fonction de LIKE

2. HAVING

Spécifie le filtrage conditionnel. Il semble que nous puissions penser à OÙ. Alors, quelle est la différence entre OÙ et HAVING ? En fait, la différence entre les deux est assez grande.

(1) La clause HAVING permet de spécifier des conditions pour filtrer les résultats groupés qui apparaîtront dans le résultat final.

(2) La clause WHERE définit les conditions sur les colonnes sélectionnées, tandis que la clause HAVING définit les conditions sur le regroupement créé par la clause GROUP BY.

(3)HAVING ne peut être utilisé qu'avec l'instruction SELECT.
(4)HAVING est généralement dans la clause GROUPBY utiliser.
(5)Si la clause GROUPBY n'est pas utilisée , Ensuite, HAVING se comporte de la même manière que la clause WHERE.

(6) Dans une requête, la clause HAVING doit être placée après la clause GROUP BY et avant la clause ORDER BY.

--Par exemple : table de requête table pour interroger le nombre de personnes dans chaque classe qui ont plus de 20 ans et dont le sexe est masculin

sélectionnezCOUNT(*)comme'>20nombre d'années',classédeTableau1 oùsex='Homme'groupeparclasse,âge ayantage>20

-- doit être noté : lorsqu'il contient également la clause Where , groupby clause , ayant clause et fonction d'agrégation, l'ordre d'exécution est le suivant :

-- exécute la clause Where pour trouver les données qui remplissent les conditions

--Utilisez le groupeby clause pour regrouper les données ; groupe Les groupes formés par la clause by exécutent une fonction d'agrégation pour calculer la valeur de chaque groupe, enfin, utilisez la clause have ; pour supprimer les groupes qui ne remplissent pas les conditions. Chaque élément de la clause

--having

doit également apparaître dans la liste select. Il existe certaines exceptions de base de données, telles que Oracle.

--having

et la clause Where peuvent être utilisées pour définir des restrictions afin que les résultats de la requête répondent à certaines conditions. . La clause

--having

restreint les groupes, pas les lignes. Les fonctions d'agrégation ne peuvent pas être utilisées dans la clause Where, mais elles peuvent être utilisées dans la clause Have.

四、Distinct 关键字

SQLite 的 DISTINCT 关键字与 SELECT 语句一起使用，来消除所有重复的记录，并只获取唯一一次记录。

有可能出现一种情况，在一个表中有多个重复的记录。当提取这样的记录时，DISTINCT 关键字就显得特别有意义，它只获取唯一一次记录，而不是获取重复记录。

五、约束

约束是在表的数据列上强制执行的规则。这些是用来限制可以插入到表中的数据类型。这确保了数据库中数据的准确性和可靠性。

约束可以是列级或表级。列级约束仅适用于列，表级约束被应用到整个表。

以下是在 SQLite 中常用的约束。

·          NOT NULL 约束：确保某列不能有 NULL 值。

·          DEFAULT 约束：当某列没有指定值时，为该列提供默认值。

·          UNIQUE 约束：确保某列中的所有值是不同的。

·          PRIMARY Key 约束：唯一标识数据库表中的各行/记录。

·          CHECK 约束：CHECK 约束确保某列中的所有值满足一定条件。

六、SQLite Joins

SQLite 的 Joins 子句用于结合两个或多个数据库中表的记录。JOIN 是一种通过共同值来结合两个表中字段的手段。

SQL 定义了三种主要类型的连接：

·          交叉连接 - CROSS JOIN

·          内连接 - INNER JOIN

·          外连接 - OUTER JOIN

1、交叉连接CROSS JOIN

交叉连接(CROSSJOIN)没有WHERE 子句，它返回连接表中所有数据行的笛卡尔积，其结果集合中的数据行数等于第一个表中符合查询条件的数据行数乘以第二个表中符合查询条件的数据行数。由于交叉连接（CROSS JOIN）有可能产生非常大的表，使用时必须谨慎，只在适当的时候使用它们。

2、内连接inner join

内连接的结果是从两个或者两个以上的表的组合中挑选出符合连接条件的数据。如果数据无法满足连接条件则将其丢弃。在内连接中，参与连接的表的地位是平等的。

内连接查询操作列出与连接条件匹配的数据行，它使用比较运算符比较被连接列的列值。内连接分三种：

1)等值连接：在连接条件中使用等于号(=)运算符比较被连接列的列值，其查询结果中列出被连接表中的所有列，包括其中的重复列。

2)不等连接： 在连接条件使用除等于运算符以外的其它比较运算符比较被连接的列的列值。这些运算符包括>、>=、816ff14aff4448eec8a656c2ab5ef5de、!<和a8093152e673feb7aba1828c43532094。

3)自然连接：在连接条件中使用等于(=)运算符比较被连接列的列值，但它使用选择列表指出查询结果集合中所包括的列，并删除连接表中的重复列。

3、外连接

外连接（OUTERJOIN）是内连接（INNER JOIN）的扩展。虽然 SQL标准定义了三种类型的外连接：LEFT、RIGHT、FULL，但 SQLite 只支持 左外连接（LEFT OUTER JOIN）。外连接（OUTER JOIN）声明条件的方法与内连接（INNER JOIN）是相同的，使用 ON、USING 或 NATURAL 关键字来表达。最初的结果表以相同的方式进行计算。一旦主连接计算完成，外连接（OUTER JOIN）将从一个或两个表中任何未连接的行合并进来，外连接的列使用 NULL值，将它们附加到结果表中。

七、unions子句

1、SQLite的 UNION 子句/运算符用于合并两个或多个 SELECT 语句的结果，不返回任何重复的行。

Pour utiliser UNION, le nombre de colonnes sélectionnées par chaque SELECT doit être le même, le même nombre d'expressions de colonnes, le même type de données et assurez-vous qu'elles ont le même ordre, mais elles ne doivent pas nécessairement l'être. la même longueur.

2. Clause UNIONALL

L'opérateur UNION ALL est utilisé pour combiner les résultats de deux instructions SELECT, y compris les lignes en double.

Les règles qui s'appliquent à UNION s'appliquent également à l'opérateur UNION ALL.

8. Déclencheurs

Le déclencheur SQLite (Trigger) est la fonction de rappel de la base de données, qui s'exécutera/appellera automatiquement lorsque l'événement de base de données spécifié se produit. Voici les points clés concernant les déclencheurs de SQLite :

• Les déclencheurs de SQLite peuvent être spécifiés pour se déclencher lorsqu'un DELETE, INSERT ou UPDATE se produit dans une table de base de données spécifique, ou lorsqu'ils sont déclenchés lorsqu'un ou plusieurs les colonnes de la table spécifiée sont mises à jour.

• SQLite ne prend en charge que les déclencheurs FOR EACH ROW (Triggers), et non les déclencheurs FOR EACH STATEMENT (Triggers). Par conséquent, la spécification explicite de FOR EACH ROW est facultative.

• Les clauses WHEN et les actions de déclenchement peuvent accéder aux éléments de ligne qui sont insérés, supprimés ou mis à jour à l'aide de références de la forme NEW.column-name et OLD.column-name , où column -name est le nom de la colonne de la table associée au déclencheur.

• Si une clause WHEN est fournie, l'instruction SQL est exécutée uniquement pour les lignes spécifiées où la clause WHEN est vraie. Si aucune clause WHEN n'est fournie, l'instruction SQL est exécutée pour toutes les lignes.

• Le mot-clé BEFORE ou AFTER détermine quand l'action déclencheur est exécutée, que ce soit avant ou après l'insertion, la modification ou la suppression de la ligne associée.

• Lorsque la table associée au déclencheur est supprimée, le déclencheur (Trigger) est automatiquement supprimé.

• La table à modifier doit exister dans la même base de données que la table ou la vue à laquelle le déclencheur est attaché, et seul le nom de la table doit être utilisé, et non la base de données.nom de la table.

• Une fonction SQL spéciale RAISE() peut être utilisée pour déclencher des exceptions levées dans le programme.

Exemple :

SELECT name FROM sqlite_master WHEREtype = 'trigger';Vous pouvez afficher tous les déclencheurs

pour chaque ligne est déclenché une fois à chaque fois que l'instruction d'opération affecte une ligne, c'est-à-dire qu'elle est déclenchée lorsque 10 lignes sont supprimées 10 fois, et pour chaque état est déclenché une fois par instruction d'opération, et parfois des lignes non affectées sont également exécutées. sqlite implémente uniquement le déclenchement de pour chaque ligne . quand et pour chaque ligne l'utilisation est comme ceci :

CREATETRIGGER trigger_name

APRÈS MISE À JOUR DE L'ID SUR la table_1

POUR CHAQUE LIGNE

QUAND nouveau.id>30

BEGIN

UPDATEtable_2 SET id=nouveau.id WHEREtable_2.id=ancien.id;

FIN ;

Lorsque le déclencheur ci-dessus modifie l'identifiant dans la table_1 , si le nouvel identifiant>30, les lignes de la table_2 avec le même identifiant que la table_1 seront remplacées par le nouvel identifiant

Neuf , Index

Index (Index) est une table de recherche spéciale que les moteurs de recherche de bases de données utilisent pour accélérer la récupération des données . Les index aident à accélérer les requêtes SELECT et les clauses WHERE, mais ils ralentissent la saisie des données lors de l'utilisation des instructions UPDATE et INSERT. Les index peuvent être créés ou supprimés sans affecter les données.

Index à colonne unique

Un index à colonne unique est un index créé sur la base d'une seule colonne de la table. La syntaxe de base est la suivante :

CREATE INDEX index_name

ON table_name (column_name);

Index unique

L'utilisation d'un index unique n'est pas seulement pour les performances, mais aussi pour l'intégrité des données. Un index unique ne permet pas d'insérer des valeurs en double dans le tableau. La syntaxe de base est la suivante :

CREATE UNIQUE INDEX index_name

on table_name (column_name);

Index combiné

Un index composite est un index créé sur deux ou plusieurs colonnes d'une table. La syntaxe de base est la suivante :

CREATE INDEX index_name

on table_name (column1, column2);

Que vous souhaitiez créer un index à colonne unique ou un index combiné, vous devez prendre en compte le WHERE .

Si la valeur utilise une colonne, choisissez d'utiliser un index de colonne unique. S'il y a deux colonnes ou plus fréquemment utilisées dans la clause WHERE comme filtre, choisissez d'utiliser un index composite.

Index implicite

L'index implicite est un index créé automatiquement par le serveur de base de données lors de la création d'un objet. Les index sont automatiquement créés avec des contraintes de clé primaire et des contraintes uniques.

SELECT * FROM sqlite_master WHEREtype = 'index';Afficher tous les index de la base de données

DROP INDEX index_name; Un index peut être supprimé à l'aide de la commande DROP de SQLite

Dans quelles circonstances éviter d'utiliser un index ?

Bien que le but de l'indexation soit d'améliorer les performances de la base de données, il existe plusieurs situations dans lesquelles l'indexation doit être évitée. Lors de l'utilisation d'index, les directives suivantes doivent être reconsidérées :

· Les indices ne doivent pas être utilisés sur des tables plus petites.

·   Les indices ne doivent pas être utilisés sur des tables avec des opérations fréquentes de mise à jour ou d'insertion par lots importants.

·  l'index ne doit pas être utilisé sur des colonnes contenant un grand nombre de valeurs NULL .

·   Les index ne doivent pas être utilisés sur des colonnes fréquemment utilisées.

Indexé par

La clause "INDEXEDBY index-name" spécifie qu'un index nommé doit être nécessaire pour trouver la valeur dans la table précédente.

Si le nom d'index nom-index n'existe pas ou ne peut pas être utilisé pour la requête, alors la préparation de l'instruction SQLite échoue.

La clause "NOTINDEXED" précise qu'aucun index n'est utilisé lors de l'accès à la table précédente (y compris les index implicites créés par les contraintes UNIQUE et PRIMARYKEY).

Cependant, même si « NON INDEXÉ » est spécifié, la CLÉ PRIMAIRE INTEGER peut toujours être utilisée pour rechercher des entrées.

INDEXED BY peut être utilisé avec les instructions DELETE, UPDATE ou SELECT :

SELECT|DELETE|UPDATE column1, column2...

INDEXED BY (index_name)

table_name

WHERE (CONDITION);

十、重命名表或向表中插入新的字段

用来重命名已有的表的 ALTERTABLE 的基本语法如下：

ALTERTABLE database_name.table_name RENAME TOnew_table_name;

用来在已有的表中添加一个新的列的 ALTERTABLE 的基本语法如下：

ALTERTABLE database_name.table_name ADD COLUMNcolumn_def...;

十一、视图

视图（View）只不过是通过相关的名称存储在数据库中的一个 SQLite 语句。视图（View）实际上是一个以预定义的 SQLite 查询形式存在的表的组合。

视图（View）可以包含一个表的所有行或从一个或多个表选定行。视图（View）可以从一个或多个表创建，这取决于要创建视图的 SQLite 查询。、

视图（View）是一种虚表，允许用户实现以下几点：

① 用户或用户组查找结构数据的方式更自然或直观。

② 限制数据访问，用户只能看到有限的数据，而不是完整的表。

③ 汇总各种表中的数据，用于生成报告。

SQLite 视图是只读的，因此可能无法在视图上执行 DELETE、INSERT 或 UPDATE 语句。但是可以在视图上创建一个触发器，当尝试 DELETE、INSERT 或 UPDATE 视图时触发，需要做的动作在触发器内容中定义。

1、创建视图

CREATE [TEMP | TEMPORARY] VIEW view_name AS

SELECT column1, column2.....

FROM table_name

WHERE [condition];

2、删除视图

DROP VIEW view_name;

十二、日期时和时间

SQLite 支持以下五个日期和时间函数：

Les cinq fonctions de date et d'heure ci-dessus prennent des chaînes de temps comme paramètres. Une chaîne de temps suivie de zéro ou plusieurs modificateurs . La fonction strftime() peut également prendre la chaîne de format format comme premier paramètre. Les différents types de chaînes temporelles et de modificateurs vous seront expliqués en détail ci-dessous.

Chaîne de temps

Une chaîne de temps peut être dans l'un des formats suivants :

序号	函数	实例
1	date(timestring, modifier, modifier, ...)	以 YYYY-MM-DD 格式返回日期。
2	time(timestring, modifier, modifier, ...)	以 HH:MM:SS 格式返回时间。
3	datetime(timestring, modifier, modifier, ...)	以 YYYY-MM-DD HH:MM:SS 格式返回。
4	julianday(timestring, modifier, modifier, ...)	Cela renverra 4714 année 11 mois 24 Le nombre de jours à partir de midi le jour.
5	strftime(format, chaîne de temps, modificateur , modificateur, ...)	Cela renverra une date formatée basée sur la chaîne de format spécifiée par le premier argument. Le format spécifique est expliqué ci-dessous.

Numéro de série

序号	时间字符串	实例
1	YYYY-MM-DD	2010-12-30
2	YYYY-MM-DD  HH:MM	2010-12-30  12:10
3	YYYY-MM-DD  HH:MM:SS.SSS	2010-12-30  12:10:04.100
4	MM-DD-YYYY  HH:MM	30-12-2010  12:10
5	HH:MM	12:10
6	YYYY-MM-DDTHH:MM	2010-12-30  12:10
7	HH:MM:SS	12:10:01
8	YYYYMMDD  HHMMSS	20101230  121001
9	now	2013-05-07

Chaîne de temps

Exemple

1

AAAA-MM-JJ

30/12/2010

2

AAAA-MM-JJ HH:MM

30/12/2010 12:10

3

AAAA-MM-JJ HH : MM :SS.SSS

30/12/2010 12:10:04.100

4

MM-JJ-AAAA HH : MM

30-12-2010 12 : 10

5

HH:MM

12:10

6

AAAA-MM-JJTHH:MM

2010-12-30 12:10

7

12:10:01

8

AAAAMMJJ HHMMSS

20101230 121001

9

maintenant

2013-05-07

Vous pouvez utiliser "T" comme caractère de texte pour séparer la date et l'heure.

Modificateur

La chaîne d'heure peut être suivie de zéro ou plusieurs modificateurs, qui modifieront la date et la date renvoyées par les cinq fonctions ci-dessus / ou l'heure. L’une des cinq fonctions ci-dessus renvoie l’heure. Les modificateurs doivent être utilisés de gauche à droite, les modificateurs pouvant être utilisés dans SQLite sont répertoriés ci-dessous :

(1)Augmentez la date et l'heure de la valeur spécifiée (les nombres positifs ou négatifs sont acceptables)

·      NNN jours

·                                                                                      NNN.NNNN secondes·  🎜>

(2)Renvoie le début de la date actuelle

· début du mois

· début de l'année

· début de la journée

(3) renvoie la date et l'heure de la semaine suivante qui est N

·                          jour de la semaine N

(4) renvoie le nombre de secondes écoulées depuis

01/01/1970

· unixepoch(5 )Retour à l'heure locale

· heure locale

( 6) Heure normale internationale

· utc

Formatage

SQLite fournit des fonctions très pratiques strftime() pour formater n'importe quelle date et le temps. Vous pouvez formater les dates et les heures en utilisant les substitutions suivantes :

替换	描述
%d	一月中的第几天，01-31
%f	带小数部分的秒，SS.SSS
%H	小时，00-23
%j	一年中的第几天，001-366
%J	儒略日数，DDDD.DDDD
%m	月，00-12
%M	分，00-59
%s	从 1970-01-01 算起的秒数
%S	秒，00-59
%w	一周中的第几天，0-6 (0 is Sunday)
%W	一年中的第几周，01-53
%Y	年，YYYY
%%	%  symbol

Remplacer

Description

% d

Le jour du mois, 01-31

%f

Avec secondes fractionnaires, SS.SSS

% H

Heure, 00 -23

%j

Au cours de l'année Le lendemain, 001-366

% J

Numéro du jour julien, DDDD.DDDD

%m

Mois,00-12

%M

points, 00-59 td>

%s

De 1970-01-01 Secondes depuis

%S

secondes, 00-59

%w

Une semaine Le jour du mois, 0-6 (0 est dimanche)

%W

Année La première semaine de 01-53

%Y

année, AAAA

%%

symbole %

selectdatetime('now','localtime');--当前时间读取本地得时间
selectdatetime('now','start of month');--本月第一天
selectdatetime('now','start of month','+1 month','-1 day');--本月最后一天
selectdatetime('now','start of year','+1 year','start of month','-1 day');--今年最后一天
SELECTjulianday(date('now','localtime')) - julianday('2018-03-20');；--计算今天到2018-03-20相差多少天

十三、函数大全

1、count 用于计算一个数据库表中得行数

如：select count（*）from k_user

2、max 选择某列最大值

3、min 选择某列最小值

4、avg 计算某列平均值

5、sum 允许一个数值列计算总和

6、random 返回一个介于 -9223372036854775808 和 +9223372036854775807之间的伪随机整数

7、abs 返回数值参数得绝对值

8、upper 吧字符串转换为大写字母

9、lower 把字符串转换为小写字母

10、length 返回字符串长度

11、sqlite_version 返回数据库版本

12、coalesce(X,Y,……) 返回第一个非空参数的副本。若所有的参数均为NULL，返回NULL。至少2个参数。

13、ifnull(X,Y) 返回第一个非空参数的副本。若两个参数均为NULL，返回NULL。

14、last_insert_rowid() 返回当前数据库连接最后插入行的RowID。

15、nullif(X,Y) 当两参数不同时返回X，否则返回NULL。

16、quote(X) 返回参数的适于插入其他SQL语句中的值。字符串会被添加单引号。

17、round(X)或round(X,Y) 将X四舍五入，保留小数点后Y位。若忽略Y参数，则默认其为0。

18、zeroblob(N)     返回一个 N 字节长、全部由 0x00 组成的 BLOB。SQLite 或以很有效的组织这些 zeroblob。它可以被用于为以后的使用预留空间。以后可以使用 incremental BLOB I/O 来写入 BLOB 数据。

19、typeof(X) 返回表达式X的类型

20、change_count() 返回受上一语句影响的行数。（好像不能用）

21、total(X) 返回一组中所有非空值的数字和。若没有非空行，sum()返回null而total()返回0.0。total()的返回值为浮点数，sum()可以为整数。

22、ltrim(X)

lrtrim(X,Y)     返回从 X 的左边边去除所有出现在 Y 中字符以后的字符串。如果省略 Y，则去除空格。

23、 replace(X,Y,Z)     返回一个将 X 字符串中每一个出现 Y 的位置替换为 Z 后的字符串。它使用二进制对照序列进行比较。

24、randomblob(N)     返回一个 N 字节长的包含伪随机字节的 BLOG。 N 应该是正整数

25、rtrim(X)

rtrim(X,Y)     返回从 X 的右边去除所有出现在 Y 中字符以后的字符串。如果省略 Y，则去除空格。

26、soundex(X)     计算字符串 X的读音编码。如果参数为 NULL，则返回 "?000"。默认情况下 SQLite 忽略该函数。仅当在编译时指定 -DSQLITE_SOUNDEX=1 时才有效。

27、substr(X,Y,Z)

substr(X,Y) Renvoie la chaîne X Une chaîne commençant par le Y-ième caractère et ayant une longueur de Z. Si Z est omis, la chaîne jusqu'à la fin de la chaîne est renvoyée. Le premier caractère de X commence par 1. Si Y est négatif, comptez à partir de la droite. Si X est une chaîne UTF-8, la valeur en indice fera référence aux caractères UTF-8 réels, et non aux octets. Si X est un BLOB, alors l'indice fait référence aux octets.

Cet article explique le contenu lié à SQLLite. Pour plus de contenu connexe, veuillez faire attention au site Web chinois de php.

Recommandations associées :

Spark SQL implémente le traitement par lots hors ligne des journaux

Explication détaillée de la récupération des données MySQL

sql Comparaison du décalage horaire entre deux enregistrements adjacents

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!