Je sais que ce post est vieux, mais serait-il possible d’ajouter des exemples concrets s’il vous plaît ?

Merci

Merci pour ces tutos.
Quand je tente de modifier les adresses IP ou le champ Activé oui non, j’ai un message d’erreur le fichier est en lecture seulement.
Avez -vous une idée?
Merci de votre réponse

SELECT DATEADD(MONTH,DATEDIFF(MONTH,0,DATEADD(YEAR,-1,GETDATE())),0)

J’ai refais le test en tenant compte de vos remarques. Voici le nouveau tableau que j’obtiens :
+———–+————–+————–+———-+
| Nombre de | Avec Curseur | Sans Curseur | Ecart |
| lignes | (Curs1) | (Curs2) | en % |
+———–+————–+————–+———-+
| 10 | 16 | 0 | – |
| 100 | 16 | 0 | – |
| 1.000 | 86 | 0 | – |
| 10.000 | 863 | 16 | 539,37 % |
| 100.000 | 8.716 | 163 | 534,72 % |
| 1.000.000 | 89.826 | 1.490 | 602,85 % |
+———–+————–+————–+———-+
| Moyenne | 99.523 | 1.669 | 593,30 % |
+———–+————–+————–+———-+
Avec curseur, j’obtiens à peu près la même chose que précédemment.
Donc votre remarque, celle d’itérer 100.000 fois sur une table ne contenant que 10 lignes, n’est pas justifiée, pour la partie curseur.

Au final, l’approche sans curseur (ensembliste) reste encore bien meilleur. Cela ne remet pas en cause la conclusion de ce sujet.
Mais je ferai remarquer que mettre une surcouche (le curseur) à ce que sait déjà faire SQL Server en interne n’est pas justifié dans ce cas.

–> le traitement par curseur est simplement catastrophique.
Oui, les résultats en millisecondes sont catastrophiques.

Mais chez moi, l’écart reste stable alors que chez vous elle est en augmentation.
Comparativement, vous obtenez 13.114 %, tandis que j’obtiens 593,30 %.
Vous êtes à plus du double de ma performance !
Normalement, nous aurions dû trouver à peu de chose près les mêmes résultats.

@+

L’INSERT permet seulement d’augmenter le nombre de lignes sur lequel on teste les deux approches. Ce n’est pas la durée de l’INSERT que l’on mesure. D’où le tableau qui montre le nombre de lignes de la table suivant les puissances de 10 : c’est ce que fait l’INSERT et que j’ai mis en commentaire, et le commentaire suivant dans l’exposition des résultats :

« Entre chaque exécution, j’ai augmenté le nombre de lignes suivant les puissances de 10″.

Evidemment vous n’obtenez pas les même résultats que moi parce que vous UPDATEz en boucle le même nombre de lignes ! Mettre à jour 10 lignes seulement, en boucle, ce n’est pas un test : 10 lignes c’est de la gnognotte, et ce n’est pas réaliste : aucun traitement business ne fait cela sur une base de données relationnelle SQL, ou alors c’est une erreur !

C’est pour ça que j’augmente le nombre de lignes de la table, et que l’on voit clairement que quand le nombre de lignes de la table augmente, le traitement par curseur est simplement catastrophique.

Vous avez une fâcheuse tendance à confondre 3 lignes qui se battent en duel dans une table, avec des tables qui en contiennent des millions voire des milliards. Or c’est à cela que l’on mesure des performances : mettre à jour 10 lignes en boucle peut être fait avec Excel.

Regardez comme je vous l’ai indiqué les tests TPC, et travaillez sur bases de données qui supportent une charge OLTP ou OLAP et dont le volume se mesure en centaines de Go, ou en To, ou plus encore. Une fois votre implémentation faite avec des curseurs, vous me direz ce que votre employeur ou client en pense : je serai ravi de vous voir le partager ici !

