Copie structure de table à table dans sqlite3

Est-il un moyen facile de copier une table existante structure pour un nouveau?
(n'ont pas besoin de ces données, seule la structure -> comme id INTEGER, nom varchar(20) ...)

Thx

InformationsquelleAutor leon22 | 2012-10-04

74

Vous pouvez utiliser une commande comme ceci:
```
CREATE TABLE copied AS SELECT * FROM mytable WHERE 0
```
mais en raison de SQLite du typage dynamique, la plus type d'information serait perdue.

Si vous avez besoin d'une table qui se comporte comme l'original, c'est à dire, a le même nombre et les noms de colonnes, et peut stocker les mêmes valeurs, c'est assez.

Si vous avez vraiment besoin de l'information concernant le type exactement comme l'original, vous pouvez lire la version d'origine de SQL CREATE TABLE déclaration de l' sqlite_master tableau, comme ceci:
```
SELECT sql FROM sqlite_master WHERE type='table' AND name='mytable'
```
- Mais comment voulez-vous utiliser la sortie de votre instruction select pour créer la nouvelle table?
- C'est la commande SQL. Vous l'exécuter.
- Je pense que indiekiduk demande si il y a un moyen de faire cela de dans le SQL, et je pense que c'est une bonne question. Si il y a un moyen pour faire cela, il serait une amélioration de la réponse.
- Astuce - Si vous avez ajouté un index à votre table (et vous souhaitez dans votre nouvelle table), vous pouvez récupérer son SQL à partir de sqlite_master à l'aide de: sql SELECT à PARTIR de sqlite_master OÙ type='index' ET table_name='mytable' et sql n'est pas nulle; - les Avis, je suis en utilisant le champ nom_table parce que le champ de nom de stocker le nom de l'INDEX, pas sur la TABLE
InformationsquelleAutor CL.
11

SQLite ne peut pas cloner table avec PK, les valeurs par défaut et les indices.

De piratage par un autre outil n'est nécessaire.

En coque, remplacer le nom de la table par le sed.
```
sqlite3 dbfile '.schema oldtable' | sed '1s/oldtable/newtable/' | sqlite3 dbfile
```
Et vous pouvez vérifier à nouveau le tableau.
```
sqlite3 dbfile '.schema newtable'
```
Clé primaire, les valeurs par défaut et des indices vous seront réservés.

J'espère que cette commande peut vous aider.

InformationsquelleAutor Raymond Wu
0

sqlite> .schéma
```
CREATE TABLE [About](
  [id],
  [name],
  [value]);
```
.schéma de commande de vous donner la structure de Propos de table comment il pourrait en être faite par programmation SQLite interprète à la main, saisissant les commandes.

Coller dans et exécuter, de les CRÉER de bloc de donner la table nouveau nom:
```
sqlite> CREATE TABLE [AboutToo](
  [id],
  [name],
  [value]);
```
.les tableaux de commande va maintenant montrer que vous avez deux tables, l'ancien et le nouveau, a "copié".
```
sqlite> .tables
About     AboutToo
```
p.s. sqlite> est l'invite de commande, vous obtenez dans la console après le lancement de SQLite.exe interprète. Pour l'obtenir aller à http://www.sqlite.org
- Semble CRÉER la TABLE de la Crainte QUE SELECT * from Sur; effectue le même travail, rend la copie.
InformationsquelleAutor startup.maker
-1

Je préfère :
```
> sqlite3 <db_file>

sqlite3 > .output <output_file>
sqlite3 > .dump <table_name>
```
La ligne ci-dessus génère le vidage de table qui comprend DDL et DML.

Apporter des modifications dans ce fichier, c'est à dire trouver et remplacer le nom de la table avec le nouveau nom de la table

Aussi, remplacer "CREATE TRIGGER " avec "CREATE TRIGGER <NEWTABLE>_" , ce sera de remplacer les déclencheurs existants avec les noms des déclencheurs avec un nouveau nom de la table sur elle. Qui le rendent unique et ne sera pas causer des conflits avec les déclencheurs existants. Une fois que toutes les modifications de schéma sont mis en œuvre, le lire dans la base de données à l'aide de .read
```
sqlite3 > .read output_file
```
Cela peut être fait avec des scripts en shell fichier à l'aide des commandes du shell comme :
```
echo ".dump <table>" | sqlite3 <db_file> > <table_file>
sed -i.bak "s/\b<table_name>\b/<new_table_name>/g" <table_file>
sed -i.bak "s/\bCREATE TRIGGER \b/CREATE TRIGGER <new_table_name_>/g" <table_file>
echo ".read <table_file>" | sqlite3 <db_file>
rm <table_name>.bak 
```
Par exemple :

Si vous avez de la table T et de la nouvelle table est TClone dans le fichier db D avec le fichier F pour la création : puis
```
echo ".dump T" | sqlite3 D.sqlite > F
sed -i.bak "s/\bT\b/TClone/g" F
sed -i.bak "s/\bCREATE TRIGGER \b/CREATE TRIGGER TClone_>/g" F
echo ".read F" | sqlite3 D.sqlite 
rm T.bak
```
Enfin, vous pouvez généraliser ce script en créant une version paramétrée où vous pouvez passer source_table, destination_table , db_file que les paramètres peuvent être utilisés pour cloner n'importe quel tableau.

J'ai testé et ça marche.

Test :
```
sqlite3 <database_file>
sqlite3 > select * from <new_table>;
```
devrait vous donner les mêmes résultats que la table d'origine. et
```
sqlite3 > .schema <new_table>
```
doivent avoir le même schéma que celui de la table d'origine avec un nouveau nom.

InformationsquelleAutor Prashant Nidgunde

Vous devez vous connecter pour publier un commentaire.