SQLite boucle déclarations?

Est-il en boucle les déclarations dans SQLite, comme FOR .. in .. LOOP ou quelque chose comme ça? J'ai deux colonnes StartRange, EndRange et j'ai besoin d'insérer toute la séquence dans une autre table. Donc, si StartRange est 1 et EndRange est de 3, il est nécessaire de faire trois insère la valeur contient 1, 2, 3.

J'ai peur que vous allez avoir besoin d'écrire du code impératif de le faire, le SQL est généralement un langage déclaratif et seulement ses extensions (comme le T-SQL, SQL/PL etc.) support de contrôle de flux des structures comme les boucles. Si ce devrait être facile, cependant, de procéder à l'insertion dans un seul terme en utilisant SQLite transactions.
Perl/Python/Ruby-script-de-la-rescousse! 🙂
Cela devrait-il être déplacé à dba.stackexchange.com ?
Non, je crois que cette question est sur le sujet depuis qu'il est fondamentalement demande "Comment puis-je écrire un peu de code pour faire X, en utilisant un langage?" Comme on peut le voir à partir de la accepté de répondre, la solution est code.

OriginalL'auteur kseen | 2011-09-10

9

Vous pouvez faire ce genre de chose tout de SQL si vous avez une table supplémentaire qui contient tous les nombres entiers dont vous avez besoin.

Supposons que votre StartRange et EndRange comprise entre un et dix et vous avez un tableau comme ceci:
```
sqlite> select i from ints;
i
1
.
.
.
10
```
Ce tableau contient tous les nombres entiers dont vous avez besoin (un sur dix).

Alors si vous aussi, vous avez ceci:
```
sqlite> create table t (startrange int not null, endrange int not null);
sqlite> insert into t values(1, 3);
sqlite> create table target (i int not null);
```
Vous pouvez faire votre Insère dans target avec une jointure:
```
insert into target (i)
select ints.i
from ints join t on (ints.i >= t.startrange and ints.i <= t.endrange)
```
Le résultat est le suivant:
```
sqlite> select * from target;
i
1
2
3
```
Bien sûr, votre véritable t aurait plus de lignes de sorte que vous voudriez une clause where à la limite de la ligne de t vous regardez.

Des choses similaires se fait souvent avec des dates (calendrier "tables").

Donc, si vos plages sont de petite taille (pour une définition de petit) puis générer votre ints table une fois, ajouter un index, et d'utiliser la technique ci-dessus pour faire tous les INSERTs à l'intérieur de la base de données. D'autres bases de données ont leurs propres moyens (tels que PostgreSQL est generate_series) pour faire ce genre de chose sans avoir besoin d'un explicite ints table, mais SQLite est (volontairement) limitée.

SQL est généralement à base de jeu si les boucles ne sont pas naturelles. Ce qui est naturel est de construire des ensembles en décrivant ce que vous avez besoin. Otoh, que, parfois, les actes contre nature sont nécessaires et raisonnables.

Je ne sais pas si cela a un sens pour votre application, j'ai juste pensé que je voudrais vous montrer comment il peut être fait. Si cette approche ne fait pas de sens dans votre cas, alors vous pouvez générer un tas d'états d'INSERTION à l'extérieur de la base de données.

SQLite tables ont des numéros de ligne qui peuvent être utilisés dans les requêtes.
Faites-vous référence à rowid?
Oui. (et avec votre nom, c'est toujours trop court)
Mais que faire si il y a des lacunes dans la rowids? Ou si elles ne correspondent pas à la plage désirée?
C'est vrai, à l'explicite distance, il semble préférable d'avoir explicite les numéros de ligne. Mais kseen besoin de vous soucier de la possibilité de lacunes.

OriginalL'auteur

Vous pouvez faire des boucles dans SQL avec récursive des déclencheurs. À l'aide de mu est trop court's schéma

sqlite> create table t (startrange int not null, endrange int not null);
sqlite> insert into t values(1, 3);
sqlite> create table target (i int not null);

nous avons besoin pour activer les déclencheurs récursifs dans SQLite:

sqlite> PRAGMA recursive_triggers = on;

Faire un temporaire de déclenchement de la boucle jusqu'à la fin de la plage:

sqlite> create temp trigger ttrig
   ...> before insert on target
   ...> when new.i < (select t.endrange from t) begin
   ...> insert into target values (new.i + 1);
   ...> end;

Coup de pied hors tension:

sqlite> insert into target values ((select t.startrange from t));
sqlite> select * from target;
3
2
1
sqlite>

Voici la magie noire dont j'avais besoin. Merci copain!

OriginalL'auteur

Apparemment, la construction de boucle dans SQLite est le AVEC RÉCURSIVE clause.
Que la documentation lien a nombre d'échantillon à dix code, un ensemble de Mandelbrot traceur, et un puzzle de Sudoku solver, le tout en pur SQL.
Voici une requête SQLite qui calcule la suite de Fibonacci pour vous donner une idée:

sqlite> WITH RECURSIVE
   ...>   fibo (curr, next)
   ...> AS
   ...>   ( SELECT 1,1
   ...>     UNION ALL
   ...>     SELECT next, curr+next FROM fibo
   ...>     LIMIT 100 )
   ...> SELECT group_concat(curr) FROM fibo;
1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,1597,2584,4181,6765,10946,...

Et voici un Crible d'Eratosthène:

begin transaction;

drop table if exists naturals;
create table naturals
( n integer unique primary key asc,
  isprime bool,
  factor integer);

with recursive
  nn (n)
as (
  select 2
  union all
  select n+1 as newn from nn
  where newn < 1e4
)
insert into naturals
select n, 1, null from nn;

insert or replace into naturals
  with recursive
    product (prime,composite)
  as (
    select n, n*n as sqr
      from naturals
      where sqr <= (select max(n) from naturals)
    union all
    select prime, composite+prime as prod
    from
      product
    where
      prod <= (select max(n) from naturals)
  )
select n, 0, prime
from product join naturals
  on (product.composite = naturals.n)
;
commit;

OriginalL'auteur

Vous devez vous connecter pour publier un commentaire.