[quote= »elsuket »]Outre le fait que les curseurs datent de COBOL (1956 …),[/quote]
Cobol est un langage de programmation qui est apparu en 1959.
Ensuite, ils sont apparus dans le cobol avec l’apparition de DB2, donc cela date des années 80.

[quote= »elsuket »]comparons donc les temps d’exécution entre un curseur et une requête sur un traitement très simple …[/quote]
Faut-il comparer des choses qui sont comparables entre eux !
Tu proposes de comparer un update dans un curseur avec un insert sans mise à jour de la colonne.
C’est sûr que le insert sera bien plus rapide que le update, même sans curseur.

Puisque tu m’as proposé de refaire ton test de comparaison, je propose de revoir les points suivants :

1) je reprends ton exemple de la création de la table sans rien modifier.

2) j’ai créé deux procédures ayant la même structure.

3) la procédure curs1 travaille avec un curseur et vient mettre à jour la colonne « [c]nombre[/c] »

4) la procédure curs2 modifie aussi la colonne « [c]nombre[/c] », mais par un traitement ensembliste.

5) la nouveauté par rapport à ton test, je traite dans la procédure le nombre d’itération.
Ainsi dix itérations va traiter 100 lignes, soit 10 itérations X 10 lignes.

Je suis sous windows 10, avec Microsoft SQL Server Express 2014.
Mon ordinateur est un HP Compaq 6830s avec un processeur deux coeurs tournant à 2,40 Ghz.

Voici le résultat que j’obtiens :
[code]– ===========
— Paramétrage
— ===========

SET NOCOUNT ON

— ==================
— Lien vers Database
— ==================

use tempdb

Le contexte de la base de données a changé ; il est maintenant ‘tempdb’.

— ========================
— Suppression Table ‘test’
— ========================

IF OBJECT_ID(N’dbo.test’, N’U’) IS NOT NULL
DROP TABLE dbo.test

— =====================
— Création Table ‘test’
— =====================

create table test (
id integer identity(1, 1) not null,
nombre integer not null default 0
constraint pk_test_id primary key clustered (id)
)

— =============================
— Suppression Procédure ‘curs1′
— =============================

IF OBJECT_ID(N’dbo.curs1′, N’P’) IS NOT NULL
DROP PROCEDURE dbo.curs1

— ==========================
— création procédure ‘curs1′
— ==========================

create procedure dbo.curs1
@nbre integer
as
declare @datedeb datetime = cast(current_timestamp as datetime)
declare @datefin datetime
declare @id integer
begin
declare curs cursor scroll for select id from dbo.test for update of nombre

open curs
fetch next from curs into @id

while (@nbre > 0)
begin
while (@@FETCH_STATUS = 0)
begin
update dbo.test set nombre = 10 * @id where current of curs
fetch next from curs into @id
end

fetch first from curs into @id
set @nbre = @nbre – 1
end

close curs
deallocate curs
set @datefin = cast(current_timestamp as datetime)

SELECT DATEDIFF(millisecond, @dateDeb, @dateFin) as ‘temps elaps’
end

— =============================
— Suppression Procédure ‘curs2′
— =============================

IF OBJECT_ID(N’dbo.curs2′, N’P’) IS NOT NULL
DROP PROCEDURE dbo.curs2

— ==========================
— création procédure ‘curs2′
— ==========================

create procedure dbo.curs2
@nbre integer
as
declare @datedeb datetime = cast(current_timestamp as datetime)
declare @datefin datetime
begin
while (@nbre > 0)
begin
update dbo.test set nombre = 10 * id
set @nbre = @nbre – 1
end

set @datefin = cast(current_timestamp as datetime)

SELECT DATEDIFF(millisecond, @dateDeb, @dateFin) as ‘temps elaps’
end

— =====================
— Insertion dans ‘test’
— =====================

insert into test (nombre) values (0), (0), (0), (0), (0), (0), (0), (0), (0), (0)

— ================
— Vidage de ‘test’
— ================

select * from test;

