¿Cómo puedo obtener emacs sql-mode para usar el archivo de configuración de mysql(.my.cnf)?

Question

Cuando mysql dbname en el indicador bash, me conecto automáticamente a la base de datos dbname con el username , la password y la información del dbname incluida en mi archivo .my.cnf .

Cuando uso Mx sql-mysql en emacs, me vuelven a solicitar toda esta información.

¿Hay alguna manera de que pueda obtener el modo sql de emacs para usar la información en mi archivo .my.cnf ?

Answer 1

No creo que esto sea posible, pero puedes configurarlo en la configuración del modo en sí:

(setq sql-connection-alist
''((pool-a
(sql-product ''mysql)
(sql-server "1.2.3.4")
(sql-user "me")
(sql-password "mypassword")
(sql-database "thedb")
(sql-port 3306))
(pool-b
(sql-product ''mysql)
(sql-server "1.2.3.4")
(sql-user "me")
(sql-password "mypassword")
(sql-database "thedb")
(sql-port 3307))))

(defun sql-connect-preset (name)
  "Connect to a predefined SQL connection listed in `sql-connection-alist''"
  (eval `(let ,(cdr (assoc name sql-connection-alist))
    (flet ((sql-get-login (&rest what)))
      (sql-product-interactive sql-product)))))

(defun sql-pool-a ()
  (interactive)
  (sql-connect-preset ''pool-a))

Echa un vistazo a este artículo para más información.

Answer 2

Simplemente presiona return, se recogió por defecto.

Answer 3

Claro que es posible. Aunque es bastante complicado.

Aproximadamente, los pasos son:

1. Lectura y análisis del archivo ini usando ini.el.
2. Fusionando la configuración de los diferentes hosts con la configuración de los clientes porque esta última se aplica globalmente.
3. Transformando cada host a un formato adecuado para sql-connection-alist
4. Poblando sql-connection-alist
5. Usando Mx sql-connect (¡que se completa automáticamente!)

El siguiente código también incluye un analizador .pgpass, por las dudas. Notarás que la implementación es más simple.

;;; .pgpass parser
(defun read-file (file)
  "Returns file as list of lines."
  (with-temp-buffer
    (insert-file-contents file)
    (split-string (buffer-string) "/n" t)))

(defun pgpass-to-sql-connection (config)
  "Returns a suitable list for sql-connection-alist from a pgpass file."
  (append sql-connection-alist
          (let ((server (lambda (host port db user _pass)
                          (list
                           (concat db ":" user ":" port ":" host)
                           (list ''sql-product ''''postgres)
                           (list ''sql-server host)
                           (list ''sql-user user)
                           (list ''sql-port (string-to-number port))
                           (list ''sql-database db))))
                (pgpass-line (lambda (line)
                               (apply server (split-string line ":" t)))))
            (mapcar pgpass-line config))))

;;; .my.cnf parser
;;; Copied verbatim from https://github.com/daniel-ness/ini.el/blob/master/ini.el
(defun ini-decode (ini_text) 
  ;; text -> alist
  (interactive)
  (if (not (stringp ini_text))
      (error "Must be a string"))
  (let ((lines (split-string ini_text "/n"))
    (section)
    (section-list)
    (alist))
    (dolist (l lines)
      ;; skip comments
      (unless (or (string-match "^;" l)
          (string-match "^[ /t]$" l))
    ;; catch sections
    (if (string-match "^//[//(.*//)//]$" l)
        (progn 
          (if section
          ;; add as sub-list
          (setq alist (cons `(,section . ,section-list) alist))
        (setq alist section-list))
          (setq section (match-string 1 l))
          (setq section-list nil)))
          ;; catch properties
          (if (string-match "^//([^/s/t]+//)[/s/t]*=[/s/t]*//(.+//)$" l)
          (let ((property (match-string 1 l))
            (value (match-string 2 l)))
            (progn 
              (setq section-list (cons `(,property . ,value) section-list)))))))
    (if section
    ;; add as sub-list
    (setq alist (cons `(,section . ,section-list) alist))
      (setq alist section-list))
    alist))

(defun read-ini (file)
  "Returns ini file as alist."
  (with-temp-buffer
    (insert-file-contents file)
    (ini-decode (buffer-string))))

(defun filter-alist (wanted-members alist)
  "Returns a copy of given alist, with only fields from wanted-members."
  (let ((result nil)
        (add-if-member (lambda (elt)
                         (when (member (car elt) wanted-members)
                           (add-to-list ''result elt t)))))
    (mapc add-if-member alist)
    result))

(defun merge-alist (original override)
  "Returns a union of original and override alist. On key conflict, the latter wins."
  (let ((result (copy-alist override))
        (add (lambda (elt)
               (setq result (add-to-list
                             ''result elt t
                             (lambda (left right) (equal (car left) (car right))))))))
    (mapc add original)
    result))

(defun map-alist-keys (f alist)
  "Maps on alist''s keys and returns new alist with new keys."
  (mapcar
   (lambda (elt) (list (funcall f (car elt)) (cdr elt)))
   alist))

(defun map-alist-values (f alist)
  "Maps on alist''s values and returns new alist with new values."
  (mapcar
   (lambda (elt) (list (car elt) (funcall f (cdr elt))))
   alist))

(defun parse-mycnf-hosts (file-path)
  "Returns list of hosts with clients'' section applied to all hosts."
  (let ((hosts nil)
        (global nil)
        (fields ''("user" "host" "database" "password" "port"))
        (section-parse (lambda(section)
                         (if (equal (car section) "client")
                             (setq global (filter-alist fields (cdr section)))
                           (let ((host (car section))
                                 (config (filter-alist fields (cdr section))))
                             (when config (add-to-list ''hosts (cons host config) t))))))
        (merge-host-with-global (lambda (host)
                                  (cons (car host) (merge-alist global (cdr host))))))
    (mapc section-parse (read-ini file-path))
    (mapcar merge-host-with-global hosts)))

(defun mycnf-to-sql-connection (config)
  (let ((key-to-sql-connection
         (lambda (key)
           (cond ((equal key "host") ''sql-server)
                 ((equal key "user") ''sql-user)
                 ((equal key "port") ''sql-port)
                 ((equal key "database") ''sql-database)
                 ((equal key "password") ''sql-password)
                 (t (error (format "Unknown key %s" key)))))))
    (map-alist-values
     (apply-partially ''map-alist-keys key-to-sql-connection)
     config)))

;;; Actually populating sql-connection-alist
(setq sql-connection-alist
      (append
       (mycnf-to-sql-connection (parse-mycnf-hosts "~/.my.cnf"))
       (pgpass-to-sql-connection (read-file "~/.pgpass"))
       ))

Con el siguiente .my.cnf :

[client]
user=me

[host1]
database=db1
host=db.host1.com

[host2]
database=db2
user=notme
host=db.host2.com

Ejecutar la expresión (mycnf-to-sql-connection (parse-mycnf-hosts "~/.my.cnf")) me da (bastante impreso a mano):

(("host2" ((sql-server "db.host2.com")
           (sql-user "notme")
           (sql-database "db2")))
 ("host1" ((sql-server "db.host1.com")
           (sql-database "db1")
           (sql-user "me"))))

Finalmente, en lugar de usar Mx sql-mysql , use Mx sql-connect y podrá conectarse usando el alias, con finalización automática.