blog.pagesd.info

Pour mon super état des marges ultra prioritaire, je dois intégrer des données en provenance de la paye. Le problème c'est que le logiciel de paie utilise une base de données SQL Anywhere 9 et qu'il faut donc que je trouve comment m'y connecter. Et ben c'est pas si évident que ça pour trouver de l'information sur comment faire et encore moins pour arriver à récupérer un client pour Sql Anywhere 9 qui fasse l'affaire. Ou alors il faut être prêt à se tartiner des kilomètres de documentation et installer à tire larigot jusqu'à tomber sur le truc qui va bien.

Mais quand on a autant de temps que moi et qu'on ne veut pas encombrer son PC de tout un tas de trucs inutiles, il faut savoir se débrouiller (et aussi se contenter d'ODBC).

Pour commencer, il faut aller dans le dossier C:\Program Files\Sybase\SQL Anywhere 9\win32 d'une machine où SQL Anywhere 9 est déjà installé.

Une fois là, récupérer les 3 fichiers suivants :

• dbodbc9.dll
• dblgen9.dll
• dbcon9.dll

Eventuellement, on peut aussi prendre les 2 fichiers suivants :

• dblgfr9.dll : dblgen9.dll en français
• dbcoen9.chm : fichier d'aide

Créer un dossier "C:\SQL Anywhere 9" et y copier les fichiers.

On dispose maintenant d'un répertoire contenant tous les fichiers nécessaires pour le bon fonctionnement du pilote ODBC de Sybase SQL Anywhere 9. Il reste simplement à configurer la base de registre pour qu'il soit possible de se connecter à Sybase via le pilote ODBC.

On continue et on lance regedit.exe pour ouvrir la base de registre

Aller dans HKEY_LOCAL_MACHINE \ SOFTWARE \ ODBC \ ODBCINST.INI. Là il faut se placer sur la clé "ODBC Drivers" et demander à y créer une nouvelle valeur chaine que l'on appellera "SQL Anywhere 9". Une fois cette valeur créée, double-cliquer dessus pour y enregistrer la valeur "Installed".

Rester dans HKEY_LOCAL_MACHINE \ SOFTWARE \ ODBC \ ODBCINST.INI et y créer une nouvelle clé "SQL Anywhere 9" (le même nom que la chaine créée auparavant). Se placer ensuite sur la clé que l'on vient de créer et ajouter les 2 valeurs chaines suivantes :

• Driver
• Setup

Puis pour chacune de ces deux chaines, enregistrer la valeur "C:\SQL Anywhere 9\dbodbc9.dll".

Ca y est, c'est quasiment fini.

On peut maintenant lancer l'administrateur de sources de données ODBC, cliquer sur le bouton "Ajouter" dans l'onglet "Sources de données système" et choisir le pilote "SQL Anywhere 9" pour obtenir la boite de dialogue permettant de configurer la connexion ODBC au serveur SQL Anywhere 9 :

A partir de là, il suffit de renseigner les différents informations qui vont bien, soit dans mon cas à peu près :

• Onglet ODBC - Nom de source de données : BasePayeProd
• Onglet ODBC - Description : Base de données Sybase de production pour la paie
• Onglet Connexion - ID utilisateur : XXXXXX
• Onglet Connexion - Mot de passe : XXXXXXXXX
• Onglet Base de données - Nom du serveur : BasePayeProd
• Onglet Réseau - TCP/IP : coché

Puis revenir sur l'onglet ODBC pour vérifier que tout est OK en cliquant sur le bouton "Tester la connexion".

Et quand on a comme moi on a la chance d'avoir un ODBCTST.EXE from Oracle, on peut immédiatement se connecter à la base de données pour vérifier que ça marche pour de vrai.

Ensuite, sous Visual Studio, on peut enfin se connecter à la base de donnée Sybase avec la commande suivante :

OdbcConnection db = new OdbcConnection("DSN=BasePayeProd");

{via monologue}

Une liste d'articles intéressants sur MSDN à propos de l'utilisation du language SQL avec les bases de données Access 2000. A lire, imprimer et voir s'ils existe des trucs dans le même style pour les dernières versions d'Access.

Fundamental Microsoft Jet SQL for Access 2000

This article discusses the basic mechanics of using Jet SQL to work with data in an Access 2000 database. It also delves into using SQL to create and alter a database's structure. If you're new to manipulating data with SQL in an Access database, this article is a great place to start. (21 printed pages)

Intermediate Microsoft Jet SQL for Access 2000

Second in a series of three articles, Intermediate SQL builds on the concepts covered in the Fundamental SQL article and gives a much more detailed picture as to what can be accomplished with Microsoft Jet SQL in Access. For users and developers seeking to expand their understanding of Structured Query Language as it is used in the Microsoft Jet Database Engine, this article is designed to be the next logical step. (38 printed pages)

Advanced Microsoft Jet SQL for Access 2000

Third in a series of three articles, Advanced SQL builds on the concepts covered in the Fundamental and Intermediate articles, this time focusing on SQL syntax that is most often found in a multi-user environment. If you've read the previous two articles in an effort to become a well-rounded SQL user, this article will provide the final tools you will need to accomplish your goal. (24 printed pages)