id nombre
———– ———–
1 0
2 0
3 0
4 0
5 0
6 0
7 0
8 0
9 0
10 0

— =================
— procédure ‘curs1′
— =================

execute dbo.curs1 1

temps elaps
———–
16
execute dbo.curs1 10

temps elaps
———–
16
execute dbo.curs1 100

temps elaps
———–
83
execute dbo.curs1 1000

temps elaps
———–
816
execute dbo.curs1 10000

temps elaps
———–
7896
execute dbo.curs1 100000

temps elaps
———–
80116

— =================
— procédure ‘curs2′
— =================

execute dbo.curs2 1

temps elaps
———–
0
execute dbo.curs2 10

temps elaps
———–
0
execute dbo.curs2 100

temps elaps
———–
13
execute dbo.curs2 1000

temps elaps
———–
70
execute dbo.curs2 10000

temps elaps
———–
380
execute dbo.curs2 100000

temps elaps
———–
3933

Appuyez sur une touche pour continuer…[/code]

Je te donne, sous forme de tableau, le récapitulatif des résultats de ce test :
[code]

+———–+————–+————–+———-+
| Nombre de | Avec Curseur | Sans Curseur | Ecart |
| lignes | (Curs1) | (Curs2) | en % |
+———–+————–+————–+———-+
| 10 | 16 | 0 | – |
| 100 | 16 | 0 | – |
| 1.000 | 83 | 13 | 63.84 % |
| 10.000 | 816 | 70 | 116,57 % |
| 100.000 | 7.896 | 380 | 207,78 % |
| 1.000.000 | 80.116 | 3.933 | 203,70 % |
+———–+————–+————–+———-+
| Moyenne | 88.943 | 4.396 | 202,32 % |
+———–+————–+————–+———-+[/code]
Je n’obtiens pas du tout les mêmes résultats que toi, même si le traitement par curseur (Curs1) est plus long que le traitement ensembliste (curs2)

Dans ton traitement avec curseur, le « [c]update[/c] » sur le curseur ne se fait pas comme tu l’as fait.
La bonne façon de mettre à joueur un curseur est comme ci-après :
[code]update dbo.test set nombre = 10 * @id [color=red]where current of curs[/color][/code]
il est inutile de préciser la ligne par un « [c]where id = @id[/c] » car tu es déjà positionné sur la ligne courante.
tandis que sans curseur, la mise à jour se fait ainsi :
[code]update dbo.test set nombre = 10 * id[/code]
Il y a peu de différence entre ces deux écritues.
La différence se fait sur la simulation par curseur, de ce que fait en interne SQL Server par la requête ensembliste.

Sinon, je trouve tes résultats (13.114,00 %) six fois moins bon que les miens (202,32 %).

@+

Effectivement tu as raison; néanmoins il faut noter que ces nouvelles fonctions sont des invocations .NET, et qu’elles sont souvent un ersatz de ce que l’on peut faire en C# par exemple.

En ce qui concerne EOMONTH(), cette fonction a été introduite avec SQL Server 2012

A bientôt !

merci

J’ai lu ton poste il y a quelques jours, donc pardonne-moi stp si je fais erreur. Mais pour l’errorlog de l’agent, on ne sait pas configurer le nombre que l’on veut ? Alors combien en garde-t-il si tu le « forces » tous les jours à se renouveller ? Il se base sur les 99 de l’errorlog du moteur ?

Je vais mettre ça en place en tout cas, merci beaucoup

Bonne journée
Jean-Luc

Juste pour signaler un mauvais nommage de colonne. La deuxième colonne de la clause SELECT devrait se nommée estInactif au lieu de estActif

Je t’attends au summit

Comment vas-tu ? Cela fait bien longtemps que je n’ai pas eu de tes nouvelles !

J’aurai bien aimé, mais je n’ai jamais fait de Sybase.
En cherchant quelques secondes, j’ai trouvé ceci :

http://stackoverflow.com/questions/3720851/how-do-i-extract-sybase-12-5-table-ddl-via-sql

@++

Merci

Par exemple, sur un champ de type datetime on peut avoir défini la fonction système getdate() comme valeur par défaut pour un champ, enregistrée en tant que (getdate()) dans sys.default_constraints. Sauf que la commande traduit ça en getdate, sans ses parenthèses.

Je pense donc qu’il faudrait plutôt faire comme ceci pour enlever les parenthèses de début et de fin :
SUBSTRING(DF.definition,2,LEN(DF.definition)-2)

Je pense qu’au lieu d’utiliser la commande :
LEFT JOIN sys.index_columns COL_INDEX — indexes
ON COL_INDEX.object_id = COLONNES.object_id
AND COL_INDEX.column_id = COLONNES.column_id
LEFT JOIN sys.indexes AS INDEXES
ON INDEXES.object_id = COL_INDEX.object_id
AND INDEXES.index_id = COL_INDEX.index_id

il serait préférable de faire comme ceci :
LEFT JOIN (
SELECT COL_INDEX.object_id, COL_INDEX.column_id, INDEXES.is_primary_key, INDEXES.is_unique_constraint
FROM sys.index_columns COL_INDEX — indexes
LEFT JOIN sys.indexes AS INDEXES
ON INDEXES.object_id = COL_INDEX.object_id AND INDEXES.index_id = COL_INDEX.index_id
WHERE (INDEXES.is_primary_key0 OR INDEXES.is_unique0)
) INDEXES
ON INDEXES.object_id = COLONNES.object_id
AND INDEXES.column_id = COLONNES.column_id

avec notamment l’ajout d’un WHERE sur les clauses is_primary_key et is_unique qui sont finalement les seules informations qui nous intéressent dans ces tables.

Jean

En ce qui concerne le nombre d’objets, je travaille sur des bases de données qui comportent au moins un millier de tables, le plus grand nombre étant environ 5000. On imagine facilement le nombre de vues et procédures stockées qui en découlent, et dans ce cas j’ai trouvé IntelliSense insuffisant, mais je comprends qu’avec peu de tables il puisse convenir.

Il n’en reste pas moins qu’au niveau des fonctions natives (CHARINDEX(), SUBSTRING(), POWER(), …, et fonctions de date surtout), la documentation dans l’infobulle évite d’avoir à consulter l’aide en ligne. Il est possible aussi de formater la casse de fonctions, et les parenthèses sont automatiquement ajoutées. Ce n’est pas grand chose, mais répété des milliers de fois, c’est appréciable

A+

Là je l’ai déjà désinstallée mais du peu que je l’ai testée, c’était assez kif-kif par rapport à l’intellisense.

Comme avec cette dernière, parfois ça s’affichait, parfois ça ne s’affichait pas (souvent après un rafraîchissement des données il me semble).

Au niveau de la recherche d’objets, je pense que j’ai nettement moins d’objets à gérer que vous, du coup ça n’apporte pas vraiment quelque chose en plus que l’intellisense. Les noms de mes objets, je les connais ^^.

J’utilise la version gratuite tous les jours et elle est bien meilleure qu’IntelliSense. La recherche des objets et l’auto-complétion sont bien plus intuitives.

Pouvez-vous décrire plus en détails votre remarque ?

A+

Rien de super dérangeant en soi mais si c’est pour avoir la même expérience d’utilisation avec l’un ou l’autre, autant ne pas surcharger le système avec un tool en plus.

Quelqu’un à une idée sur la différence ?

Je viens de copier-coller la requête dans SSMS 2012 et de l’exécuter sur AdventureWorks2012 dans une instance SQL Server 2012 SP1, et la requête fonctionne correctement. Peux-tu décrire le problème que tu as eu plus précisément ?

@++

Il faut utiliser dans ce cas désactiver l’option CHECK_POLICY et la réactiver et le tour est joué