Mise à jour :

• quelques notes à propos de ces 3 articles sur : http://www.chat11.com/Microsoft_Access_SQL
• un tutoriel en français sur Le langage SQL dans Access

QC étant destiné à être multi base de données, il est nécessaire de prendre un certain nombre de précautions pour tout ce qui concerne SQL, qu'il s'agisse des requêtes ou des types de données.

Pour les requêtes on verra plus tard, pour les types de données, c'est ici.

Pour faciliter le développement multi base de données voire simplifier la migration d'une base de données à l'autre, QC ne gère qu'un sous-ensemble de types de données, qui fonctionnent de façon plus ou moins identique dans la plupart des bases de données.

La liste des "pseudo-types" de données reconnues par QC est la suivante :

• AUTOINCREMENT
• BOOLEAN
• SMALLINT
• INT
• BIGINT
• SINGLE
• DOUBLE
• CURRENCY
• TEXT(2000)
• TEXT
• MEMO
• DATETIME
• DATE
• TIME
• BINDATA

Remarques :

• Pour le type de données TEXT, il faut impérativement définir une longueur comprise entre 1 et 255 ou strictement égale à 2000.
• Il est conseillé d'éviter d'utiliser des données de types CURRENCY (n'existe réellement que sous Access et Sql Server) et BINDATA.
• Le type DATE et le type TIME ne doivent pas être utilisés. Ils sont uniquement destinés à gérer des tables déjà existantes pour lesquelles il serait impossible de modifier le type de données.

Transposition pour une base de données Access

• AUTOINCREMENT : INT NOT NULL IDENTITY (1, 1)
• BOOLEAN : BIT
• SMALLINT : SMALLINT
• INT : INTEGER
• BIGINT : LONG
• SINGLE : REAL
• DOUBLE : DOUBLE PRECISION
• CURRENCY : MONEY
• TEXT(2000) : MEMO
• TEXT : TEXT
• MEMO : MEMO
• DATETIME : DATETIME
• DATE : DATE
• TIME : TIME
• BINDATA : IMAGE

Transposition pour une base de données Sql Server

• AUTOINCREMENT : INT NOT NULL IDENTITY (1, 1)
• BOOLEAN : BIT
• SMALLINT : SMALLINT
• INT : INTEGER
• BIGINT : BIGINT
• SINGLE : REAL
• DOUBLE : DOUBLE PRECISION
• CURRENCY : MONEY
• TEXT(2000) : NVARCHAR(2000)
• TEXT : NVARCHAR
• MEMO : NTEXT
• DATETIME : DATETIME
• DATE : DATETIME
• TIME : DATETIME
• BINDATA : IMAGE

Transposition pour une base de données Oracle

• AUTOINCREMENT : INT NOT NULL
• BOOLEAN : NUMBER(1,0)
• SMALLINT : NUMBER(5,0)
• INT : NUMBER(10,0)
• BIGINT : NUMBER(20,0)
• SINGLE : FLOAT(24)
• DOUBLE : FLOAT(48)
• CURRENCY : NUMBER(19,1)
• TEXT(2000) : VARCHAR2(2000)
• TEXT : VARCHAR2
• MEMO : CLOB
• DATETIME : DATE
• DATE : DATE
• TIME : DATE
• BINDATA : BLOB

Dans le cas du pseudo-type AUTOINCREMENT, l'incrémentation automatique est simulée à l'aide :

• d'une séquence SEQ_NomTable,
• d'un trigger before insert TRG_BI_NomTable

Transposition pour une base de données PostgreSQL

• AUTOINCREMENT : BIGSERIAL
• BOOLEAN : NUMERIC(1)
• SMALLINT : INT2
• INT : INT4
• BIGINT : INT8
• SINGLE : FLOAT4
• DOUBLE : FLOAT8
• CURRENCY : NUMERIC(16,4)
• TEXT(2000) : VARCHAR(2000)
• TEXT : VARCHAR
• MEMO : TEXT
• DATETIME : TIMESTAMP WITHOUT TIME ZONE
• DATE : DATE
• TIME : TIME
• BINDATA : BYTEA

Transposition pour une base de données MySQL

• AUTOINCREMENT : INT AUTO_INCREMENT
• BOOLEAN : TINYINT(1)
• SMALLINT : SMALLINT
• INT : INTEGER
• BIGINT : BIGINT
• SINGLE : FLOAT
• DOUBLE : DOUBLE PRECISION
• CURRENCY : DECIMAL(16,4)
• TEXT(2000) : TEXT
• TEXT : VARCHAR
• MEMO : MEDIUMTEXT
• DATETIME : DATETIME
• DATE : DATE
• TIME : TIME
• BINDATA : MEDIUMBLOB

La boite SqlQuery automatise l'affichage du résultat d'une requête SQL dans une table à l'aide de l'objet XTable. La nouvelle boite SqlRepeat permet également d'afficher le résultat d'une requête SQL, mais offre plus de souplesse en ce qui concerne la présentation. Il est ainsi possible de définir :

• le code html a afficher avant le résultat de la requête,
• le code html servant de modèle pour formatter chaque ligne du résultat de la requête,
• le code html à générer à la suite du résultat de la requête.

Exemple de paramétrage pour un fichier CSV :

• Connection string : {odbc};Driver={Microsoft Text Driver (*.txt; *.csv)};Dbq=~/data/
• Sql query :

  SELECT affix, givenName, legalName,
         telephone, email,
         addressLine1, postalCode, municipality
  FROM   [adresses.csv]
  ORDER BY postalCode DESC, legalName ASC, givenName ASC
  

• Header section : <ol>
• Template for each item : <h4>{0} {1} {2}</h4><ul><li>téléphone : {3}</li><li><a href='mailto:{4}'>{4}</a></li><li>{5} - {6} {7}</li></ul>
• Footer section : </ol>

Dans le cas d'un fichier Excel, la paramétrage de la connexion et de la requête devraient être effectué de la façon suivante :

• Connection string : {odbc};Driver={Microsoft Excel Driver (*.xls)};Dbq=~/data/adresses.xls
• Sql query :

  SELECT affix, givenName, legalName,
         telephone, email,
         addressLine1, postalCode, municipality
  FROM   [Sheet1$]
  ORDER BY postalCode DESC, legalName ASC, givenName ASC
  

SELECT COLUMN_NAME,
       DATA_TYPE,
       CHARACTER_MAXIMUM_LENGTH,
       NUMERIC_PRECISION,
       NUMERIC_SCALE,
       IS_NULLABLE,
       COLUMNPROPERTY(OBJECT_ID(TABLE_NAME), COLUMN_NAME, 'IsIdentity') AS IS_AUTOINCREMENT,
       COLUMN_DEFAULT
FROM   INFORMATION_SCHEMA.COLUMNS
WHERE  TABLE_NAME = 'xxxxxxxx'
ORDER BY ORDINAL_POSITION

(publié à l'origine sur http://www.bigbold.com/snippets/posts/show/815)

Edit : Voir aussi "system_function_schema.fn_datadictionary", une fonction qui renvoie le dictionnaire de données pour n'importe quelle base Sql Server.

CONVERT(DATETIME, 'yyyymmdd', 112)

112 -> ISO date cf. CAST and CONVERT

Edit : une bien meilleure solution de Wild Richard :

{d 'yyyy-mm-dd'}

(publié à l'origine sur http://www.bigbold.com/snippets/posts/show/754)

This week-end, I looked for a way to have auto-increment column in Oracle while having the possibility to set a given value in some inserts.

Several years ago, I used a trigger where the pseudo auto-incremented column was initialized with a sequence only when its value is empty.

CREATE OR REPLACE TRIGGER TRG_BI_all_Increments
   BEFORE INSERT
   ON all_Increments
   FOR EACH ROW
BEGIN
   IF (:NEW.ID IS NULL) THEN
      SELECT SEQ_all_Increments.NEXTVAL INTO :NEW.ID FROM DUAL;
   END IF;
END;

That enabled me to initialize parameters tables with default values from an sql script. The drawback was that once the data are loaded, the start value for the sequence had to be manually reset to the maxim value inserted in order to avoid duplicate errors.

I rewrote it so that when an INSERT statement define the ID value, the triggeer checks if this value is greather than the current sequence value and in this case automatically reset the sequence to the inserted value.

/* create table */
CREATE TABLE all_Increments (
    id   INT NOT NULL ,
    test VARCHAR2(100) ,
    CONSTRAINT PK_all_Increments
    PRIMARY KEY ( id )
);

/* create sequence */
CREATE SEQUENCE SEQ_all_Increments
    START WITH 1
    MAXVALUE 1.0E28
    MINVALUE 1
    NOCYCLE
    NOCACHE
    ORDER;

/* create trigger */
CREATE OR REPLACE TRIGGER TRG_BI_all_Increments
    BEFORE INSERT
    ON all_Increments
    FOR EACH ROW
DECLARE
    last_Sequence NUMBER;
    last_InsertID NUMBER;
BEGIN
    IF (:NEW.id IS NULL) THEN
         SELECT SEQ_all_Increments.NEXTVAL INTO :NEW.id FROM DUAL;
    ELSE
         SELECT NVL(Last_Number, 0) INTO last_Sequence
           FROM User_Sequences
          WHERE UPPER(Sequence_Name) = UPPER('SEQ_all_Increments');
         SELECT :NEW.id INTO last_InsertID FROM DUAL;
         WHILE (last_InsertID > last_Sequence) LOOP
              SELECT SEQ_all_Increments.NEXTVAL INTO last_Sequence FROM DUAL;
         END LOOP;
    END IF;
END;

/* test values */
INSERT INTO all_Increments (id, test) values (1, 'one');
INSERT INTO all_Increments (id, test) values (2, 'two');
INSERT INTO all_Increments (id, test) values (3, 'three');
INSERT INTO all_Increments (id, test) values (10, 'ten');
INSERT INTO all_Increments (test) values ('eleven?');
INSERT INTO all_Increments (id, test) values (5, 'five?');
INSERT INTO all_Increments (test) values ('twelve?');