Cette méthode est intéressante pour exporter un nombre restreint de DTS. Cependant si tu dois transférer un nombre important de dts un transfert des données de la table sysdtspackages est plus rapide entre serveurs.

++

Globalement on peut utiliser les plans de maintenance sur des bases de données à taille ou nombre d’objets raisonnables. Ces plans sont tout à fait adapter à bon nombre de « petites » instances SQL Server.

On peut effectivement créer son propre plan de maintenance dans BIDS et du coup rendre le plan beaucoup plus générique et paramétrable. C’est d’ailleurs ce qu’utilise un de mes clients pour ses 200 instances SQL. De plus le déploiement et la mise à jour des packages SSIS est tout à fait scriptable via l’utilitaire DTEXEC et les options qui vont bien (pour l’avoir déjà fait).

Tout cela pour dire que la problématique des plans de maintenance à base de package SSIS n’est pas tant le déploiement mais l’exhaustivité des tâches qui peuvent être réalisées. Tu l’as très bien montré dans ton billet d’ailleurs (où il faut utiliser des tâches de script SQL ce qui revient à faire du TSQL au final tu me diras ). Je pense que la politique de MS vis à vis des plans de maintenance consiste à couvrir une gamme de besoin large. On peut se poser la question suivante : combien d’instances / de bases de données sur SQL Server nécessitent un plan de maintenance custom ? Je pense que le ratio ne doit pas être si élevé que cela …

++

La première division donne 0,294985… qui, étant de type money devient 0,2949.
0,2949 * 1000 = 2949

Le compte est bon.

C’est d’ailleurs comme cela que compte les comptables. En BI, l’arrondi intermédiaire est souvent un pré-requis

Il est en effet très pratique de pouvoir scripter un job : on peut ainsi déployer le même job sur un groupe de serveurs avec la fonctionnalité Central Management Server et ses groupes de serveurs.
De la même façon, on peut exécuter un job sur un groupe de serveurs en utilisant l’instruction EXEC sp_start_job @job_name = ‘monJob’.
La génération du script du job donne également sa planification : il s’agit de l’appel à la procédure stockée msdb.dbo.sp_add_jobschedule; cela étant, rien n’oblige à planifier un job : si le job que vous avez scripté n’est pas planifié, vous ne trouverez pas l’appel à cette procédure stockée, pas plus que vous ne trouverez de planifications pour celui-ci par un clic-droit sur celui-ci > Propriétés > Planification.

Vous trouverez dans le billet suivant une requête qui permet de consulter l’historique d’exécution des jobs :
http://blog.developpez.com/elsuket/p7895/agent-sql-server/voir-l-historique-d-execution-des-jobs-p/

Dans ce billet que je viens de publier, il y a une requête qui permet d’obtenir un aperçu complet de tous les jobs d’une instance SQL Server : http://blog.developpez.com/elsuket/p11193/agent-sql-server/une-requete-pour-lister-tous-les-travaux/

@++

Du coup, je réalise que puisque vous parlez de portabilité, c’est qu’il doit être possible de scripter un job. Et effectivement, chose que je n’avais jamais remarquée jusqu’ici, il y a bien l’option Script Job As lorsqu’on fait un clic droit. Effectivement il faut changer le nom du serveur mais un find/replace va assez vite mais je conviens que ce n’est pas pratique.

Par contre, par curiosité et pour mon information, je m’interroge car je ne trouve nulle part la mention de quand doit être exécuté ce job. Le fait d’exécuter ce script nécessiterait donc de devoir encore paramétré tout ce qui est « scheduling » (je ne trouve pas le mot français^^) du job ?

Je vais donc continuer à tester la méthode de maintenance fournie par sqlpro dans un ces articles qui utilise une table des tâches de maintenance à effectuer sur chaque DB. Cela m’avait pas mal du tout (venant de lui, le contraire eut été étonnant) mais je n’ai pas encore osé passer cela en production… Etant DBA amateur, je joue encore un peu à l’apprenti sorcier et chaque changement sur le serveur de production provoque pas mal de stress ^^

Encore merci pour l’article.

Kropernic.

Je ne savais pas que les plans de maintenance sont disponibles dans BIDS.
En fait un plan de maintenance, c’est la « liaison » entre un travail de l’Agent SQL Server et une tâche SQL Server Integration Services; donc effectivement il doit être possible de spécifier des plans de maintenance dans BIDS.

Il n’est pas absolument nécessaire de remplacer les plans de maintenance par l’exécution d’une procédure stockée qui fait plus ou moins le même travail. Comme bien souvent, cela dépend de la quantité de données que vous ou votre employeur peut se permettre de perdre en cas de crash : si vous pouvez dire que perdre une journée de données n’est pas catastrophique pour le business, alors un plan de maintenance pour les sauvegardes peut tout à fait convenir.
Si en revanche vous ne pouvez pas vous permettre de perdre une minute de changements de données, et que vous avez besoin d’être alerté immédiatement lorsqu’une sauvegarde a échoué, je ne trouve pas qu’un plan de maintenance soit ce qu’il y a de plus adapté.

Finalement, les plans de maintenance ne sont pas catastrophiques pour les sauvegardes de base de données; ils le sont bien plus en ce qui concerne la maintenance des statistiques et des index, ou pire, le rétrécissement des bases de données, qui, je pense, ne devraient tout simplement pas exister.

Je pense que la raison est un défaut de précision qui n’est pas signalé à l’affectation et lors des calculs.
Je ne m’explique pas que cela n’ait pas été corrigé; aussi le type decimal ou numeric convient tout à fait.

Je ne trouve pas problématique que la division d’un entier par un entier produise un entier.
C’est le cas dans de nombreux autres langages; je suppose que c’est un standard

@++

Je voudrais être sûr car j’ai mis en place un backup des DB de prod à l’aide de ces tâches (n’y connaissant rien, j’ai trouvé ça pratique et bien foutu :-/) et je voulais savoir si je pouvais laisser cela en place ou bien s’il fallait que j’écrive les scripts à la main ?

Merci pour l’info. Par contre, pourquoi cela produit-il ce résultat ?

Ne serait-ce pas pour le même genre de raison qu’un entier divisé par un entier donne un entier comme résultat ?

–> http://blog.developpez.com/mikedavem/p11091/sql-server-2000/scanner-le-reseau-pour-trouver-les-liste

++

————————————————————
#Clear console display
cls;

# Current hostname
$computer = hostname;

Write-Host « Discover SQL Server instances on the local machine » -foreground red
Start-Sleep -s 2
Write-Host « … »
Start-Sleep -s 1
Write-Host «  »
Write-Host «  »

# Discover SQL Server instances
try
{
$sql_server = get-wmiobject -class win32_service -computer $computer -EA STOP

$instances = $sql_server | where { $_.name -like ‘MSSQL$*’ -or $_.name -eq ‘MSSQLSERVER’ } | Select -Property Name

Foreach ($instance_name in $instances)
{
$list_instance +=  »  » + $instance_name.Name;
}

If ($instances.Count -gt 0)
{
$line = $computer,$list_instance -join «  »;
# WRITE TO CONSOLE
Write-Host –> $line.replace( » « , « , »);
}
}
catch
{
Write-host $_
}

Write-Host «  »
Write-Host «  »
Write-Host «  »
Write-Host «  »
Write-Host «  »
Write-Host «  »
————————————————————

++

Ce script n’est destiné qu’à l’étude manuelle d’une table ou vue indexée en particulier.
Normalement il vient en complément de jobs collectant la fragmentation des index d’une base de données et l’éliminant, et d’un job maintenant les statistiques.

Est-ce à dire que vous seriez intéressé par un script / une procédure stockée faisant ce que fait ce script mais pour toute une base de données ?
Notez que suivant le volume de la base de données, le temps d’exécution d’un tel script peut être long et impacter les performances de la base de données auditée.

, @table_or_indexed_view_name sysname = NULL– NULL étudie toutes les tables

Avec la valeur NULL on a un message qui dit que NULL n’existe pas.

http://img842.imageshack.us/img842/1659/captureaide.png

En revanche lorsque j’ai tenté de passer en Français la documentation de SQL Server 2012 dans mon entreprise, où j’ai un navigateur en Anglais, j’ai obtenu le même problème que vous …

Je suppose que la boulette sera bientôt corrigée par Microsoft

En précisant quel lien de quelle version ne marche pas, ça peut aider, parce que je viens de tester tous les liens et les pages sont bien en Français …

Il sert tout simplement à activer l’écoute de connexions sur le protocole TCP/IP, avec par défaut le port 1433 (mais vous pouvez le changer).
Tout changement de configuration à ce niveau implique un redémarrage sur service SQL Server, c’est à dire au moins quelques secondes d’indisponibilité de l’instance et des bases de données qu’elle héberge.

@++

Merci de cet article utile.

Qu’en est-il du champ « Activé » pour chaque connexion TCP/IP ?
A quoi sert-il ? Je ne trouve nulle part l’information.

Merci.

Fabrice, Toulouse

merci à tous les deux de vos commentaires.

En ce qui concerne l’année fiscale, il me semble qu’en France c’est l’année civile.

Je me rappelle m’être renseigné là-dessus quand j’étudiais la possibilité d’ouvrir ma propre entreprise au mois d’Octobre 2009 : le plafond annuel de chiffre d’affaire était à ce moment là de 32000€, et si j’avais ouvert mon entreprise en tant qu’auto-entrepreneur, je n’aurai pas pu dépasser les 8000€ d’Octobre à Décembre, puisque c’est au pro-rata.

Je ne sais pas si en France il est possible pour les entreprise de choisir leur année fiscale comme c’est le cas aux États-Unis …

@++

Je suis tombé sur cette article car j’ai des problèmes de perfs … et j’essai de réaliser la même chose pour l’année fiscale en cours.

Une idée pour éviter d’utiliser des CASE WHEN ELSE END ?

Merci dans tous les cas pour cette article

Merci de l’avoir relevé

ou

La table fait partie intégrante de la fonction et on doit donc l’ajouter, voir la remplir avec le plus possible d’enregistrements et on est pas obligé de ré implémenter cette fonction pour chaques types d’utilisation?

Pour la taille de CreateLSN, quelle taille avez-vous mis ?

@++

chunks less than 64MB = 4 VLFs
chunks of 64MB and less than 1GB = 8 VLFs
chunks of 1GB and larger = 16 VLFs

Les fichiers logs ne benificient pas de l’instant file initialisation ce qui force le moteur a remplir le nouvel espace allouer de 0 car un bout de disque pourrait contenir des informations similaires a un log file.

Etant donne l’aspect cyclique du transaction log, un bit de parite fixe a 64 ou 128 permet de definir ou un VLF « reutilise » s’arrete.

Cheers

Pour SQL Server 2008 x64 il faut également rajouter le path « C:Program FilesAdobeAdobe PDF iFilter 9 for 64-bit platformsbin » dans les variables d’environnements.

Sans cela SQL Server ne prend pas en compte les fichiers pdf … C’est effectivement marqué dans la documentation abode mais tout en bas …. donc pensez à bien la lire jusqu’au bout

++

Il me semble qu’il y a une coquille dans la requête collation niveau colonne.

Prenons un exemple :

–>Pour une collation serveur French_CI_AS

–> Et une base de données de collation Latin1_General_CS_AS

L’exécution de la requête suivante :

Renvoie une erreur classique connue :

Msg 468, Niveau 16, État 9, Ligne 11
Impossible de résoudre le conflit de classement entre « French_CI_AS » et « Latin1_General_CS_AS » dans l’opération equal to.

–> Contournement

En revanche les 4 fonctions non déterministes ci-dessous ne sont toujours pas autorisées dans les fonctions : UDF
NEWID,
RAND,
NEWSEQUENTIALID,
TEXTPTR.

SQL Server Books Online (BOL) ne fournit aucune raison pour ce changement et ne fait aucune distinction entre les fonctions non déterministes qui sont autorisés dans une fonction de celles qui ne sont pas !

A+

A +

Je suis plus pour réduire le journal à une taille définie plutôt que de faire un ‘TRUNCATEONLY’ et le réagrandir ensuite. Pendant l’opération de réagrandissement, le fichier LDF sera zéro-initialisé justement en raison de la structure des VLFs, ça risque de prendre du temps. Tu peux le voir en activant le TF 3004 dans la session qui fait l’alter database modify file.

Merci pour ton post, A+

David B.

Exemple :

Donne bien comme résultat : OK

Il faudra attendre la prochaine version de SQL Server pour pouvoir auditer cela à l’aide des événements étendus

@++

SELECT GETDATE() -1 AS hier_avec_heure
SELECT CAST(GETDATE() -1 AS DATE) AS hier

SELECT DATEADD(WEEKDAY, -1,GETDATE()) AS hier_avec_heure
SELECT CAST(DATEADD(WEEKDAY, -1,GETDATE()) AS DATE)AS hier

Billet intéressant. Je me permets de compléter .. Avec cette méthode on est obligé d’avoir une trace en continue pour pouvoir détecter un éventuel grossissement de fichier. J’avais un client qui voulait pouvoir détecter ces grossissements uniquements quand ceux-ci se produisent.

On peut également passer une des méthodes (parmi tant d’autres) qui permet de faire ceci :

http://blog.developpez.com/mikedavem/p8763/sql-server-2005/sql/audit-des-autogrow-de-fichiers-de-bases/#more8763

++

–> Automatiser cette tâche sur un serveur de PROD me paraît un peu risqué si on n’a pas sous la main le script de retour arrière.
je m’explique :
S’il y a juste deux colonnes qui sont MAJ pas de problème pour faire un retour arrière rapide AU CAS OU !
Mais imaginons le cas où il y a plusieurs dizaines de colonnes qui sont MAJ…en cas de problème
au niveau d’une application par exemple , il faut prévoir le script de retour arrière

–> je propose de :
1.
Lister d’abord les colonnes concernées
—————-
SELECT OBJECT_NAME(c.OBJECT_ID) TableName
, c.name ColonneName
,t.name TypeName
FROM sys.columns AS c
JOIN sys.types AS t ON c.user_type_id=t.user_type_id
WHERE t.name IN (‘text’,’ntext’,’image’)
ORDER BY TableName;

2.
Préparer le script de retour arrière (pour annuler l’opération de MAJ)
—————-

3.
–> Aplliquer la MAJ

Question
——–
Je me demande si les types ‘timestamp’ et ‘datetime’ ne sont pas aussi dépréciés sous SQL Server 2008 ?

A +

++

SELECT TOP 1 @backupdir = QUOTENAME(LEFT(physical_device_name, LEN(physical_device_name) – CHARINDEX( », REVERSE(physical_device_name))))
FROM msdb.dbo.backupset AS bs
JOIN msdb.dbo.backupmediafamily AS bf
ON bs.media_set_id = bf.media_set_id
WHERE bs.database_name =
ORDER BY bs.backup_finish_date DESC;

++

Pouvez-vous essayer sans le « sys. » qui précède « sysmessages »? Je n’ai pas d’instance SQL Server 2000 sous la main pour tester …

N’hésitez pas à donner le label de l’erreur

@++

Merci pour ton script.
Je suis débutant sous sql server. La version complete marche très bien sous sql server 2008 mais sous sql server 2000 j’ai un message d’erreur sur sysmessages ?

Comment pourrais je résoudre ce problème.

Merci