Gecko [ fernandoquevedodop.com ]

Name	Size	Permission
antlr-mode.elc	77.56 KB	-rw-r--r--
asm-mode.elc	7.42 KB	-rw-r--r--
autoconf.elc	4.55 KB	-rw-r--r--
bat-mode.elc	6.56 KB	-rw-r--r--
bug-reference.elc	7.3 KB	-rw-r--r--
cc-align.elc	39.52 KB	-rw-r--r--
cc-awk.elc	17.95 KB	-rw-r--r--
cc-bytecomp.elc	10.56 KB	-rw-r--r--
cc-cmds.elc	97.51 KB	-rw-r--r--
cc-defs.elc	66.37 KB	-rw-r--r--
cc-engine.elc	231.26 KB	-rw-r--r--
cc-fonts.elc	153.13 KB	-rw-r--r--
cc-guess.elc	13.35 KB	-rw-r--r--
cc-langs.elc	110.05 KB	-rw-r--r--
cc-menus.elc	8.05 KB	-rw-r--r--
cc-mode.elc	227.86 KB	-rw-r--r--
cc-styles.elc	16.66 KB	-rw-r--r--
cc-vars.elc	77.01 KB	-rw-r--r--
cfengine.elc	48.18 KB	-rw-r--r--
cmacexp.elc	6.2 KB	-rw-r--r--
compile.elc	92.53 KB	-rw-r--r--
cperl-mode.elc	212.98 KB	-rw-r--r--
cpp.elc	23.2 KB	-rw-r--r--
cwarn.elc	11.9 KB	-rw-r--r--
dcl-mode.elc	50.32 KB	-rw-r--r--
ebnf-abn.elc	6.95 KB	-rw-r--r--
ebnf-bnf.elc	8.02 KB	-rw-r--r--
ebnf-dtd.elc	13.53 KB	-rw-r--r--
ebnf-ebx.elc	8.12 KB	-rw-r--r--
ebnf-iso.elc	7.77 KB	-rw-r--r--
ebnf-otz.elc	8.47 KB	-rw-r--r--
ebnf-yac.elc	7.4 KB	-rw-r--r--
ebnf2ps.elc	121.12 KB	-rw-r--r--
ebrowse.elc	202.8 KB	-rw-r--r--
elisp-mode.elc	58.74 KB	-rw-r--r--
etags.elc	61.3 KB	-rw-r--r--
executable.elc	7.83 KB	-rw-r--r--
f90.elc	95.13 KB	-rw-r--r--
flymake-cc.elc	3.55 KB	-rw-r--r--
flymake-proc.elc	38.04 KB	-rw-r--r--
flymake.elc	63.5 KB	-rw-r--r--
fortran.elc	59.75 KB	-rw-r--r--
gdb-mi.elc	188.72 KB	-rw-r--r--
glasses.elc	10.37 KB	-rw-r--r--
grep.elc	40.95 KB	-rw-r--r--
gud.elc	98.55 KB	-rw-r--r--
hideif.elc	48.36 KB	-rw-r--r--
hideshow.elc	25.56 KB	-rw-r--r--
icon.elc	16.75 KB	-rw-r--r--
idlw-complete-structtag.elc	4.22 KB	-rw-r--r--
idlw-help.elc	35.91 KB	-rw-r--r--
idlw-shell.elc	129.89 KB	-rw-r--r--
idlw-toolbar.elc	27.44 KB	-rw-r--r--
idlwave.elc	250.95 KB	-rw-r--r--
inf-lisp.elc	21.06 KB	-rw-r--r--
js.elc	176.3 KB	-rw-r--r--
ld-script.elc	5.44 KB	-rw-r--r--
m4-mode.elc	6.34 KB	-rw-r--r--
make-mode.elc	62.21 KB	-rw-r--r--
meta-mode.elc	31.41 KB	-rw-r--r--
mixal-mode.elc	36.18 KB	-rw-r--r--
modula2.elc	30.37 KB	-rw-r--r--
octave.elc	63.2 KB	-rw-r--r--
opascal.elc	52.47 KB	-rw-r--r--
pascal.elc	39.22 KB	-rw-r--r--
perl-mode.elc	29.41 KB	-rw-r--r--
prog-mode.elc	15.82 KB	-rw-r--r--
project.elc	17.06 KB	-rw-r--r--
prolog.elc	85.47 KB	-rw-r--r--
ps-mode.elc	33 KB	-rw-r--r--
python.elc	178.17 KB	-rw-r--r--
ruby-mode.elc	63.86 KB	-rw-r--r--
scheme.elc	18.81 KB	-rw-r--r--
sh-script.elc	116.3 KB	-rw-r--r--
simula.elc	44.83 KB	-rw-r--r--
sql.elc	182.59 KB	-rw-r--r--
subword.elc	18.77 KB	-rw-r--r--
tcl.elc	40.14 KB	-rw-r--r--
vera-mode.elc	45.08 KB	-rw-r--r--
verilog-mode.elc	450.39 KB	-rw-r--r--
vhdl-mode.elc	528.7 KB	-rw-r--r--
which-func.elc	10.4 KB	-rw-r--r--
xref.elc	56.91 KB	-rw-r--r--
xscheme.elc	38 KB	-rw-r--r--

Code Editor : sql.elc

;ELC���
;;; Compiled
;;; in Emacs version 27.1
;;; with all optimizations.

;;; This file contains utf-8 non-ASCII characters,
;;; and so cannot be loaded into Emacs 22 or earlier.
(and (boundp 'emacs-version)
     (< (aref emacs-version (1- (length emacs-version))) ?A)
     (string-lessp emacs-version "23")
     (error "`%s' was compiled for Emacs 23 or later" #$))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(byte-code "\300\301!\210\300\302!\210\300\303!\210\300\304!\210\300\305!\210\306\307\310\311\312\313\314\315\314\316&	\210\317\320\321\322\323DD\324\325\326\314\307\327\330&	\210\317\331\321\322\332DD\333\325\326\314\307\334\335&	\210\317\336\321\322\337DD\340\325\326\314\307\327\330&	\210\317\341\321\322\342DD\343\325\326\314\307\327\330&	\210\317\344\321\322\345DD\346\312\347\325\350\314\307\327\351&\210\317\352\321\322\353DD\354\312\355\325\356\314\307\327\330&\210\357\360\361\362\363\364\325\365&\207" [require cl-lib comint custom thingatpt view custom-declare-group SQL nil "Running a SQL interpreter from within Emacs buffers." :version "20.4" :group languages processes custom-declare-variable sql-user funcall function #[0 "\300\207" [#1=""] 1 #1#] "Default username." :type string :safe stringp sql-password #[0 "\300\207" [#1#] 1 #1#] "Default password.\nIf you customize this, the value will be stored in your init\nfile.  Since that is a plaintext file, this could be dangerous." :risky t sql-database #[0 "\300\207" [#1#] 1 #1#] "Default database." sql-server #[0 "\300\207" [#1#] 1 #1#] "Default server or host." sql-port #[0 "\300\207" [0] 1] "Default port for connecting to a MySQL or Postgres server." "24.1" number numberp sql-default-directory #[0 "\300\207" [nil] 1] "Default directory for SQL processes." "25.1" (choice (const nil) string) define-widget sql-login-params lazy "Widget definition of the login parameters list" :tag "Login Parameters" (set :tag "Login Parameters" (choice :tag "user" :value user (const user) (list :tag "Specify a default" (const user) (list :tag "Default" :inline t (const :default) string))) (const password) (choice :tag "server" :value server (const server) (list :tag "Specify a default" (const server) (list :tag "Default" :inline t (const :default) string)) (list :tag "file" (const :format #1# server) (const :format #1# :file) regexp) (list :tag "completion" (const :format #1# server) (const :format #1# :completion) (const :format #1# :must-match) (restricted-sexp :match-alternatives (listp stringp)))) (choice :tag "database" :value database (const database) (list :tag "Specify a default" (const database) (list :tag "Default" :inline t (const :default) string)) (list :tag "file" (const :format #1# database) (const :format #1# :file) (choice (const nil) regexp) (const :format #1# :must-match) (symbol :tag ":must-match")) (list :tag "completion" (const :format #1# database) (const :format #1# :default) (string :tag ":default") (const :format #1# :completion) (sexp :tag ":completion") (const :format #1# :must-match) (restricted-sexp :match-alternatives (listp stringp)))) (const port))] 12)
#@39 Product under `sql-interactive-mode'.
(defvar sql-interactive-product nil (#$ . 3081))
#@66 Connection name if interactive session started by `sql-connect'.
(defvar sql-connection nil (#$ . 3174))
#@5532 An alist of product specific configuration settings.

Without an entry in this list a product will not be properly
highlighted and will not support `sql-interactive-mode'.

Each element in the list is in the following format:

(PRODUCT FEATURE VALUE ...)

where PRODUCT is the appropriate value of `sql-product'.  The
product name is then followed by FEATURE-VALUE pairs.  If a
FEATURE is not specified, its VALUE is treated as nil.  FEATURE
may be any one of the following:

:name                  string containing the displayable name of
                        the product.

:free-software         is the product Free (as in Freedom) software?

:font-lock             name of the variable containing the product
                        specific font lock highlighting patterns.

:sqli-program          name of the variable containing the product
                        specific interactive program name.

:sqli-options          name of the variable containing the list
                        of product specific options.

:sqli-login            name of the variable containing the list of
                        login parameters (i.e., user, password,
                        database and server) needed to connect to
                        the database.

:sqli-comint-func      function of two arguments, PRODUCT
                        and OPTIONS, that will open a comint buffer
                        and connect to the database.  PRODUCT is the
                        first argument to be passed to `sql-comint',
                        and OPTIONS should be included in its second
                        argument.  The function should use the values
                        of `sql-user', `sql-password', `sql-database',
                        `sql-server' and `sql-port' to .  Do product
                        specific configuration of comint in this
                        function.  See `sql-comint-oracle' for an
                        example of such a function.

:list-all              Command string or function which produces
                        a listing of all objects in the database.
                        If it's a cons cell, then the car
                        produces the standard list of objects and
                        the cdr produces an enhanced list of
                        objects.  What "enhanced" means is
                        dependent on the SQL product and may not
                        exist.  In general though, the
                        "enhanced" list should include visible
                        objects from other schemas.

:list-table            Command string or function which produces
                        a detailed listing of a specific database
                        table.  If its a cons cell, then the car
                        produces the standard list and the cdr
                        produces an enhanced list.

:completion-object     A function that returns a list of
                        objects.  Called with a single
                        parameter--if nil then list objects
                        accessible in the current schema, if
                        not-nil it is the name of a schema whose
                        objects should be listed.

:completion-column     A function that returns a list of
                        columns.  Called with a single
                        parameter--if nil then list objects
                        accessible in the current schema, if
                        not-nil it is the name of a schema whose
                        objects should be listed.

:prompt-regexp         regular expression string that matches
                        the prompt issued by the product
                        interpreter.

:prompt-length         length of the prompt on the line.

:prompt-cont-regexp    regular expression string that matches
                        the continuation prompt issued by the
                        product interpreter.

:input-filter          function which can filter strings sent to
                        the command interpreter.  It is also used
                        by the `sql-send-string',
                        `sql-send-region', `sql-send-paragraph'
                        and `sql-send-buffer' functions.  The
                        function is passed the string sent to the
                        command interpreter and must return the
                        filtered string.  May also be a list of
                        such functions.

:statement             name of a variable containing a regexp that
                        matches the beginning of SQL statements.

:terminator            the terminator to be sent after a
                        `sql-send-string', `sql-send-region',
                        `sql-send-paragraph' and
                        `sql-send-buffer' command.  May be the
                        literal string or a cons of a regexp to
                        match an existing terminator in the
                        string and the terminator to be used if
                        its absent.  By default ";".

:syntax-alist          alist of syntax table entries to enable
                        special character treatment by font-lock
                        and imenu.

Other features can be stored but they will be ignored.  However,
you can develop new functionality which is product independent by
using `sql-get-product-feature' to lookup the product specific
settings.
(defvar sql-product-alist '((ansi :name "ANSI" :font-lock sql-mode-ansi-font-lock-keywords :statement sql-ansi-statement-starters) (db2 :name "DB2" :font-lock sql-mode-db2-font-lock-keywords :sqli-program sql-db2-program :sqli-options sql-db2-options :sqli-login sql-db2-login-params :sqli-comint-func sql-comint-db2 :prompt-regexp "^db2 => " :prompt-length 7 :prompt-cont-regexp "^db2 (cont\\.) => " :input-filter sql-escape-newlines-filter) (informix :name "Informix" :font-lock sql-mode-informix-font-lock-keywords :sqli-program sql-informix-program :sqli-options sql-informix-options :sqli-login sql-informix-login-params :sqli-comint-func sql-comint-informix :prompt-regexp "^> " :prompt-length 2 :syntax-alist ((123 . "<") (125 . ">"))) (ingres :name "Ingres" :font-lock sql-mode-ingres-font-lock-keywords :sqli-program sql-ingres-program :sqli-options sql-ingres-options :sqli-login sql-ingres-login-params :sqli-comint-func sql-comint-ingres :prompt-regexp "^\\* " :prompt-length 2 :prompt-cont-regexp "^\\* ") (interbase :name "Interbase" :font-lock sql-mode-interbase-font-lock-keywords :sqli-program sql-interbase-program :sqli-options sql-interbase-options :sqli-login sql-interbase-login-params :sqli-comint-func sql-comint-interbase :prompt-regexp "^SQL> " :prompt-length 5) (linter :name "Linter" :font-lock sql-mode-linter-font-lock-keywords :sqli-program sql-linter-program :sqli-options sql-linter-options :sqli-login sql-linter-login-params :sqli-comint-func sql-comint-linter :prompt-regexp "^SQL>" :prompt-length 4) (mariadb :name "MariaDB" :free-software t :font-lock sql-mode-mariadb-font-lock-keywords :sqli-program sql-mariadb-program :sqli-options sql-mariadb-options :sqli-login sql-mariadb-login-params :sqli-comint-func sql-comint-mariadb :list-all "SHOW TABLES;" :list-table "DESCRIBE %s;" :prompt-regexp "^MariaDB \\[.*]> " :prompt-cont-regexp "^    [\"'`-]> " :syntax-alist ((35 . "< b")) :input-filter sql-remove-tabs-filter) (ms :name "Microsoft" :font-lock sql-mode-ms-font-lock-keywords :sqli-program sql-ms-program :sqli-options sql-ms-options :sqli-login sql-ms-login-params :sqli-comint-func sql-comint-ms :prompt-regexp "^[0-9]*>" :prompt-cont-regexp "^[0-9]*>" :prompt-length 5 :syntax-alist ((64 . "_")) :terminator ("^go" . "go")) (mysql :name "MySQL" :free-software t :font-lock sql-mode-mysql-font-lock-keywords :sqli-program sql-mysql-program :sqli-options sql-mysql-options :sqli-login sql-mysql-login-params :sqli-comint-func sql-comint-mysql :list-all "SHOW TABLES;" :list-table "DESCRIBE %s;" :prompt-regexp "^mysql> " :prompt-length 6 :prompt-cont-regexp "^    -> " :syntax-alist ((35 . "< b")) :input-filter sql-remove-tabs-filter) (oracle :name "Oracle" :font-lock sql-mode-oracle-font-lock-keywords :sqli-program sql-oracle-program :sqli-options sql-oracle-options :sqli-login sql-oracle-login-params :sqli-comint-func sql-comint-oracle :list-all sql-oracle-list-all :list-table sql-oracle-list-table :completion-object sql-oracle-completion-object :prompt-regexp "^SQL> " :prompt-length 5 :prompt-cont-regexp "^\$?:[ ][ ][1-9]\\|[ ][1-9][0-9]\\|[1-9][0-9]\\{2\\}\$[ ]\\{2\\}" :statement sql-oracle-statement-starters :syntax-alist ((36 . "_") (35 . "_")) :terminator ("\$^/\\|;\$" . "/") :input-filter sql-placeholders-filter) (postgres :name "Postgres" :free-software t :font-lock sql-mode-postgres-font-lock-keywords :sqli-program sql-postgres-program :sqli-options sql-postgres-options :sqli-login sql-postgres-login-params :sqli-comint-func sql-comint-postgres :list-all ("\\d+" . "\\dS+") :list-table ("\\d+ %s" . "\\dS+ %s") :completion-object sql-postgres-completion-object :prompt-regexp "^[[:alnum:]_]*=[#>] " :prompt-length 5 :prompt-cont-regexp "^[[:alnum:]_]*[-(][#>] " :input-filter sql-remove-tabs-filter :terminator ("\$^\\s-*\\\\g\\|;\$" . "\\g")) (solid :name "Solid" :font-lock sql-mode-solid-font-lock-keywords :sqli-program sql-solid-program :sqli-options sql-solid-options :sqli-login sql-solid-login-params :sqli-comint-func sql-comint-solid :prompt-regexp "^" :prompt-length 0) (sqlite :name "SQLite" :free-software t :font-lock sql-mode-sqlite-font-lock-keywords :sqli-program sql-sqlite-program :sqli-options sql-sqlite-options :sqli-login sql-sqlite-login-params :sqli-comint-func sql-comint-sqlite :list-all ".tables" :list-table ".schema %s" :completion-object sql-sqlite-completion-object :prompt-regexp "^sqlite> " :prompt-length 8 :prompt-cont-regexp "^   \\.\\.\\.> ") (sybase :name "Sybase" :font-lock sql-mode-sybase-font-lock-keywords :sqli-program sql-sybase-program :sqli-options sql-sybase-options :sqli-login sql-sybase-login-params :sqli-comint-func sql-comint-sybase :prompt-regexp "^SQL> " :prompt-length 5 :syntax-alist ((64 . "_")) :terminator ("^go" . "go")) (vertica :name "Vertica" :sqli-program sql-vertica-program :sqli-options sql-vertica-options :sqli-login sql-vertica-login-params :sqli-comint-func sql-comint-vertica :list-all ("\\d" . "\\dS") :list-table "\\d %s" :prompt-regexp "^[[:alnum:]_]*=[#>] " :prompt-length 5 :prompt-cont-regexp "^[[:alnum:]_]*[-(][#>] ")) (#$ . 3287))
(defvar sql-indirect-features '(:font-lock :sqli-program :sqli-options :sqli-login :statement))
(byte-code "\301\302\303\304\305DD\306\307\310\311\312\313\314\315\316\317\320\321\"BE\322BB\257\323\324\325\326&	\210\327\330\331\"\210\301\331\303\304\332DD\333\307\317\320\334\"B\325\326\335\336&	\210\301\337\303\304\340DD\341\325\326\342\343\307\344\323\345&\207" [sql-product-alist custom-declare-variable sql-connection-alist funcall function #[0 "\300\207" [nil] 1] "An alist of connection parameters for interacting with a SQL product.\nEach element of the alist is as follows:\n\n  (CONNECTION (SQL-VARIABLE VALUE) ...)\n\nWhere CONNECTION is a case-insensitive string identifying the\nconnection, SQL-VARIABLE is the symbol name of a SQL mode\nvariable, and VALUE is the value to be assigned to the variable.\nThe most common SQL-VARIABLE settings associated with a\nconnection are: `sql-product', `sql-user', `sql-password',\n`sql-port', `sql-server', and `sql-database'.\n\nIf a SQL-VARIABLE is part of the connection, it will not be\nprompted for during login.  The command `sql-connect' starts a\npredefined SQLi session using the parameters from this list.\nConnections defined here appear in the submenu SQL->Start...  for\nmaking new SQLi sessions." :type alist :key-type (string :tag "Connection") :value-type set group (const :tag "Product" sql-product) choice mapcar #[257 "\300\301\302A\303\"\206�\304\305@!!\306@DF\207" [const :tag plist-get :name capitalize symbol-name quote] 6 "\n\n(fn PROD-INFO)"] ((group (const :tag "Username" sql-user) string) (group (const :tag "Password" sql-password) string) (group (const :tag "Server" sql-server) string) (group (const :tag "Database" sql-database) string) (group (const :tag "Port" sql-port) integer) (repeat :inline t (list :tab "Other" (symbol :tag " Variable Symbol") (sexp :tag "Value Expression")))) :version "24.1" :group SQL defvaralias sql-dialect sql-product #[0 "\300\207" [ansi] 1] "Select the SQL database product used.\nThis allows highlighting buffers properly when you open them." #[257 "\300\301\302A\303\"\206�\304\305@!!@F\207" [const :tag plist-get :name capitalize symbol-name] 6 "\n\n(fn PROD-INFO)"] :safe symbolp sql-use-indent-support #[0 "\300\207" [t] 1] "If non-nil then use the SQL indent support features of sql-indent.\nThe `sql-indent' package in ELPA provides indentation support for\nSQL statements with easy customizations to support varied layout\nrequirements.\n\nThe package must be available to be loaded and activated." :link (url-link "https://elpa.gnu.org/packages/sql-indent.html") boolean "27.1"] 16)
#@56 Enable `sqlind-minor-mode' if available and requested.
(defalias 'sql-indent-enable #[0 "\301\302!\205�\302\203�\303\202�\304!\207" [sql-use-indent-support fboundp sqlind-minor-mode 1 -1] 2 (#$ . 16541)])
(require 'auth-source)
#@264 Read auth source WALLET to locate the USER secret.
Sets `auth-sources' to WALLET and uses `auth-source-search' to locate the entry.
The DATABASE and SERVER are concatenated with a slash between them as the
host key.

(fn WALLET PRODUCT USER SERVER DATABASE PORT)
(defalias 'sql-auth-source-search-wallet #[1542 "\301\211\211\211\302	!\262	\211\303\230\262?\205�\262\205.�\247\205.�\304U?\205.�\305!\262\211\303\230\262?\205=�\262\211\303\230\262?\205J�\262\203c�\203^�\306Q\202d�\202d�\262\307\310\311\"\211\203O\211@\n\203\206�\312\313\"\203\212�\314\313\"\232\202\207�\315\203H	\203\240�\312\316\"\203\244�\314\316\"\n\232\202\241�\315\203H\203\272�\312\317\"\203\276�\314\317\"\232\202\273�\315\203H\203\333�\312\320\"\203\333�\314\320\"\232\203\333�\211B\262\202H\203\312\321\"\203\203\312\322\"\203\314\321\"	\232\203\314\322\"\232\203\211B\262\202H\203-\312\321\"\203-\314\321\"	\232\203-\211B\262\202H\203H\312\322\"\203H\314\322\"\232\203H\211B\262A\266\202\202j�\210\206Y\211\206Y\262G\323U\205q@\262\312\324\"\205q\314\324\")\207" [auth-sources nil symbol-name "" 0 number-to-string "/" auth-source-search :max 1000 plist-member :product plist-get t :user :port :host :server :database 1 :secret] 15 (#$ . 16780)])
(byte-code "\300\301\302\303\304DD\305\306\307\310\311\312\313&	\207" [custom-declare-variable sql-password-wallet funcall function #[0 "\300\211\301\211\203'�\211@\204 �\302\303P\304P\"\262\305!\203 �\262A\266\202\202�\262\207" [nil (".json.gpg" ".gpg" ".json" "") locate-user-emacs-file "sql-wallet" ".sql-wallet" file-exists-p] 8] "Identification of the password wallet.\nSee `sql-password-search-wallet-function' to understand how this value\nis used to locate the password wallet." :type (plist-get (symbol-plist 'auth-sources) 'custom-type) :group SQL :version "27.1"] 10)
#@449 Function to handle the lookup of the database password.
The specified function will be called as:
  (wallet-func WALLET PRODUCT USER SERVER DATABASE PORT)

It is expected to return either a string containing the password,
a function returning the password, or nil.  If you want to support
another format of password file, then implement a different
search wallet function and identify the location of the password
store with `sql-password-wallet'.
(defvar sql-password-search-wallet-function 'sql-auth-source-search-wallet (#$ . 18726))
(byte-code "\300\301\302\303\304DD\305\306\307\310\311\312\313&	\210\300\314\302\303\315DD\316\306\317\310\320\312\313&	\207" [custom-declare-variable sql-electric-stuff funcall function #[0 "\300\207" [nil] 1] "Treat some input as electric.\nIf set to the symbol `semicolon', then hitting `;' will send current\ninput in the SQLi buffer to the process.\nIf set to the symbol `go', then hitting `go' on a line by itself will\nsend current input in the SQLi buffer to the process.\nIf set to nil, then you must use \\[comint-send-input] in order to send\ncurrent input in the SQLi buffer to the process." :type (choice (const :tag "Nothing" nil) (const :tag "The semicolon `;'" semicolon) (const :tag "The string `go' by itself" go)) :version "20.8" :group SQL sql-send-terminator #[0 "\300\207" [nil] 1] "When non-nil, add a terminator to text sent to the SQL interpreter.\n\nWhen text is sent to the SQL interpreter (via `sql-send-string',\n`sql-send-region', `sql-send-paragraph' or `sql-send-buffer'), a\ncommand terminator can be automatically sent as well.  The\nterminator is not sent, if the string sent already ends with the\nterminator.\n\nIf this value is t, then the default command terminator for the\nSQL interpreter is sent.  If this value is a string, then the\nstring is sent.\n\nIf the value is a cons cell of the form (PAT . TERM), then PAT is\na regexp used to match the terminator in the string and TERM is\nthe terminator to be sent.  This form is useful if the SQL\ninterpreter has more than one way of submitting a SQL command.\nThe PAT regexp can match any of them, and TERM is the way we do\nit automatically." (choice (const :tag "No Terminator" nil) (const :tag "Default Terminator" t) (string :tag "Terminator String") (cons :tag "Terminator Pattern and String" (string :tag "Terminator Pattern") (string :tag "Terminator String"))) "22.2"] 10)
#@170 When non-nil, the current buffer contains database names.

Globally should be set to nil; it will be non-nil in `sql-mode',
`sql-interactive-mode' and list all buffers.
(defvar sql-contains-names nil (#$ . 21143))
#@75 Maximum number of seconds you are willing to wait for a login connection.
(defvar sql-login-delay 7.5 (#$ . 21363))
(byte-code "\300\301\302\"\210\303\302\304\305\306DD\307\310\311\312\313\314\315&	\207" [defvaralias sql-pop-to-buffer-after-send-region sql-display-sqli-buffer-function custom-declare-variable funcall function #[0 "\300\207" [display-buffer] 1] "Function to be called to display a SQLi buffer after `sql-send-*'.\n\nWhen set to a function, it will be called to display the buffer.\nWhen set to t, the default function `pop-to-buffer' will be\ncalled.  If not set, no attempt will be made to display the\nbuffer." :type (choice (const :tag "Default" t) (const :tag "No display" nil) (function :tag "Display Buffer function")) :version "27.1" :group SQL] 10)
#@279 Define interesting points in the SQL buffer for `imenu'.

This is used to set `imenu-generic-expression' when SQL mode is
entered.  Subsequent changes to `sql-imenu-generic-expression' will
not affect existing SQL buffers because `imenu-generic-expression' is
a local variable.
(defvar sql-imenu-generic-expression '(("Rules/Defaults" "^\\s-*create\\s-+\$?:\\w+\\s-+\$*\$?:rule\\|default\$\$?:if\\s-+not\\s-+exists\\s-+\$?\\s-+\$\\(?:\\w+\\s-*[.]\\s-*\$*\\w+\\)" 1) ("Sequences" "^\\s-*create\\s-+\$?:\\w+\\s-+\$*sequence\\s-+\$?:if\\s-+not\\s-+exists\\s-+\$?\$\\(?:\\w+\\s-*[.]\\s-*\$*\\w+\\)" 1) ("Triggers" "^\\s-*create\\s-+\$?:\\w+\\s-+\$*trigger\\s-+\$?:if\\s-+not\\s-+exists\\s-+\$?\$\\(?:\\w+\\s-*[.]\\s-*\$*\\w+\\)" 1) ("Functions" "^\\s-*\$?:create\\s-+\\(?:\\w+\\s-+\$*\\)?function\\s-+\$?:if\\s-+not\\s-+exists\\s-+\$?\$\\(?:\\w+\\s-*[.]\\s-*\$*\\w+\\)" 1) ("Procedures" "^\\s-*\$?:create\\s-+\\(?:\\w+\\s-+\$*\\)?proc\$?:edure\$?\\s-+\$?:if\\s-+not\\s-+exists\\s-+\$?\$\\(?:\\w+\\s-*[.]\\s-*\$*\\w+\\)" 1) ("Packages" "^\\s-*create\\s-+\$?:\\w+\\s-+\$*package\\s-+\$?:body\\s-+\$?\$?:if\\s-+not\\s-+exists\\s-+\$?\$\\(?:\\w+\\s-*[.]\\s-*\$*\\w+\\)" 1) ("Types" "^\\s-*create\\s-+\$?:\\w+\\s-+\$*type\\s-+\$?:body\\s-+\$?\$?:if\\s-+not\\s-+exists\\s-+\$?\$\\(?:\\w+\\s-*[.]\\s-*\$*\\w+\\)" 1) ("Indexes" "^\\s-*create\\s-+\$?:\\w+\\s-+\$*index\\s-+\$?:if\\s-+not\\s-+exists\\s-+\$?\$\\(?:\\w+\\s-*[.]\\s-*\$*\\w+\\)" 1) ("Tables/Views" "^\\s-*create\\s-+\$?:\\w+\\s-+\$*\$?:table\\|view\$\\s-+\$?:if\\s-+not\\s-+exists\\s-+\$?\$\\(?:\\w+\\s-*[.]\\s-*\$*\\w+\\)" 1)) (#$ . 22144))
(byte-code "\300\301\302\303\304DD\305\306\307\310\311&\210\300\312\302\303\313DD\314\306\315\310\311&\210\300\316\302\303\317DD\320\306\321\310\311\322\323&	\210\300\324\302\303\325DD\326\306\321\310\311\322\323&	\210\300\327\302\303\330DD\331\306\321\310\311&\210\300\332\302\303\333DD\334\322\335\306\321\310\311&	\210\300\336\302\303\337DD\340\322\335\306\315\310\311&	\210\300\341\302\303\342DD\343\306\344\310\311&\210\300\345\302\303\346DD\347\306\350\322\351\310\311&	\210\300\352\302\303\353DD\354\306\355\322\335\310\311&	\210\300\356\302\303\357DD\360\322\335\306\315\310\311&	\210\300\361\302\303\362DD\363\322\335\306\364\310\311&	\210\300\365\302\303\366DD\367\322\370\306\364\310\311&	\210\300\371\302\303\372DD\373\306\344\310\311&\210\300\374\302\303\375DD\376\306\377\322\201@�\310\311&	\210\300\201A�\302\303\201B�DD\201C�\306\355\322\201D�\310\311&	\210\201E�\201F�\201G�\"\210\201E�\201H�\201I�\"\210\201E�\201J�\201K�\"\210\300\201G�\302\303\201L�DD\201M�\306\344\310\311&\210\300\201I�\302\303\201N�DD\201O�\306\201P�\322\201@�\310\311&	\210\300\201K�\302\303\201Q�DD\201R�\306\355\322\335\310\311&	\210\300\201S�\302\303\201T�DD\201U�\306\344\310\311&\210\300\201V�\302\303\201W�DD\201X�\306\355\322\335\310\311&	\210\300\201Y�\302\303\201Z�DD\201[�\306\344\310\311&\210\300\201\\�\302\303\201]�DD\201^�\306\201_�\322\201@�\310\311&	\210\300\201`�\302\303\201a�DD\201b�\306\355\322\335\310\311&	\210\300\201c�\302\303\201d�DD\201e�\306\344\310\311&\210\300\201f�\302\303\201g�DD\201h�\306\355\322\335\310\311&	\210\300\201i�\302\303\201j�DD\201k�\306\344\310\311&\210\300\201l�\302\303\201m�DD\201n�\306\355\322\335\310\311&	\210\300\201o�\302\303\201p�DD\201q�\306\344\310\311&\210\300\201r�\302\303\201s�DD\201t�\306\201u�\322\201v�\310\311&	\210\300\201w�\302\303\201x�DD\201y�\306\355\322\335\310\311&	\210\300\201z�\302\303\201{�DD\201|�\306\344\310\311&\210\300\201}�\302\303\201~�DD\201�\306\201\200�\322\201@�\310\311&	\210\300\201\201�\302\303\201\202�DD\201\203�\306\355\322\201D�\310\311&	\207" [custom-declare-variable sql-input-ring-file-name funcall function #[0 "\300\207" [nil] 1] "If non-nil, name of the file to read/write input history.\n\nYou have to set this variable if you want the history of your commands\nsaved from one Emacs session to the next.  If this variable is set,\nexiting the SQL interpreter in an SQLi buffer will write the input\nhistory to the specified file.  Starting a new process in a SQLi buffer\nwill read the input history from the specified file.\n\nThis is used to initialize `comint-input-ring-file-name'.\n\nNote that the size of the input history is determined by the variable\n`comint-input-ring-size'." :type (choice (const :tag "none" nil) (file)) :group SQL sql-input-ring-separator #[0 "\300\207" [#1="\n--\n"] 1 #1#] "Separator between commands in the history file.\n\nIf set to \"\\n\", each line in the history file will be interpreted as\none command.  Multi-line commands are split into several commands when\nthe input ring is initialized from a history file.\n\nThis variable used to initialize `comint-input-ring-separator'.\n`comint-input-ring-separator' is part of Emacs 21; if your Emacs\ndoes not have it, setting `sql-input-ring-separator' will have no\neffect.  In that case multiline commands will be split into several\ncommands when the input history is read, as if you had set\n`sql-input-ring-separator' to \"\\n\"." string sql-interactive-mode-hook #[0 "\300\207" [(sql-indent-enable)] 1] "Hook for customizing `sql-interactive-mode'." hook :version "27.1" sql-mode-hook #[0 "\300\207" [(sql-indent-enable)] 1] "Hook for customizing `sql-mode'." sql-set-sqli-hook #[0 "\300\207" [nil] 1] "Hook for reacting to changes of `sql-buffer'.\n\nThis is called by `sql-set-sqli-buffer' when the value of `sql-buffer'\nis changed." sql-login-hook #[0 "\300\207" [nil] 1] "Hook for interacting with a buffer in `sql-interactive-mode'.\n\nThis hook is invoked in a buffer once it is ready to accept input\nfor the first time." "24.1" sql-ansi-statement-starters #[0 "\300\207" ["\$?:alter\\|create\\|d\\(?:elete\\|rop\$\\|grant\\|insert\\|merge\\|revoke\\|select\\|update\\)"] 1] "Regexp of keywords that start SQL commands.\n\nAll products share this list; products should define a regexp to\nidentify additional keywords in a variable defined by\nthe :statement feature." sql-oracle-program #[0 "\300\207" [#2="sqlplus"] 1 #2#] "Command to start sqlplus by Oracle.\n\nStarts `sql-interactive-mode' after doing some setup.\n\nOn Windows, \"sqlplus\" usually starts the sqlplus \"GUI\".  In order\nto start the sqlplus console, use \"plus33\" or something similar.\nYou will find the file in your Orant\\bin directory." file sql-oracle-options #[0 "\300\207" [("-L")] 1] "List of additional options for `sql-oracle-program'." (repeat string) "24.4" sql-oracle-login-params #[0 "\300\207" [(user password database)] 1] "List of login parameters needed to connect to Oracle." sql-login-params sql-oracle-statement-starters #[0 "\300\207" ["\$?:begin\\|declare\\|with\$"] 1] "Additional statement starting keywords in Oracle." sql-oracle-scan-on #[0 "\300\207" [t] 1] "Non-nil if placeholders should be replaced in Oracle SQLi.\n\nWhen non-nil, Emacs will scan text sent to sqlplus and prompt\nfor replacement text for & placeholders as sqlplus does.  This\nis needed on Windows where SQL*Plus output is buffered and the\nprompts are not shown until after the text is entered.\n\nYou need to issue the following command in SQL*Plus to be safe:\n\n    SET DEFINE OFF\n\nIn older versions of SQL*Plus, this was the SET SCAN OFF command." boolean sql-db2-escape-newlines #[0 "\300\207" [nil] 1] "Non-nil if newlines should be escaped by a backslash in DB2 SQLi.\n\nWhen non-nil, Emacs will automatically insert a space and\nbackslash prior to every newline in multi-line SQL statements as\nthey are submitted to an interactive DB2 session." "24.3" sql-sqlite-program #[0 "\300\301!\206
�\300\302!\206
�\302\207" [executable-find "sqlite3" "sqlite"] 2] "Command to start SQLite.\n\nStarts `sql-interactive-mode' after doing some setup." sql-sqlite-options #[0 "\300\207" [nil] 1] "List of additional options for `sql-sqlite-program'." (repeat string) "20.8" sql-sqlite-login-params #[0 "\300\207" [((database :file nil :must-match confirm))] 1] "List of login parameters needed to connect to SQLite." "26.1" defvaralias sql-mariadb-program sql-mysql-program sql-mariadb-options sql-mysql-options sql-mariadb-login-params sql-mysql-login-params #[0 "\300\207" [#3="mysql"] 1 #3#] "Command to start mysql by Oracle.\n\nStarts `sql-interactive-mode' after doing some setup." #[0 "\300\207" [nil] 1] "List of additional options for `sql-mysql-program'.\nThe following list of options is reported to make things work\non Windows: \"-C\" \"-t\" \"-f\" \"-n\"." (repeat string) #[0 "\300\207" [(user password database server)] 1] "List of login parameters needed to connect to MySQL." sql-solid-program #[0 "\300\207" [#4="solsql"] 1 #4#] "Command to start SOLID SQL Editor.\n\nStarts `sql-interactive-mode' after doing some setup." sql-solid-login-params #[0 "\300\207" [(user password server)] 1] "List of login parameters needed to connect to Solid." sql-sybase-program #[0 "\300\207" [#5="isql"] 1 #5#] "Command to start isql by Sybase.\n\nStarts `sql-interactive-mode' after doing some setup." sql-sybase-options #[0 "\300\207" [nil] 1] "List of additional options for `sql-sybase-program'.\nSome versions of isql might require the -n option in order to work." (repeat string) sql-sybase-login-params #[0 "\300\207" [(server user password database)] 1] "List of login parameters needed to connect to Sybase." sql-informix-program #[0 "\300\207" [#6="dbaccess"] 1 #6#] "Command to start dbaccess by Informix.\n\nStarts `sql-interactive-mode' after doing some setup." sql-informix-login-params #[0 "\300\207" [(database)] 1] "List of login parameters needed to connect to Informix." sql-ingres-program #[0 "\300\207" [#7="sql"] 1 #7#] "Command to start sql by Ingres.\n\nStarts `sql-interactive-mode' after doing some setup." sql-ingres-login-params #[0 "\300\207" [(database)] 1] "List of login parameters needed to connect to Ingres." sql-ms-program #[0 "\300\207" [#8="osql"] 1 #8#] "Command to start osql by Microsoft.\n\nStarts `sql-interactive-mode' after doing some setup." sql-ms-options #[0 "\300\207" [("-w" "300" "-n")] 1] "List of additional options for `sql-ms-program'." (repeat string) "22.1" sql-ms-login-params #[0 "\300\207" [(user password server database)] 1] "List of login parameters needed to connect to Microsoft." sql-postgres-program #[0 "\300\207" [#9="psql"] 1 #9#] "Command to start psql by Postgres.\n\nStarts `sql-interactive-mode' after doing some setup." sql-postgres-options #[0 "\300\207" [("-P" "pager=off")] 1] "List of additional options for `sql-postgres-program'.\nThe default setting includes the -P option which breaks older versions\nof the psql client (such as version 6.5.3).  The -P option is equivalent\nto the --pset option.  If you want the psql to prompt you for a user\nname, add the string \"-u\" to the list of options.  If you want to\nprovide a user name on the command line (newer versions such as 7.1),\nadd your name with a \"-U\" prefix (such as \"-Umark\") to the list." (repeat string) sql-postgres-login-params #[0 "\300\301\302 E\303\301\302 \304\305\306!\307BBBBB\310BB\207" [user :default user-login-name database :completion completion-table-dynamic #[257 "\300 \207" [sql-postgres-list-databases] 2 "\n\n(fn _)"] (:must-match confirm) (server)] 7] "List of login parameters needed to connect to Postgres."] 10)
#@50 Return a list of available PostgreSQL databases.
(defalias 'sql-postgres-list-databases #[0 "\301!\205<�\302\30313�\304\305\306\307$\211\205-�\211@\310\311\"\203&�\312\313\"B\262A\266\202\202�\2620\2027�\210\2028�\210\211\237\262\207" [sql-postgres-program executable-find nil (error) process-lines "--list" "--no-psqlrc" "--tuples-only" string-match "^ \$[^ |]+\$ +|.*" match-string 1] 6 (#$ . 33479)])
(byte-code "\300\301\302\303\304DD\305\306\307\310\311&\210\300\312\302\303\313DD\314\306\315\316\317\310\311&	\210\300\320\302\303\321DD\322\306\323\316\324\310\311&	\210\300\325\302\303\326DD\327\306\307\310\311&\210\300\330\302\303\331DD\332\306\333\316\317\310\311&	\210\300\334\302\303\335DD\336\306\323\316\324\310\311&	\210\300\337\302\303\340DD\341\306\307\310\311&\210\300\342\302\303\343DD\344\306\345\316\346\310\311&	\210\300\347\302\303\350DD\351\306\323\316\324\310\311&	\207" [custom-declare-variable sql-interbase-program funcall function #[0 "\300\207" [#1="isql"] 1 #1#] "Command to start isql by Interbase.\n\nStarts `sql-interactive-mode' after doing some setup." :type file :group SQL sql-interbase-options #[0 "\300\207" [nil] 1] "List of additional options for `sql-interbase-program'." (repeat string) :version "20.8" sql-interbase-login-params #[0 "\300\207" [(user password database)] 1] "List of login parameters needed to connect to Interbase." sql-login-params "24.1" sql-db2-program #[0 "\300\207" [#2="db2"] 1 #2#] "Command to start db2 by IBM.\n\nStarts `sql-interactive-mode' after doing some setup." sql-db2-options #[0 "\300\207" [nil] 1] "List of additional options for `sql-db2-program'." (repeat string) sql-db2-login-params #[0 "\300\207" [nil] 1] "List of login parameters needed to connect to DB2." sql-linter-program #[0 "\300\207" [#3="inl"] 1 #3#] "Command to start inl by RELEX.\n\nStarts `sql-interactive-mode' after doing some setup." sql-linter-options #[0 "\300\207" [nil] 1] "List of additional options for `sql-linter-program'." (repeat string) "21.3" sql-linter-login-params #[0 "\300\207" [(user password database server)] 1] "Login parameters to needed to connect to Linter."] 10)
#@28 History of usernames used.
(defvar sql-user-history nil (#$ . 35639))
#@28 History of databases used.
(defvar sql-database-history nil (#$ . 35715))
#@26 History of servers used.
(defvar sql-server-history nil (#$ . 35795))
#@27 History of products used.
(defvar sql-product-history nil (#$ . 35871))
#@30 History of connections used.
(defvar sql-connection-history nil (#$ . 35949))
#@368 Current SQLi buffer.

The global value of `sql-buffer' is the name of the latest SQLi buffer
created.  Any SQL buffer created will make a local copy of this value.
See `sql-interactive-mode' for more on multiple sessions.  If you want
to change the SQLi buffer a SQL mode sends its SQL strings to, change
the local value of `sql-buffer' using \[sql-set-sqli-buffer].
(defvar sql-buffer nil (#$ . 36034))
#@119 Prompt used to initialize `comint-prompt-regexp'.

You can change `sql-prompt-regexp' on `sql-interactive-mode-hook'.
(defvar sql-prompt-regexp nil (#$ . 36445))
#@129 Prompt used to set `left-margin' in `sql-interactive-mode'.

You can change `sql-prompt-length' on `sql-interactive-mode-hook'.
(defvar sql-prompt-length 0 (#$ . 36614))
#@51 Prompt pattern of statement continuation prompts.
(defvar sql-prompt-cont-regexp nil (#$ . 36790))
#@92 Buffer-local string used to possibly rename the SQLi buffer.

Used by `sql-rename-buffer'.
(defvar sql-alternate-buffer-name nil (#$ . 36895))
#@354 Return non-nil if the process associated with buffer is live.

BUFFER can be a buffer object or a buffer name.  The buffer must
be a live buffer, have a running process attached to it, be in
`sql-interactive-mode', and, if PRODUCT or CONNECTION are
specified, it's `sql-product' or `sql-connection' must match.

(fn BUFFER &optional PRODUCT CONNECTION)
(defalias 'sql-buffer-live-p #[769 "\205;�\302!\262\205;�\303!\205;�\304!\205;�rq\210\305\306!\205:�\203-�=\205:�\211?\206:�\211;\205:�\211	\230)\207" [sql-product sql-connection get-buffer buffer-live-p comint-check-proc derived-mode-p sql-interactive-mode] 5 (#$ . 37045)])
#@57 Return non-nil if buffer is a SQLi buffer.

(fn BUFFER)
(defalias 'sql-is-sqli-buffer-p #[257 "\211\205�\300!\262\211\205�\301!\205�r\211q\210\302\303!)\207" [get-buffer buffer-live-p derived-mode-p sql-interactive-mode] 3 (#$ . 37690)])
#@71 Mode map used for `sql-interactive-mode'.
Based on `comint-mode-map'.
(defvar sql-interactive-mode-map (byte-code "\301 \302\303!\203�\303\"\210\202�\302\304!\203�\304C\"\210\302\305!\203'�\305\306\"\210\307\310\311#\210\307\312\313#\210\307\314\315#\210\307\316\315#\210\307\317\320#\210\307\321\322#\210\307\323\324#\210\211\207" [comint-mode-map make-sparse-keymap fboundp set-keymap-parent set-keymap-parents set-keymap-name sql-interactive-mode-map define-key "\n" sql-accumulate-and-indent "" sql-copy-column "O" sql-magic-go "o" ";" sql-magic-semicolon "\fa" sql-list-all "\ft" sql-list-table] 5) (#$ . 37940))
#@31 Mode map used for `sql-mode'.
(defvar sql-mode-map (byte-code "\300 \301\302\303#\210\301\304\305#\210\301\306\307#\210\301\310\311#\210\301\312\313#\210\301\314\315#\210\301\316\317#\210\301\320\321#\210\301\322\323#\210\301\324\325#\210\301\326\327#\210\211\207" [make-sparse-keymap define-key "" sql-send-paragraph "" sql-send-region "" sql-send-string "" sql-send-buffer "" sql-send-line-and-next "	" sql-product-interactive "" sql-show-sqli-buffer "\fa" sql-list-all "\ft" sql-list-table [remap beginning-of-defun] sql-beginning-of-statement [remap end-of-defun] sql-end-of-statement] 5) (#$ . 38583))
#@22 Menu for `sql-mode'.
(defvar sql-mode-menu nil (#$ . 39222))
(byte-code "\302\303\304\305\306\307\310\311\312\313\314\312\315\316\317\320\321\322\323\324\325\326	\"B\257$\207" [sql-mode-map sql-product-alist easy-menu-do-define sql-mode-menu "Menu for `sql-mode'." "SQL" ["Send Paragraph" sql-send-paragraph (sql-buffer-live-p sql-buffer)] ["Send Region" sql-send-region (and mark-active (sql-buffer-live-p sql-buffer))] ["Send Buffer" sql-send-buffer (sql-buffer-live-p sql-buffer)] ["Send String" sql-send-string (sql-buffer-live-p sql-buffer)] "--" ["List all objects" sql-list-all (and (sql-buffer-live-p sql-buffer) (sql-get-product-feature sql-product :list-all))] ["List table details" sql-list-table (and (sql-buffer-live-p sql-buffer) (sql-get-product-feature sql-product :list-table))] ["Start SQLi session" sql-product-interactive :visible (not sql-connection-alist) :enable (sql-get-product-feature sql-product :sqli-comint-func)] ("Start..." :visible sql-connection-alist :filter sql-connection-menu-filter "--" ["New SQLi Session" sql-product-interactive (sql-get-product-feature sql-product :sqli-comint-func)]) ["--" :visible sql-connection-alist] ["Show SQLi buffer" sql-show-sqli-buffer t] ["Set SQLi buffer" sql-set-sqli-buffer t] ["Pop to SQLi buffer after send" sql-toggle-pop-to-buffer-after-send-region :style toggle :selected sql-pop-to-buffer-after-send-region] ["--" nil nil] "Product" mapcar #[257 "\211A\262\242\300\301\"\206�\302\303!!\304\305\306\"!\211\307\310\305\311\"\312\313\314	DD\257M\210\315\316\317\320\321\322\314DE&\207" [plist-get :name capitalize symbol-name intern format "sql-highlight-%s-keywords" lambda nil "Highlight %s SQL keywords." (interactive) sql-set-product quote vector :style radio :selected eq sql-product] 14 "\n\n(fn PROD-INFO)"]] 24)
#@34 Menu for `sql-interactive-mode'.
(defvar sql-interactive-mode-menu nil (#$ . 41041))
(byte-code "\301\302\303\304$\210\305\306\307\310#\207" [sql-interactive-mode-map easy-menu-do-define sql-interactive-mode-menu "Menu for `sql-interactive-mode'." ("SQL" ["Rename Buffer" sql-rename-buffer t] ["Save Connection" sql-save-connection (not sql-connection)] "--" ["List all objects" sql-list-all (sql-get-product-feature sql-product :list-all)] ["List table details" sql-list-table (sql-get-product-feature sql-product :list-table)]) define-abbrev-table sql-mode-abbrev-table (("ins" "insert" nil nil t) ("upd" "update" nil nil t) ("del" "delete" nil nil t) ("sel" "select" nil nil t) ("proc" "procedure" nil nil t) ("func" "function" nil nil t) ("cr" "create" nil nil t)) "Abbrev table used in `sql-mode' and `sql-interactive-mode'."] 5)
#@61 Syntax table used in `sql-mode' and `sql-interactive-mode'.
(defvar sql-mode-syntax-table (byte-code "\300 \301\302\303#\210\301\304\305#\210\301\306\307#\210\301\310\311#\210\301\312\311#\210\301\313\314#\210\301\315\316#\210\317\320\321\322\323\324!\325\"\326\327%\330\331\332\"\262\"\210\211\207" [make-syntax-table modify-syntax-entry 47 ". 14" 42 ". 23" 45 ". 12b" 10 "> b" 12 39 "\"" 34 "." mapc make-byte-code 257 "\301\302\300#\207" vconcat vector [modify-syntax-entry "."] 5 "\n\n(fn C)" "!#$%&+,.:;<=>?@\\|" append nil] 8) (#$ . 41883))
#@188 Pattern to match the names of top-level objects.

The pattern matches the name in a CREATE, DROP or ALTER
statement.  The format of variable should be a valid
`font-lock-keywords' entry.
(defvar sql-mode-font-lock-object-name '("^\\s-*\$?:create\\|drop\\|alter\$\\s-+\$?:\\w+\\s-+\$*\$?:table\\|view\\|\\(?:package\\|type\$\$?:\\s-+body\$?\\|proc\$?:edure\$?\\|function\\|trigger\\|sequence\\|rule\\|default\\)\\s-+\$?:if\\s-+not\\s-+exists\\s-+\$?\$\\w+\\(?:\\s-*[.]\\s-*\\w+\$*\\)" 1 font-lock-function-name-face) (#$ . 42449))
#@89 Generation of regexp matching any one of KEYWORDS.

(fn FACE BOUNDARIES &rest KEYWORDS)
(defalias 'sql-font-lock-keywords-builder #[642 "\206�\300\301\262@\302\303\"AQB\207" [("\\b" . "\\b") nil regexp-opt t] 9 (#$ . 42999)])
#@16

(fn KEYWORD)
(defalias 'sql-regexp-abbrev #[257 "\300\301\"G\302\303\211\204�\202B�\304\305#\262\306\\\262T\262\211X\203?�\304#Q\262\307\262\211T\262\202#�\310P\207" [string-match "[~]" "\$?:" nil substring 0 2 "\\|" "\$?"] 12 (#$ . 43239)])
#@24

(fn &rest KEYW-LIST)
(defalias 'sql-regexp-abbrev-list #[128 "\300\301\203�\302@!Q\262\303\262A\262\202�\304P\207" [nil "\\<\$?:" sql-regexp-abbrev "\\|" "\$\\>"] 7 (#$ . 43517)])
#@350 ANSI SQL keywords used by font-lock.

This variable is used by `sql-mode' and `sql-interactive-mode'.  The
regular expressions are created during compilation by calling the
function `regexp-opt'.  Therefore, take a look at the source before
you define your own `sql-mode-oracle-font-lock-keywords'.  You may want
to add functions and PL/SQL keywords.
(defvar sql-mode-oracle-font-lock-keywords '(("^rem\$?:a\\|ar\\|ark\$?\$?:\\s-.*\$?$" 0 font-lock-comment-face t) ("^\$?:\\<\\(?:[@]\\{1,2\\}\\|acc\\(?:e\\|ep\\|ept\$?\\|a\$?:p\\|pp\\|ppe\\|ppen\\|ppend\$?\\|archive\\|attribute\\|bre\$?:a\\|ak\$?\\|bti\$?:t\\|tl\\|tle\$?\\|c\$?:h\\|ha\\|han\\|hang\\|hange\$?\\|cl\$?:e\\|ea\\|ear\$?\\|col\$?:u\\|um\\|umn\$?\\|conn\$?:e\\|ec\\|ect\$?\\|copy\\|def\$?:i\\|in\\|ine\$?\\|del\\|desc\$?:r\\|ri\\|rib\\|ribe\$?\\|disc\$?:o\\|on\\|onn\\|onne\\|onnec\\|onnect\$?\\|ed\$?:i\\|it\$?\\|exec\$?:u\\|ut\\|ute\$?\\|exit\\|get\\|help\\|ho\$?:s\\|st\$?\\|[$]\\|i\$?:n\\|np\\|npu\\|nput\$?\\|l\$?:i\\|is\\|ist\$?\\|passw\$?:o\\|or\\|ord\$?\\|pau\$?:s\\|se\$?\\|pri\$?:n\\|nt\$?\\|pro\$?:m\\|mp\\|mpt\$?\\|quit\\|recover\\|repf\$?:o\\|oo\\|oot\\|oote\\|ooter\$?\\|reph\$?:e\\|ea\\|ead\\|eade\\|eader\$?\\|r\$?:u\\|un\$?\\|sav\$?:e\$?\\|sho\$?:w\$?\\|shutdown\\|spo\$?:o\\|ol\$?\\|sta\$?:r\\|rt\$?\\|startup\\|store\\|tim\$?:i\\|in\\|ing\$?\\|tti\$?:t\\|tl\\|tle\$?\\|undef\$?:i\\|in\\|ine\$?\\|var\$?:i\\|ia\\|iab\\|iabl\\|iable\$?\\|whenever\\)\\>\\|\$?:comp\\(?:u\\|ut\\|ute\$?\\s-+\\<\$?:avg\\|cou\\(?:n\\|nt\$?\\|min\$?:i\\|im\\|imu\\|imum\$?\\|max\$?:i\\|im\\|imu\\|imum\$?\\|num\$?:b\\|be\\|ber\$?\\|sum\\|std\\|var\$?:i\\|ia\\|ian\\|ianc\\|iance\$?\\)\\>\\)\\|\$?:set\\s-+\\<\\(?:appi\\(?:n\\|nf\\|nfo\$?\\|array\$?:s\\|si\\|siz\\|size\$?\\|auto\$?:c\\|co\\|com\\|comm\\|commi\\|commit\$?\\|autop\$?:r\\|ri\\|rin\\|rint\$?\\|autorecovery\\|autot\$?:r\\|ra\\|rac\\|race\$?\\|blo\$?:c\\|ck\\|ckt\\|ckte\\|ckter\\|ckterm\\|cktermi\\|cktermin\\|cktermina\\|ckterminat\\|ckterminato\\|ckterminator\$?\\|cmds\$?:e\\|ep\$?\\|colsep\\|com\$?:p\\|pa\\|pat\\|pati\\|patib\\|patibi\\|patibil\\|patibili\\|patibilit\\|patibility\$?\\|con\$?:c\\|ca\\|cat\$?\\|copyc\$?:o\\|om\\|omm\\|ommi\\|ommit\$?\\|copytypecheck\\|def\$?:i\\|in\\|ine\$?\\|describe\\|echo\\|editf\$?:i\\|il\\|ile\$?\\|emb\$?:e\\|ed\\|edd\\|edde\\|edded\$?\\|esc\$?:a\\|ap\\|ape\$?\\|feed\$?:b\\|ba\\|bac\\|back\$?\\|flagger\\|flu\$?:s\\|sh\$?\\|hea\$?:d\\|di\\|din\\|ding\$?\\|heads\$?:e\\|ep\$?\\|instance\\|lin\$?:e\\|es\\|esi\\|esiz\\|esize\$?\\|lobof\$?:f\\|fs\\|fse\\|fset\$?\\|long\\|longc\$?:h\\|hu\\|hun\\|hunk\\|hunks\\|hunksi\\|hunksiz\\|hunksize\$?\\|mark\$?:u\\|up\$?\\|newp\$?:a\\|ag\\|age\$?\\|null\\|numf\$?:o\\|or\\|orm\\|orma\\|ormat\$?\\|num\$?:w\\|wi\\|wid\\|widt\\|width\$?\\|pages\$?:i\\|iz\\|ize\$?\\|pau\$?:s\\|se\$?\\|recsep\\|recsepchar\\|scan\\|serverout\$?:p\\|pu\\|put\$?\\|shift\$?:i\\|in\\|ino\\|inou\\|inout\$?\\|show\$?:m\\|mo\\|mod\\|mode\$?\\|sqlbl\$?:a\\|an\\|ank\\|ankl\\|ankli\\|anklin\\|ankline\\|anklines\$?\\|sqlc\$?:a\\|as\\|ase\$?\\|sqlco\$?:n\\|nt\\|nti\\|ntin\\|ntinu\\|ntinue\$?\\|sqln\$?:u\\|um\\|umb\\|umbe\\|umber\$?\\|sqlpluscompat\$?:i\\|ib\\|ibi\\|ibil\\|ibili\\|ibilit\\|ibility\$?\\|sqlpre\$?:f\\|fi\\|fix\$?\\|sqlp\$?:r\\|ro\\|rom\\|romp\\|rompt\$?\\|sqlt\$?:e\\|er\\|erm\\|ermi\\|ermin\\|ermina\\|erminat\\|erminato\\|erminator\$?\\|suf\$?:f\\|fi\\|fix\$?\\|tab\\|term\$?:o\\|ou\\|out\$?\\|ti\$?:m\\|me\$?\\|timi\$?:n\\|ng\$?\\|trim\$?:o\\|ou\\|out\$?\\|trims\$?:p\\|po\\|poo\\|pool\$?\\|und\$?:e\\|er\\|erl\\|erli\\|erlin\\|erline\$?\\|ver\$?:i\\|if\\|ify\$?\\|wra\$?:p\$?\\)\\>\\)\\)\$?:\\s-.*\$?\$?:[-]\n.*\$*$" 0 font-lock-doc-face t) ("&?&\$?:\\sw\\|\\s_\$+[.]?" 0 font-lock-preprocessor-face t) ("%\$bulk_\\(?:exceptions\\|rowcount\$\\|found\\|isopen\\|notfound\\|row\$?:count\\|type\$\\|type\\)\\b" . font-lock-builtin-face) ("\\b\$a\\(?:bs\\|cos\\|dd_months\\|ppendchildxml\\|s\\(?:cii\\(?:str\$?\\|in\\)\\|tan2?\\|vg\\)\\|b\$?:filename\\|i\\(?:n_to_num\\|tand\$\\)\\|c\$?:a\\(?:rdinality\\|st\$\\|eil\\|h\$?:artorowid\\|r\$\\|luster_\$?:id\\|probability\\|set\$\\|o\$?:alesce\\|llect\\|mpose\\|n\\(?:cat\\|nect_by_\\(?:is\\(?:cycle\\|leaf\$\\|root\\)\\|vert\\)\\|rr\$?:_[ks]\$?\\|sh?\\|unt\\|var_\$?:\\(?:po\\|sam\$p\\)\\)\\|u\$?:be_table\\|me_dist\\|rrent_\\(?:date\\|timestamp\$\\)\\|v\\)\\|d\$?:ataobj_to_partition\\|btimezone\\|e\\(?:co\\(?:\\(?:d\\|mpos\$e\\)\\|letexml\\|nse_rank\\|pth\\|ref\\)\\|ump\\)\\|e\$?:mpty_\\(?:[bc]lob\$\\|x\$?:istsnode\\|p\\|tract\\(?:value\$?\\)\\)\\|f\$?:eature_\\(?:id\\|set\\|value\$\\|irst\$?:_value\$?\\|loor\\|rom_tz\\)\\|gr\$?:eatest\\|oup\\(?:_id\\|ing\\(?:_id\$?\\)\\)\\|hextoraw\\|i\$?:n\\(?:itcap\\|s\\(?:ert\\(?:childxml\\(?:after\\|before\$?\\|xml\$?:after\\|before\$\\)\\|tr[24bc]?\\)\\)\\|teration_number\\)\\|l\$?:a\\(?:g\\|st\\(?:_\\(?:day\\|value\$\\)?\\)\\|e\$?:a\\(?:d\\|st\$\\|ngth[24bc]?\\)\\|istagg\\|n\$?:nvl\$?\\|o\$?:caltimestamp\\|g\\|wer\$\\|pad\\|trim\\)\\|m\$?:a\\(?:ke_ref\\|x\$\\|edian\\|in\\|o\$?:d\\|nths_between\$\\)\\|n\$?:anvl\\|chr\\|e\\(?:w_time\\|xt_day\$\\|ls\$?:_\\(?:charset_\\(?:decl_len\\|id\\|name\$\\|initcap\\|\$?:low\\|upp\$er\\)\\|sort\\)\\|t\$?:\\(?:h_valu\\|il\$e\\)\\|u\$?:llif\\|mto\\(?:\\(?:ds\\|ym\$interval\\)\\)\\|vl2?\\)\\|ora_\$?:dst_\\(?:affected\\|convert\\|error\$\\|hash\\)\\|p\$?:ath\\|ercent\\(?:_rank\\|ile_\\(?:cont\\|disc\$\\)\\|ower\$?:multiset\\(?:_by_cardinality\$?\\)?\\|re\$?:diction\\(?:_\\(?:bounds\\|cost\\|details\\|probability\\|set\$\\)?\\|sent\$?:\\(?:nn\$?v\\)\\|vious\\)\\)\\|r\$?:a\\(?:nk\\|tio_to_report\\|wto\\(?:n?hex\$\\)\\|e\$?:f\\(?:tohex\$?\\|g\$?:exp_\\(?:count\\|instr\\|like\\|replace\\|substr\$\\|r_\$?:avg[xy]\\|count\\|intercept\\|r2\\|s\\(?:lope\\|x[xy]\\|yy\$\\)\\)\\|mainder\\|place\\)\\|o\$?:und\\|w\\(?:\\(?:_numbe\\|idto\\(?:n?cha\$\\)r\\)\\)\\|pad\\|trim\\)\\|s\$?:cn_to_timestamp\\|e\\(?:ssiontimezone\\|t\$\\|i\$?:gn\\|nh?\$\\|oundex\\|qrt\\|t\$?:ats_\\(?:binomial_test\\|crosstab\\|f_test\\|ks_test\\|m\\(?:ode\\|w_test\$\\|one_way_anova\\|t_test_\$?:indepu?\\|one\\|paired\$\\|wsr_test\\)\\|ddev\$?:_\\(?:\\(?:po\\|sam\$p\\)\\)?\\)\\|u\$?:bstr[24bc]?\\|m\$\\|ys\$?:_\\(?:con\\(?:nect_by_path\\|text\$\\|dburigen\\|extract_utc\\|guid\\|typeid\\|xml\$?:agg\\|gen\$\\)\\|date\\|timestamp\\)\\)\\|t\$?:anh?\\|imestamp_to_scn\\|o_\\(?:b\\(?:inary_\\(?:double\\|float\$\\|lob\\)\\|c\$?:har\\|lob\$\\|d\$?:ate\\|sinterval\$\\|lob\\|multi_byte\\|n\$?:c\\(?:har\\|lob\$\\|umber\\)\\|single_byte\\|timestamp\$?:_tz\$?\\|yminterval\\)\\|r\$?:anslate\\|eat\\|im\\|unc\$\\|z_offset\\)\\|u\$?:id\\|nistr\\|p\\(?:datexml\\|per\$\\|ser\$?:env\$?\\)\\|v\$?:a\\(?:lue\\|r\\(?:_\\(?:\\(?:po\\|sam\$p\\)\\|iance\\)\\)\\|size\\)\\|width_bucket\\|xml\$?:agg\\|c\\(?:ast\\|data\\|o\\(?:lattval\\|\\(?:mmen\\|nca\$t\\)\\)\\|diff\\|e\$?:lement\\|xists\$\\|forest\\|isvalid\\|p\$?:a\\(?:rse\\|tch\$\\|i\\)\\|query\\|root\\|se\$?:\\(?:quenc\\|rializ\$e\\)\\|t\$?:able\\|ransform\$\\)\\)\\b" . font-lock-builtin-face) ("\\b\$a\\(?:bort\\|c\\(?:c\\(?:ess\\(?:ed\$?\\|ount\\)\\|tivate\\)\\|d\$?:d\\|min\\|vise\$\\|fter\\|g\$?:ent\\|gregate\$\\|l\$?:l\\(?:o\\(?:cate\\|w\$\\)?\\|ter\\|ways\\)\\|n\$?:alyze\\|cillary\\|[dy]\$\\|pply\\|r\$?:chive\\(?:log\$?\\|ray\\)\\|s\$?:c\\|sociate\$\\|ttributes?\\|u\$?:dit\\|t\\(?:h\\(?:enticated\\|id\\|orization\$\\|o\$?:allocate\\|matic\$?\\)\\)\\|vailability\\|[st]\\)\\|b\$?:ackup\\|e\\(?:fore\\|gin\\|half\\|tween\$\\|i\$?:nding\\|tmap\$\\|lock\$?:size\$?\\|o\$?:dy\\|th\$\\|u\$?:ffer_pool\\|ild\$\\|y\\)\\|c\$?:a\\(?:che\\|ll\\|ncel\\|s\\(?:\\(?:cad\$?e\\)\\|tegory\\)\\|ertificate\\|h\$?:a\\(?:ined\\|nge\$\\|eck\$?:point\$?\\|ild\\|unk\\)\\|l\$?:ass\\|ear\\|o\\(?:[ns]e\$\\|uster\\)\\|o\$?:lumn\\(?:_value\\|s\$?\\|m\$?:m\\(?:ent\\|it\\(?:ted\$?\\)\\|p\$?:atibility\\|ile\\|lete\\|osite_limit\\|ress\\|ute\$\\)\\|n\$?:nect\\(?:_time\$?\\|s\$?:i\\(?:der\\|stent\$\\|tr\$?:aints?\\|uctor\$\\)\\|t\$?:e\\(?:nts\\|xt\$\\|\$?:inu\\|rolfil\$e\\)\\)\\|rruption\\|st\\)\\|pu_per_\$?:call\\|session\$\\|r\$?:eate\\|oss\$\\|u\$?:be\\|rr\\(?:ent\\|val\$\\)\\|ycle\\)\\|d\$?:a\\(?:ngling\\|ta\\(?:base\\|files?\$?\\|y\\)\\|dl\\|e\$?:allocate\\|bug\\|f\\(?:ault\\|err\\(?:able\\|ed\$\\|iner\\)\\|l\$?:ay\\|ete\$\\|mand\\|sc\\|termin\$?:es\\|istic\$\\)\\|i\$?:ctionary\\|mension\\|rectory\\|s\\(?:a\\(?:\\(?:bl\\|ssociat\$e\\)\\|connect\\|t\$?:in\\(?:ct\\|guished\$\\|ributed\\)\\)\\)\\|ml\\|rop\\)\\|e\$?:ach\\|l\\(?:ement\\|se\$\\|n\$?:able\\|d\$\\|quals_path\\|s\$?:\\(?:cap\\|timat\$e\\)\\|x\$?:c\\(?:ept\\(?:ions\$?\\|hange\\|luding\\)\\|ists\\|p\$?:ire\\|lain\$\\|te\$?:nt\\|rnal\\(?:ly\$?\\)\\)\\)\\|f\$?:a\\(?:iled_login_attempts\\|st\$\\|i\$?:le\\|n\\(?:al\\|ish\$\\)\\|lush\\|or\$?:ce\\|eign\$?\\|r\$?:e\\(?:e\\(?:lists?\\|pools\$\\|sh\\)\\|om\\)\\|u\$?:ll\\|nctions?\$\\)\\|g\$?:enerated\\|lobal\\(?:_name\\|ly\$?\\|r\$?:ant\\|oup\\(?:ing\\|s\$?\\)\\|uard\\)\\|h\$?:a\\(?:sh\\(?:keys\$?\\|ving\\)\\|eap\\|ierarchy\\)\\|i\$?:d\\(?:entifie[dr]\\|le_time\$\\|mmediate\\|n\$?:c\\(?:luding\\|rement\$\\|d\$?:ex\\(?:e[ds]\\|types?\$?\\|icator\\)\\|it\$?:ial\\(?:ized\\|ly\$?\\|rans\\)\\|ner\\|s\$?:ert\\|t\\(?:an\\(?:\\(?:c\\|tiabl\$e\\)\\|ead\\)\\)\\|t\$?:ersect\\|o\$\\|validate\\)\\|solation\\|[dns]\\)\\|j\$?:ava\\|oin\$\\|k\$?:e\\(?:ep\\|y\$\\|ill\\)\\|l\$?:anguage\\|e\\(?:ft\\|ss\\|vels?\$\\|i\$?:brary\\|ke[24c]?\\|mit\\|nk\\|st\$\\|o\$?:c\\(?:a\\(?:l\\|t\\(?:ion\\|or\$\\)\\|k\\)\\|g\$?:file\\|ging\\|ical\\(?:_reads_per_\\(?:call\\|session\$\\)?\\)\\|[bg]\\)\\)\\|m\$?:a\\(?:n\\(?:age\\(?:d\\|ment\$\\|ual\\)\\|p\$?:ping\$?\\|ster\\|t\$?:\\(?:ch\\|erializ\$ed\\)\\|x\$?:datafiles\\|extents\\|i\\(?:mize\\|nstances\$\\|log\$?:files\\|history\\|members\$\\|size\\|trans\\|value\\)\\)\\|e\$?:m\\(?:ber\\|ory\$\\|rge\\)\\|i\$?:grate\\|n\\(?:extents\\|im\\(?:ize\\|um\$\\|us\\|value\\)\\)\\|o\$?:d\\(?:e\\|ify\$\\|n\$?:itoring\\|th\$\\|unt\\|ve\$?:ment\$?\\)\\)\\|n\$?:a\\(?:med?\\|tural\$\\|e\$?:sted\\|ver\\|w\\|xt\\(?:val\$?\\)\\|o\$?:a\\(?:rchivelog\\|udit\$\\|c\$?:ache\\|o\\(?:mpress\\|py\$\\|ycle\\)\\|delay\\|force\\|logging\\|m\$?:a\\(?:pping\\|xvalue\$\\|in\$?:\\(?:imiz\\|valu\$e\\)\\|onitoring\\)\\|ne\\|order\\|parallel\\|r\$?:e\\(?:ly\\|setlogs\\|verse\$\\|mal\\|owdependencies\\)\\|s\$?:ort\\|witch\$\\|t\$?:hing\\|imeout\$?\\|validate\\|wait\\)?\\|ulls?\\)\\|o\$?:bject\\|ff\\(?:line\$?\\|idindex\\|ld\\|nl\$?:ine\\|y\$\\|p\$?:e\\(?:n\\|rator\$\\|ti\$?:mal\\|on\$\\)\\|r\$?:der\\|ganization\$\\|ut\$?:er\\|line\$?\\|ver\$?:flow\\|riding\$?\\|[fnr]\\)\\|p\$?:a\\(?:ckages?\\|r\\(?:a\\(?:llel\\(?:_enable\$?\\|meters\\)\\|ent\\|titions?\\)\\|ssword\$?:_\\(?:grace_time\\|l\\(?:\\(?:ife\\|ock\$_time\\)\\|reuse_\$?:max\\|time\$\\|verify_function\\)\\)?\\)\\|ct\$?:free\\|increase\\|threshold\\|used\\|version\$\\|er\$?:cent\\|formance\\|manent\$\\|file\\|hysical\\|i\$?:pelined\\|vot\$\\|lan\\|ost_transaction\\|r\$?:agma\\|e\\(?:built\\|serve\$\\|i\$?:mary\\|v\\(?:ate\\(?:_sga\$?\\|ileges\\)\\)\\|o\$?:cedure\\|file\\|tection\$\\)\\|u\$?:blic\\|rge\$\\)\\|qu\$?:ery\\|iesce\\|ota\$\\|r\$?:ange\\|e\\(?:ads?\\|build\\|c\\(?:o\\(?:rds_per_block\\|very?\$\\|ycle\\)\\|duced\\|f\$?:erenc\\(?:es\\|ing\$\\|resh\\)?\\|gister\\|ject\\|l\$?:ational\\|y\$\\|name\\|s\$?:et\\(?:logs\$?\\|ize\\|o\$?:lver?\\|urce\$\\|trict\$?:_references\\|ed\$?\\|u\$?:lt\\|m\\(?:\\(?:abl\$?e\\)\\)\\)\\|t\$?:ention\\|urn\\(?:ing\$?\\)\\|\$?:us\\|v\\(?:ers\\|ok\$\\|writ\\)e\\)\\|ight\\|n\$?:[dp]s\$\\|o\$?:l\\(?:es?\\|l\\(?:back\\|up\$\\)\\|w\$?:dependencies\\|num\\|s\$?\\)\\)\\|s\$?:a\\(?:mple\\|vepoint\$\\|c\$?:an\\|hema\\|n\\|ope\$\\|e\$?:gment\\|l\\(?:ect\\(?:ivity\$?\\|f\\)\\|quence\\|rializable\\|ssion\$?:s_per_user\$?\\|t\$?:\\(?:ting\$?s\\)?\\)\\|h\$?:ared\\(?:_pool\$?\\|rink\\|utdown\\)\\|i\$?:blings\\|d\\|\\(?:ngl\\|z\$e\\)\\|kip\\|o\$?:me\\|rt\\|urce\$\\|p\$?:ace\\|ecification\\|file\\|lit\$\\|t\$?:a\\(?:ndby\\|rt\\|t\\(?:ement_id\\|i\\(?:c\\|stics\$\\)\\)\\|o\$?:p\\|r\\(?:\\(?:ag\$?e\\)\\)\\|ructure\\)\\|u\$?:b\\(?:partitions?\\|stitutable\$\\|ccessful\\|pplemental\\|spend\\)\\|witch\$?:over\$?\\|y\$?:nonym\\|s\\(?:tem\$?\\)\\)\\|t\$?:able\\(?:s\\(?:pace\$?\\)?\\|e\$?:mp\\(?:file\\|late\\|orary\$\\|st\\)\\|h\$?:an\\|en\\|r\\(?:ead\\|ough\$\\)\\|ime\$?:_zone\\|out\$\\|o\\|r\$?:a\\(?:ce\\|nsaction\$\\|iggers?\\|u\$?:ncate\\|st\$\\)\\|ypes?\\)\\|u\$?:n\\(?:archived\\|d\\(?:er\\(?:_path\$?\\|o\\)\\|i\$?:form\\|on\\|que\$\\|l\$?:imited\\|ock\$\\|pivot\\|quiesce\\|recoverable\\|til\\|us\$?:able\\|ed\$\\)\\|p\$?:\\(?:dat\\|grad\$e\\)\\|s\$?:age\\|e\\|ing\$\\)\\|v\$?:a\\(?:l\\(?:idat\\(?:e\\|ion\$\\|ues?\\)\\|r\$?:iable\\|ray\$\\)\\|ersion\\|iew\\)\\|w\$?:ait\\|he\\(?:n\\(?:ever\$?\\|re\\)\\|ith\$?:out\$?\\|n\$?:[dp]s\$\\|ork\\|rite\\)\\|xml\$?:data\\|schema\\|type\$\\)\\b" . font-lock-keyword-face) ("\\b\$b\\(?:file\\|inary_\\(?:double\\|float\$\\|lob\\|yte\\)\\|c\$?:har\\(?:byte\$?\\|lob\\)\\|da\$?:te\\|y\$\\|float\\|interval\\|lo\$?:cal\\|ng\\(?:raw\$?\\)\\|m\$?:inute\\|onth\$\\|n\$?:c\\(?:har\\|lob\$\\|umber\\|varchar2\\)\\|r\$?:aw\\|owid\$\\|second\\|time\$?:stamp\$?\\|urowid\\|varchar2\\|with\\|year\\|zone\\)\\b" . font-lock-type-face) ("\\b\$count\\|delete\\|ex\\(?:ists\\|tend\$\\|first\\|l\$?:\\(?:as\\|imi\$t\\)\\|next\\|prior\\|sql\$?:code\\|errm\$\\|trim\\)\\b" . font-lock-builtin-face) ("\\b\$a\\(?:l\\(?:l\\|ter\$\\|n[dy]\\|sc\\|[st]\\)\\|b\$?:e\\(?:\\(?:gi\\|twee\$n\\)\\|y\\)\\|c\$?:ase\\|heck\\|lusters?\\|o\\(?:l\\(?:auth\\|umns\$\\|mpress\\|nnect\\)\\|r\$?:ash\\|eate\$\\|ursor\\)\\|d\$?:e\\(?:clare\\|fault\\|sc\$\\|istinct\\|rop\\)\\|e\$?:lse\\|nd\\|xc\\(?:eption\\|lusive\$\\)\\|f\$?:alse\\|etch\\|or\\|rom\\|unction\$\\|g\$?:oto\\|r\\(?:ant\\|oup\$\\)\\|having\\|i\$?:dentified\\|n\\(?:dex\\(?:es\$?\\|sert\\|t\$?:ersect\\|o\$\\)\\|[fns]\\)\\|l\$?:ike\\|ock\$\\|m\$?:inus\\|ode\$\\|n\$?:o\\(?:compress\\|\\(?:wai\$?t\\)\\|ull\\)\\|o\$?:ption\\|rder\\|verlaps\\|[fnr]\$\\|p\$?:rocedure\\|ublic\$\\|r\$?:aise_application_error\\|e\\(?:\\(?:sourc\\|vok\$e\\)\\)\\|s\$?:elect\\|hare\\|ize\\|ql\\|tart\\|ubtype\$\\|t\$?:ab\\(?:auth\\|le\$\\|hen\\|o\\|\$?:ru\\|yp\$e\\)\\|u\$?:ni\\(?:on\\|que\$\\|pdate\\)\\|v\$?:alues\\|iews?\$\\|w\$?:he\\(?:n\\|re\$\\|ith\\)\\)\\b" . font-lock-keyword-face) ("\\b\$a\\(?:dd\\|g\\(?:ent\\|gregate\$\\|rray\\|ttribute\\|ut\$?:hid\\|onomous_transaction\$\\|vg\\)\\|b\$?:file_base\\|inary\\|lo\\(?:b_base\\|ck\$\\|o\$?:dy\\|th\\|und\$\\|ulk\\|yte\\)\\|c\$?:a\\(?:ll\\(?:ing\$?\\|scade\\)\\|har\$?:_base\\|acter\\|set\\(?:form\\|id\$?\\)?\\|lo\$?:\\(?:b_ba\$?se\\)\\|o\$?:llect\\|m\\(?:m\\(?:ent\\|it\\(?:ted\$?\\)\\|piled\\)\\|n\$?:st\\(?:ant\\|ructor\$\\|t\$?:ext\\|inue\$\\|vert\\)\\|unt\\)\\|u\$?:rrent\\|stomdatum\$\\)\\|d\$?:a\\(?:ngling\\|t\\(?:e_base\\|[ae]\$\\|y\\)\\|e\$?:fine\\|lete\\|terministic\$\\|ouble\\|uration\\)\\|e\$?:l\\(?:ement\\|sif\$\\|mpty\\|scape\\|x\$?:cept\\(?:ion\\(?:_init\\|s\$\\)?\\|ecute\\|i\$?:sts\\|t\$\\|ternal\\)\\)\\|f\$?:i\\(?:nal\\|xed\$\\|loat\\|or\$?:all\\|ce\$\\)\\|general\\|h\$?:ash\\|eap\\|idden\\|our\$\\|i\$?:mmediate\\|n\\(?:cluding\\|dic\\(?:ator\\|es\$\\|finite\\|line\\|stantiable\\|t\$?:er\\(?:face\\|val\$\\)?\\|validate\\)\\|solation\\)\\|java\\|l\$?:a\\(?:\\(?:ngua\\|r\$ge\\)\\|e\$?:ading\\|ngth\\|vel\$\\|i\$?:brary\\|ke[24c]\\|mit\\(?:ed\$?\\)\\|o\$?:cal\\|ng\\|op\$\\)\\|m\$?:a\\(?:xlen\\|[px]\$\\|e\$?:mber\\|rge\$\\|in\$?:ute\$?\\|o\$?:d\\(?:ify\$?\\|nth\\)\\|ultiset\\)\\|n\$?:a\\(?:me\\|n\\|ti\\(?:onal\\|ve\$\\)\\|char\\|ew\\|ocopy\\|umber_base\\)\\|o\$?:bject\\|ci\\(?:coll\\|d\\(?:ate\\(?:time\$?\\|uration\\)\\|interval\\|loblocator\\|number\\|r\$?:aw\\|ef\\(?:cursor\$?\\|owid\\)\\|string\\|type\\)\\|ld\\|nly\\|p\$?:aque\\|e\\(?:n\\|rator\$\\)\\|r\$?:a\\(?:cle\\|data\$\\|ganization\\|l\$?:\\(?:an\\|var\$y\\)\\)\\|thers\\|ut\\|verriding\\)\\|p\$?:a\\(?:ckage\\|r\\(?:a\\(?:llel_enable\\|meters?\$\\|ent\\|tition\\)\\|scal\\)\\|ipe\$?:lined\$?\\|r\$?:agma\\|ecision\\|i\\(?:or\\|vate\$\\)\\)\\|r\$?:a\\(?:ise\\|nge\\|w\$\\|e\$?:ad\\|cord\\|ference\\|lies_on\\|mainder\\|name\\|s\\(?:trict_references\\|ult\\(?:_cache\$?\\)\\|turn\$?:ing\$?\\|verse\\|[fm]\\)\\|o\$?:llback\\|w\$\\)\\|s\$?:a\\(?:mple\\|ve\\(?:point\$?\\)\\|b[124]\\|e\$?:cond\\|gment\\|lf\\|parate\\|quence\\|rial\\(?:\\(?:iz\\|ly_reus\$able\\)\\|t\\)\\|hort\\|ize_t\\|ome\\|parse\\|ql\$?:code\\|data\\|\\(?:nam\\|stat\$e\\)\\|t\$?:a\\(?:ndard\\|tic\$\\|ddev\\|ored\\|r\$?:ing\\|uct\$\\|yle\\)\\|u\$?:b\\(?:multiset\\|partition\\|stitutable\$\\|m\\)\\|ynonym\\)\\|t\$?:do\\|he\\|ime\\(?:stamp\\|zone_\\(?:abbr\\|hour\\|minute\\|region\$\\)?\\|r\$?:a\\(?:iling\\|nsaction\\(?:al\$?\\)\\|usted\\)\\)\\|u\$?:b[124]\\|n\\(?:der\\|\\(?:sign\\|trust\$ed\\)\\|s\$?:e\\|ing\$\\)\\|v\$?:a\\(?:l\\(?:ist\\|ue\$\\|r\$?:ia\\(?:\\(?:bl\\|nc\$e\\)\\|ray\\|ying\\)\\)\\|oid\\)\\|w\$?:hile\\|ork\\|r\\(?:apped\\|ite\$\\)\\|year\\|zone\\|[ac]\\)\\b" . font-lock-keyword-face) ("\\b\$\"\\(?:\\(?:BINARY LARGE OBJECT\\|CHAR\\(?: \\(?:LARGE OBJECT\\|VARYING\$\\|ACTER \$?:LARGE OBJECT\\|VARYING\$\\)\\|DOUBLE PRECISION\\|INTERVAL \$?:DAY TO SECOND\\|YEAR TO MONTH\$\\|LONG RAW\\|N\$?:ATIONAL CHAR\\(?:ACTER\\(?: LARGE OBJECT\$?\\)?\\|C\$?:HAR\\(?: LARGE OBJECT\$?\\|LOB\\)\\|VARCHAR2\\)\\|TIME\$?:\\(?: WITH\\|STAMP WITH\\(?: LOCAL\$?\\) TIME ZONE\\)\\)\"\\)\\|b\$?:file\\(?:_base\$?\\|inary_\$?:double\\|float\\|integer\$\\|lob\$?:_base\$?\\|oolean\\)\\|c\$?:har\\(?:_base\\|acter\$?\\|lob\$?:_base\$?\\|ursor\\)\\|d\$?:a\\(?:te\\|y\$\\|ec\$?:imal\$?\\|sinterval_unconstrained\\)\\|float\\|int\$?:e\\(?:ger\\|rval\$\\)?\\|lo\$?:cal\\|ng\$\\|m\$?:lslabel\\|onth\$\\|n\$?:aturaln?\\|char_cs\\|um\\(?:ber\\(?:_base\$?\\|eric\\)\\)\\|p\$?:ls_integer\\|ositiven?\$\\|r\$?:aw\\|e\\(?:al\\|f\$\\|owid\\)\\|s\$?:econd\\|i\\(?:gntype\\|mple_\\(?:double\\|float\\|integer\$\\)\\|mallint\\|tring\\)\\|t\$?:ime\\(?:_\\(?:\\(?:tz_\$?unconstrained\\)\\|stamp\$?:_\\(?:\\(?:l?tz_\$?unconstrained\\)\\)?\\)?\\|o\\)\\|urowid\\|varchar2?\\|with\\|y\$?:ear\\|minterval_unconstrained\$\\|zone\\)\\b" . font-lock-type-face) ("\\b\$access_into_null\\|c\\(?:ase_not_found\\|ollection_is_null\\|ursor_already_open\$\\|dup_val_on_index\\|invalid_\$?:\\(?:curso\\|numbe\$r\\)\\|login_denied\\|no\$?:_data_\\(?:\\(?:foun\\|neede\$d\\)\\|t_logged_on\\)\\|program_error\\|rowtype_mismatch\\|s\$?:elf_is_null\\|torage_error\\|ubscript_\\(?:\\(?:beyond_coun\\|outside_limi\$t\\)\\|ys_invalid_rowid\\)\\|t\$?:imeout_on_resource\\|oo_many_rows\$\\|value_error\\|zero_divide\\)\\b" . font-lock-warning-face)) (#$ . 50148))
#@306 Postgres SQL keywords used by font-lock.

Setting this variable directly no longer has any affect.  Use
`sql-product' and `sql-add-product-keywords' to control the
highlighting rules in SQL mode.
(defvar sql-mode-font-lock-keywords nil (#$ . 103879))
#@58 Read a valid SQL product.

(fn PROMPT &optional INITIAL)
(defalias 'sql-read-product #[513 "\211\203\n�\301!\206�\302\303\304\305\306\"\307\310\311&!\207" [sql-product-alist symbol-name "ansi" intern completing-read mapcar #[257 "\300@!\207" [symbol-name] 3 "\n\n(fn INFO)"] nil require-match sql-product-history] 12 (#$ . 104127)])
#@354 Add support for a database product in `sql-mode'.

Add PRODUCT to `sql-product-alist' which enables `sql-mode' to
properly support syntax highlighting and interactive interaction.
DISPLAY is the name of the SQL product that will appear in the
menu bar and in messages.  PLIST initializes the product
configuration.

(fn PRODUCT DISPLAY &optional PLIST)
(defalias 'sql-add-product #[770 "\302\"\203\f�\303\304\"\207\305BBB\211\235\203�\210\202\"�\211B\210\306	\307\310\311\312	DD\313\314\315\316\317\312DE&\320C\227\321\322\323\324\325\310\"\326\"\327\330%\331	\332\"\"\210\242\266\202$\210\207" [sql-product-alist sql-mode-menu assoc user-error "Product `%s' is already defined" :name easy-menu-add-item ("Product") vector sql-set-product quote :style radio :selected eq sql-product nil map-keymap make-byte-code 514 "\300\242?\205�\301A@\227\231\205�\300\240\207" vconcat [] 4 "\n\n(fn K B)" easy-menu-get-map ("Product")] 17 (#$ . 104477)])
#@57 Remove support for PRODUCT in `sql-mode'.

(fn PRODUCT)
(defalias 'sql-del-product #[257 "\302\303\304\305\"#\210\306	\"\307\207" [sql-mode-menu sql-product-alist easy-menu-remove-item ("Product") sql-get-product-feature :name assq-delete-all nil] 7 (#$ . 105454)])
#@327 Set FEATURE of database PRODUCT to NEWVALUE.

The PRODUCT must be a symbol which identifies the database
product.  The product must have already exist on the product
list.  See `sql-add-product' to add new products.  The FEATURE
argument must be a plist keyword accepted by
`sql-product-alist'.

(fn PRODUCT FEATURE NEWVALUE)
(defalias 'sql-set-product-feature #[771 "\302\"\303A\"\203\245�	\235\203r�\211\203\\�\211A@\2035�\211A@9\203,�\211A@L\202\252�\304\305#\202\252�9\203S�\211A\203I�\211A\211\240\262\202\252�\211\211C\241\262\202\252�\304\306#\202\252�D\262\211A\211A\241\266\211\241\262\202\252�\211\203\217�\211A\203\205�\211A\211\240\262\202\252�\211\211C\241\262\202\252�D\262\211A\211A\241\266\211\241\262\202\252�\304\307\"\207" [sql-product-alist sql-indirect-features assoc plist-member error "The value of `%s' for `%s' is not a symbol" "The indirect variable of `%s' for `%s' must be a symbol" "`%s' is not a known product; use `sql-add-product' to add it first"] 9 (#$ . 105731)])
#@472 Lookup FEATURE associated with a SQL PRODUCT.

If the FEATURE is nil for PRODUCT, and FALLBACK is specified,
then the FEATURE associated with the FALLBACK product is
returned.

If the FEATURE is in the list `sql-indirect-features', and the
NOT-INDIRECT parameter is not set, then the value of the symbol
stored in the connect alist is returned.

See `sql-product-alist' for a list of products and supported features.

(fn PRODUCT FEATURE &optional FALLBACK NOT-INDIRECT)
(defalias 'sql-get-product-feature #[1026 "\302\"\303A\"\203<�\211\204#�\203#�=\204#�\304\"\202C�	\235\2038�\2048�\2119\2038�\305!\202C�\211\202C�\306\307\"\210\310\207" [sql-product-alist sql-indirect-features assoc plist-get sql-get-product-feature eval error "`%s' is not a known product; use `sql-add-product' to add it first." nil] 9 (#$ . 106777)])
#@301 Configure font-lock and imenu with product-specific settings.

The KEYWORDS-ONLY flag is passed to font-lock to specify whether
only keywords should be highlighted and syntactic highlighting
skipped.  The IMENU flag indicates whether `imenu-mode' should
also be configured.

(fn KEYWORDS-ONLY IMENU)
(defalias 'sql-product-font-lock #[514 "\306 \307\302!\210\310\311=?\205�\312\313\"\312\311\313\"	C#\314\315!\210\307\303!\210\302\316F\317\304!\203@�\320\304!\203@�\f\203@�\321\322!\210\321\316!\210\323\324\325\322\316$\210\205N�\211\211\207" [sql-product sql-mode-font-lock-object-name sql-mode-font-lock-keywords font-lock-defaults font-lock-mode imenu-syntax-alist sql-product-font-lock-syntax-alist make-local-variable append ansi sql-get-product-feature :font-lock kill-local-variable font-lock-set-defaults t fboundp boundp font-lock-mode-internal nil add-hook font-lock-mode-hook #[0 "\303\304\300!\203�\202\f�	!\210\305\n!\207" [font-lock-preprocessor-face font-lock-keyword-face font-lock-string-face (lambda (#1=#:def-tmp-var) (defvar font-lock-builtin-face #1#)) boundp (lambda (#1#) (defvar font-lock-doc-face #1#))] 3]] 8 (#$ . 107626)])
#@674 Add highlighting KEYWORDS for SQL PRODUCT.

PRODUCT should be a symbol, the name of a SQL product, such as
`oracle'.  KEYWORDS should be a list; see the variable
`font-lock-keywords'.  By default they are added at the beginning
of the current highlighting list.  If optional argument APPEND is
`set', they are used to replace the current highlighting list.
If APPEND is any other non-nil value, they are added at the end
of the current highlighting list.

For example:

(sql-add-product-keywords \='ms
  \='(("\\b\\w+_t\\b" . font-lock-type-face)))

adds a fontification pattern to fontify identifiers ending in
`_t' as data types.

(fn PRODUCT KEYWORDS &optional APPEND)
(defalias 'sql-add-product-keywords #[770 "\301\302\303\"\301J\262\304=\203�\202&�\203\"�\305\"\202&�\305\"L)\207" [sql-indirect-features nil sql-get-product-feature :font-lock set append] 9 (#$ . 108796)])
#@88 Iterate through login parameters and return a list of results.

(fn LOGIN-PARAMS BODY)
(defalias 'sql-for-each-login #[514 "\300\301\302\303\304\305\306\307!\310\"\311\312%\"\"\207" [delq nil mapcar make-byte-code 257 "\211\242\206�\211\243\300\"\207" vconcat vector [] 6 "\n\n(fn PARAM)"] 11 (#$ . 109696)])
(defalias 'sql-product-syntax-table #[0 "\302!\303\304\305\306\307\310!\311\"\312\313%\314	\315\"\"\210\211\207" [sql-mode-syntax-table sql-product copy-syntax-table mapc make-byte-code 257 "\301@A\300#\207" vconcat vector [modify-syntax-entry] 5 "\n\n(fn ENTRY)" sql-get-product-feature :syntax-alist] 8])
(defalias 'sql-product-font-lock-syntax-alist #[0 "\301\302\303\304\305\"\"\306\"\207" [sql-product append mapcar #[257 "\300A\301\302#\303\230\203�\211@\304\300A\302\"PB\207\207" [substring 0 1 "_" "w"] 6 "\n\n(fn ENTRY)"] sql-get-product-feature :syntax-alist ((95 . "w"))] 6])
#@61 Turn on the font highlighting for the SQL product selected.
(defalias 'sql-highlight-product #[0 "\302\303!\205�\304\305 !\210\306\307\310\"\210\311\312\313\"\206�\314!\315Q\211\207" [sql-product mode-name derived-mode-p sql-mode set-syntax-table sql-product-syntax-table sql-product-font-lock nil t "SQL[" sql-get-product-feature :name symbol-name "]"] 4 (#$ . 110614)])
#@81 Set `sql-product' to PRODUCT and enable appropriate highlighting.

(fn PRODUCT)
(defalias 'sql-set-product #[257 "\211;\203\n�\302!\262\303\"\204�\304\305\"\210\306\262\211\307 \207" [sql-product-alist sql-product intern assoc user-error "SQL product %s is not supported; treated as ANSI" ansi sql-highlight-product] 4 (#$ . 110997) (byte-code "\300\301!C\207" [sql-read-product "SQL product: "] 2)])
(defalias 'sql-set-dialect 'sql-set-product)
#@33 Is the buffer hidden?

(fn BUF)
(defalias 'sql-buffer-hidden-p #[257 "\300\301;\203�\302!\205�\202�\303!\203�\304!\202�\305\"\207" [string-prefix-p " " get-buffer bufferp buffer-name nil] 5 (#$ . 111457)])
#@213 Display a SQLi buffer based on `sql-display-sqli-buffer-function'.

If BUF is hidden or `sql-display-sqli-buffer-function' is nil,
then the buffer will not be displayed. Otherwise the BUF is
displayed.

(fn BUF)
(defalias 'sql-display-buffer #[257 "\301!?\205(�\302=\203�\303!\207\204�\304\207\305!\203!�!\207\306\307!\210\303!\207" [sql-display-sqli-buffer-function sql-buffer-hidden-p t pop-to-buffer nil functionp message "Invalid setting of `sql-display-sqli-buffer-function'"] 3 (#$ . 111680)])
#@130 Make a progress reporter if BUF is not hidden.

(fn BUF MESSAGE &optional MIN-VALUE MAX-VALUE CURRENT-VALUE MIN-CHANGE MIN-TIME)
(defalias 'sql-make-progress-reporter #[1794 "\301!\206	�??\205�\302&\207" [sql-display-sqli-buffer-function sql-buffer-hidden-p make-progress-reporter] 14 (#$ . 112197)])
#@82 Report progress of an operation in the echo area.

(fn REPORTER &optional VALUE)
(defalias 'sql-progress-reporter-update #[513 "\205�\300\247\203�@Y\205�\301#\266\203\207" [nil progress-reporter-do-update] 9 (#$ . 112521)])
#@81 Print reporter’s message followed by word "done" in echo area.

(fn REPORTER)
(defalias 'sql-progress-reporter-done #[257 "\211\205�\300!\207" [progress-reporter-done] 3 (#$ . 112763)])
#@13

(fn PROD)
(defalias 'sql-statement-regexp #[257 "\300\301\302\"\206�\303\300\302\"\304\203�\305\306\307\260\202�\310Q\207" [sql-get-product-feature ansi :statement "select" "^\\<" "\$" "\\|" "\$" "\\>"] 9 (#$ . 112959)])
#@63 Move to the beginning of the current SQL statement.

(fn ARG)
(defalias 'sql-beginning-of-statement #[257 "`\301!\302\211\303[!\206�e\262\303\304!\206�d\262b\210\305\306\304$\2033�\307\310 8\2033�\311\225b\210\202�\312 \203=�\311\224\202>�b\210\313 \210`U\205Q�\314\315\316!_!\207" [sql-product sql-statement-regexp nil sql-end-of-statement 1 re-search-forward t 7 syntax-ppss 0 match-data beginning-of-line sql-beginning-of-statement 2 cl-signum] 10 (#$ . 113199) "p"])
#@57 Move to the end of the current SQL statement.

(fn ARG)
(defalias 'sql-end-of-statement #[257 "\301\302\"\206�\303\304V\203�\305\202�\306`\304:\203�@\262\307!\304U\204i�\304V\2033�\310\311\"\204?�\304W\203E�\312!\203E�\313\262\202H�\314\262\311\315$\204W�\304\262\202�\316\317 8\204�\307!Z\262\202�\320 \203s�\304\225\202t�b\207" [sql-product sql-get-product-feature :terminator ";" 0 re-search-backward re-search-forward cl-signum looking-back nil looking-at 2 1 t 7 syntax-ppss match-data] 10 (#$ . 113690) "p"])
#@98 Insert "o" and call `comint-send-input'.
`sql-electric-stuff' must be the symbol `go'.

(fn ARG)
(defalias 'sql-magic-go #[257 "\301\302!!\210\303=\205�\212\304\305!\210\306\307!)\205�\310 \207" [sql-electric-stuff self-insert-command prefix-numeric-value go comint-bol nil looking-at "go\\b" comint-send-input] 4 (#$ . 114239) "P"])
(put 'sql-magic-go 'delete-selection t)
#@111 Insert semicolon and call `comint-send-input'.
`sql-electric-stuff' must be the symbol `semicolon'.

(fn ARG)
(defalias 'sql-magic-semicolon #[257 "\301\302!!\210\303=\205�\304 \207" [sql-electric-stuff self-insert-command prefix-numeric-value semicolon comint-send-input] 4 (#$ . 114624) "P"])
(put 'sql-magic-semicolon 'delete-selection t)
#@42 Continue SQL statement on the next line.
(defalias 'sql-accumulate-and-indent #[0 "\300\301!\203\f�\301 \210\202�\302 \210\303 \207" [fboundp comint-accumulate newline indent-according-to-mode] 2 (#$ . 114975) nil])
#@169 Generate listing of products available for use under SQLi.

List products with :free-software attribute set to FREEP.  Indent
each line with INDENT.

(fn INDENT FREEP)
(defalias 'sql-help-list-products #[514 "\301\211\302\262\211\203F�\211@\303\304\305@!P!\262\306!\203?�\307@\310\"=\203?�\307@\311\"\2065�\305@!\312\305!\313\260\262A\266\202\202�\210\207" [sql-product-alist nil "" intern "sql-" symbol-name fboundp sql-get-product-feature :free-software :name ":	\\[" "]\n"] 12 (#$ . 115199)])
#@36 Show short help for the SQL modes.
(defalias 'sql-help #[0 "\300\301!\207" [describe-function sql-help] 2 (#$ . 115719) nil])
(put 'sql-help 'function-documentation '(sql--make-help-docstring))
(defvar sql--help-docstring "Show short help for the SQL modes.\nUse an entry function to open an interactive SQL buffer.  This buffer is\nusually named `*SQL*'.  The name of the major mode is SQLi.\n\nUse the following commands to start a specific SQL interpreter:\n\n    \\\\FREE\n\nOther non-free SQL implementations are also supported:\n\n    \\\\NONFREE\n\nBut we urge you to choose a free implementation instead of these.\n\nYou can also use \\[sql-product-interactive] to invoke the\ninterpreter for the current `sql-product'.\n\nOnce you have the SQLi buffer, you can enter SQL statements in the\nbuffer.  The output generated is appended to the buffer and a new prompt\nis generated.  See the In/Out menu in the SQLi buffer for some functions\nthat help you navigate through the buffer, the input history, etc.\n\nIf you have a really complex SQL statement or if you are writing a\nprocedure, you can do this in a separate buffer.  Put the new buffer in\n`sql-mode' by calling \\[sql-mode].  The name of this buffer can be\nanything.  The name of the major mode is SQL.\n\nIn this SQL buffer (SQL mode), you can send the region or the entire\nbuffer to the interactive SQL buffer (SQLi mode).  The results are\nappended to the SQLi buffer without disturbing your SQL buffer.")
#@64 Return a docstring for `sql-help' listing loaded SQL products.
(defalias 'sql--make-help-docstring #[0 "\301\302\303#\203�\304\305\306\307\"\310\"\310\211\303%\262\301\311\303#\203/�\304\305\306\307\"\312\"\310\211\303%\262\211\207" [sql--help-docstring string-match "^\$\\s-*\$[\\][\\]FREE\\s-*$" 0 replace-match sql-help-list-products match-string 1 t "^\$\\s-*\$[\\][\\]NONFREE\\s-*$" nil] 7 (#$ . 117205)])
#@162 Fetch the value of a variable.

If the current buffer is in `sql-interactive-mode', then fetch
the global value, otherwise use the buffer local value.

(fn VAR)
(defalias 'sql-default-value #[257 "\300\301!\203\n�\302!\207\303p\"\207" [derived-mode-p sql-interactive-mode default-value buffer-local-value] 4 (#$ . 117637)])
#@780 Prompt user with extended login parameters.

The global value of SYMBOL is the last value and the global value
of the SYMBOL is set based on the user's input.

If PLIST is nil, then the user is simply prompted for a string
value.

The property `:default' specifies the default value.  If the
`:number' property is non-nil then ask for a number.

The `:file' property prompts for a file name that must match the
regexp pattern specified in its value.

The `:completion' property prompts for a string specified by its
value.  (The property value is used as the PREDICATE argument to
`completing-read'.)

For both `:file' and `:completion', there can also be a
`:must-match' property that controls REQUIRE-MATCH parameter to
`completing-read'.

(fn SYMBOL PROMPT HISTORY-VAR PLIST)
(defalias 'sql-get-login-ext #[1028 "\301\302\303\"\304!\2032�\305\306\"\203$�\307\310\311\"\312\211\n\313%\2024�\314\315\310\316\"	\312\211%\2024�\317\320\321\"\203\214�\322\323!\320\n\324\"\203U�\302\n\324\"\202V�\312\325!\302\f\321\"\205x�\326\327\330\331\312\305\332\333\302\321\"\334BBB\335BBFE&\211\336\230\203\204�\336\202\207�\337!\262\202\330�\320\340\"\203\270�\341\302\340\"\317\320\n\324\"\203\254�\302\n\324\"\202\255�\312\f	&\202\330�\302\342\"\203\320�\343\206\314�\206\314�\344\"\202\330�\345	$)\266\203\"\207" [use-dialog-box set-default plist-get :default sql-default-value string-match "\$\$:[ 	]*\\'" replace-match format " (default \"%s\")" t 1 replace-regexp-in-string "[ 	]*\\'" " (default \"%s\") " nil plist-member :file read-file-name file-name-directory :must-match file-name-nondirectory lambda (f) if (not (file-regular-p f)) concat "\\<" ("\\>") ((file-name-nondirectory f)) "" expand-file-name :completion completing-read :number read-number 0 read-string] 26 (#$ . 117970)])
#@1330 Get username, password and database from the user.

The variables `sql-user', `sql-password', `sql-server', and
`sql-database' can be customized.  They are used as the default values.
Usernames, servers and databases are stored in `sql-user-history',
`sql-server-history' and `database-history'.  Passwords are not stored
in a history.

Parameter WHAT is a list of tokens passed as arguments in the
function call.  The function asks for the username if WHAT
contains the symbol `user', for the password if it contains the
symbol `password', for the server if it contains the symbol
`server', and for the database if it contains the symbol
`database'.  The members of WHAT are processed in the order in
which they are provided.

If the `sql-password-wallet' is non-nil and WHAT contains the
`password' token, then the `password' token will be pushed to the
end to be sure that all of the values can be fed to the wallet.

Each token may also be a list with the token in the car and a
plist of options as the cdr.  The following properties are
supported:

:file <filename-regexp>
    :completion <list-of-strings-or-function>
    :default <default-value>
    :number t

In order to ask the user for username, password and database, call the
function like this: (sql-get-login \='user \='password \='database).

(fn &rest WHAT)
(defalias 'sql-get-login #[128 "\203�\306	!\203�\307>\203�\310\311\307\"\312\"\262\211\211\205\226�\211@\211\243\242\206(�\211\313\267\202\215�\314\303\315\316$\210\202\215�\317\320\203b�\306	!\203b�	\n\f
&\211\203V�\211\202]�\321\322\323\324\320!#\262\202i�\321\322\323\324\320!#\"\210\202\215�\314\304\325\326$\210\202\215�\314\305\327\330$\210\202\215�\314\331\332\323\310\333\"$\210\266A\266\202\202�\207" [sql-password-wallet sql-password-search-wallet-function sql-product sql-user sql-server sql-database fboundp password append cl-delete (password) #s(hash-table size 5 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (user 46 password 56 server 110 database 120 port 130)) sql-get-login-ext "User: " sql-user-history set-default sql-password read-passwd "Password: " nil sql-default-value "Server: " sql-server-history "Database: " sql-database-history sql-port "Port: " (:number t)] 14 (#$ . 119819)])
#@196 Return the name of the current default SQLi buffer or nil.
In order to qualify, the SQLi buffer must be alive, be in
`sql-interactive-mode' and have a process.

(fn &optional PRODUCT CONNECTION)
(defalias 'sql-find-sqli-buffer #[512 "\206�	\302#\203�\206>�\303\300!\211\262\203'�\302#\203'�\206>�\304\305\306\307\310\311\312\313\n	\"\314\"\315\316%\317 \"\"@\207" [sql-buffer sql-product sql-buffer-live-p default-value apply append mapcar make-byte-code 257 "\302\301\300#\205\f�\303!C\207" vconcat vector [sql-buffer-live-p buffer-name] 5 "\n\n(fn B)" buffer-list] 14 (#$ . 122107)])
#@345 Set SQLi buffer for all SQL buffers that have none.
This function checks all SQL buffers for their SQLi buffer.  If their
SQLi buffer is nonexistent or has no process, it is set to the current
default SQLi buffer.  The current default SQLi buffer is determined
using `sql-find-sqli-buffer'.  If `sql-buffer' is set,
`sql-set-sqli-hook' is run.
(defalias 'sql-set-sqli-buffer-generally #[0 "\212\301 \302 \303\300\"\210??\2053�@\211q\210\304\305!\203+�\306!\204+�\203+�\307\310!\210\210A\262\202\n�\266\202)\207" [sql-buffer buffer-list sql-find-sqli-buffer set-default derived-mode-p sql-mode sql-buffer-live-p run-hooks sql-set-sqli-hook] 5 (#$ . 122717) nil])
#@364 Set the SQLi buffer SQL strings are sent to.

Call this function in a SQL buffer in order to set the SQLi buffer SQL
strings are sent to.  Calling this function sets `sql-buffer' and runs
`sql-set-sqli-hook'.

If you call it from a SQL buffer, this sets the local copy of
`sql-buffer'.

If you call it from anywhere else, it sets the global copy of
`sql-buffer'.
(defalias 'sql-set-sqli-buffer #[0 "\301 \211\204�\302 \202(�\303\304\305#\306!\204�\307\310\"\202&�\211\205&�\211\311\312!\262\207" [sql-buffer sql-find-sqli-buffer sql-product-interactive read-buffer "New SQLi buffer: " t sql-buffer-live-p user-error "Buffer %s is not a working SQLi buffer" run-hooks sql-set-sqli-hook] 5 (#$ . 123395) nil])
#@176 Display the current SQLi buffer.

This is the buffer SQL strings are sent to.
It is stored in the variable `sql-buffer'.
I
See also `sql-help' on how to create such a buffer.
(defalias 'sql-show-sqli-buffer #[0 "\203�\301\302!!\203�\303!\204�\304 \210\305!\207" [sql-buffer buffer-live-p get-buffer get-buffer-process sql-set-sqli-buffer display-buffer] 3 (#$ . 124117) nil])
#@428 Return a string that can be used to rename a SQLi buffer.
This is used to set `sql-alternate-buffer-name' within
`sql-interactive-mode'.

If the session was started with `sql-connect' then the alternate
name would be the name of the connection.

Otherwise, it uses the parameters identified by the :sqlilogin
parameter.

If all else fails, the alternate name would be the user and
server/database name.

(fn &optional PRODUCT)
(defalias 'sql-make-alternate-buffer-name #[256 "\305\306\307\306\310\311\312\313\206�\314\"\315\"#A\"\262	\203'�\316\317	\206#�\305#\202d�\211\206,�\305\305\230\203c�\n\305\230\203F�\320 \305\230?\205I�\320 \321P\202I�\n\321P\305\230\203^�\f\305\230\203Z�\322 \202_�\f\202_�P\202d�\211\207" [sql-product sql-connection sql-user sql-database sql-server #1="" apply concat append nil sql-for-each-login sql-get-product-feature :sqli-login #[514 "\304\267\202T�\305\230?\205U�\306D\207	\247?\206�	\307U?\205U�\310\311	!D\207\n\305\230?\205U�\312\313\314\"\2039�\315\n!\202:�\nD\207\305\230?\205U�\316\313\314\"\203Q�\315!\202R�D\207\317\207" [sql-user sql-port sql-server sql-database #s(hash-table size 4 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (user 6 port 17 server 36 database 60)) #1# "/" 0 ":" number-to-string "." plist-member :file file-name-nondirectory "@" nil] 6 "\n\n(fn TOKEN PLIST)"] format "<%s>%s" user-login-name "/" system-name] 11 (#$ . 124507)])
#@130 Generate a new, unique buffer name for a SQLi buffer.

Append a sequence number until a unique name is found.

(fn PRODUCT BASE)
(defalias 'sql-generate-unique-sqli-buffer-name #[514 "\301\203�;\203�\202�\302\303\"\202�\304\305\"\206�\306!!\307\211\310\307\311\312#)\266\204\203<�\313\262\314\262\202H�\302\315\"\262\302\316\"\262\317\320!\203V�\321!\202[�\322\323!!\203k�\302\"\262\211T\262\202J�\266\202\207" [inhibit-changing-match-data substring-no-properties format "%S" sql-get-product-feature :name symbol-name nil "\\`[ 	\n
]*\\'" t string-match "*SQL*" "*SQL-%d*" "*SQL: %s*" "*SQL: %s-%%d*" 1 sql-is-sqli-buffer-p comint-check-proc buffer-live-p get-buffer] 13 (#$ . 125946)])
#@328 Rename a SQL interactive buffer.

Prompts for the new name if command is preceded by
\[universal-argument].  If no buffer name is provided, then the
`sql-alternate-buffer-name' is used.

The actual buffer name set will be "*SQL: NEW-NAME*".  If
NEW-NAME is empty, then the buffer name will be "*SQL*".

(fn &optional NEW-NAME)
(defalias 'sql-rename-buffer #[256 "\302\303!\204\n�\304\305!\207\306;\203�\202!�:\203 �\307\310\"\202!�!\311\312	\"\313\"\207" [sql-alternate-buffer-name sql-product derived-mode-p sql-interactive-mode user-error "Current buffer is not a SQL interactive buffer" substring-no-properties read-string "Buffer name (\"*SQL: XXX*\"; enter `XXX'): " rename-buffer sql-generate-unique-sqli-buffer-name t] 5 (#$ . 126672) "P"])
#@84 Copy current column to the end of buffer.
Inserts SELECT or commas if appropriate.
(defalias 'sql-copy-column #[0 "\300\212\301\302u\210\303\302!\210`\304\302!\210`\"\262db\210\305 \211`U\203$�\306c\210\202=�\212\307\310\311#)\2034�\312c\210\202=�h\313=\204=�\314c\210\210\211c\210\315\316\")\207" [nil buffer-substring-no-properties 1 backward-sexp forward-sexp comint-line-beginning-position "SELECT " re-search-backward "\\b\$\\(into\\s-+\\S-+\\s-+(\$\\|select\\|order by\\) .+" t ", " 32 " " message "%s"] 6 (#$ . 127434) nil])
#@37 History of placeholder values used.
(defvar sql-placeholder-history nil (#$ . 127977))
#@108 Replace placeholders in STRING.
Placeholders are words starting with an ampersand like &this.

(fn STRING)
(defalias 'sql-placeholders-filter #[257 "\2037�\301\302\303\304#\2035�\305\306\307\310\311\312\"\313\314#\"\315\211\211\316%\262\317\320\211$\262\312\224G\\\262\202�\266\207" [sql-oracle-scan-on 0 "" string-match "&?&\$\\(?:\\sw\\|\\s_\$+\\)[.]?" read-from-minibuffer format "Enter value for %s: " propertize match-string 1 face font-lock-variable-name-face nil sql-placeholder-history replace-match t] 10 (#$ . 128071)])
#@112 Escape newlines in STRING.
Every newline in STRING will be preceded with a space and a backslash.

(fn STRING)
(defalias 'sql-escape-newlines-filter #[257 "\204�\207\301\302\303\211\304\305#\203C�\302\224\262\302\225\262\306#\307V\2039�\306\310Z#\311\230\2039�\301\202:�\312Q\262\211\262\202	�\306\"P\207" [sql-db2-escape-newlines "" 0 nil string-match "\n" substring 1 2 " \\" " \\\n"] 11 (#$ . 128624)])
#@90 Number of newlines in the input string.

Allows the suppression of continuation prompts.
(defvar sql-output-newline-count 0 (#$ . 129060))
#@63 Send STRING to PROC after applying filters.

(fn PROC STRING)
(defalias 'sql-input-sender #[514 "\211C\301\302\303!\"\304\305\"\211\2036�\306!\203 �\242!\240\210\2026�\211<\2036�\307\310\311\312\313\314!\315\"\316\317%\"\210\320\321\322\323\242\"\"\324\242\"\266\202\207" [sql-output-newline-count buffer-local-value sql-product process-buffer sql-get-product-feature :input-filter functionp mapc make-byte-code 257 "\300\300\242!\240\207" vconcat vector [] 4 "\n\n(fn F)" apply + mapcar #[257 "\211\300=\203�\301\207\302\207" [10 1 0] 3 "\n\n(fn CH)"] comint-simple-send] 12 (#$ . 129205)])
(defvar sql-preoutput-hold nil)
#@100 Anchor the prompt expression at the beginning of the output line.
Remove the start of line regexp.
(defalias 'sql-starts-with-prompt-re #[0 "\301P\207" [comint-prompt-regexp "\\`"] 2 (#$ . 129852)])
#@102 Anchor the prompt expression at the end of the output line.
Match a SQL prompt or a password prompt.
(defalias 'sql-ends-with-prompt-re #[0 "\302\303	\304\260\207" [sql-prompt-regexp comint-password-prompt-regexp "\$?:\\(?:" "\$\\|\$?:" "\$\\)\\'"] 5 (#$ . 130059)])
#@748 Strip out continuation prompts out of the OLINE.

Added to the `comint-preoutput-filter-functions' hook in a SQL
interactive buffer.  If `sql-output-newline-count' is greater than
zero, then an output line matching the continuation prompt is filtered
out.  If the count is zero, then a newline is inserted into the output
to force the output from the query to appear on a new line.

The complication to this filter is that the continuation prompts
may arrive in multiple chunks.  If they do, then the function
saves any unfiltered output in a buffer and prepends that buffer
to the next chunk to properly match the broken-up prompt.

If the filter gets confused, it should reset and stop filtering
to avoid deleting non-prompt output.

(fn OLINE)
(defalias 'sql-interactive-remove-continuation-prompt #[257 "\203\325�	\206	�\305G\306V\204+�\n\206�\306\306V\204+�\307\"\204\325�\f\203+�\307\f\"\204\325�\310 \311\306\312\313\314!\315\"\316$\216\317\211	P\262\305\n\250\203\213�\n\320Y\203\213�\321 \305\230\204u�\n\306V\203u�\307\"\203u�\322\305\317\211$\262\nS\323\262\202O�\210\n\306U\203\206�\317\324P\262\202\213�\305\262\204\230�\317	P\262\305\325 \305\230\204\260�\307\"\203\260�\306\225GY\204\321�\306\262\307\324#\203\303�\306\225\262\202\263�\326\"	P\326\306#\262\266)\210\207" [comint-prompt-regexp sql-preoutput-hold sql-output-newline-count sql-prompt-regexp sql-prompt-cont-regexp "" 0 string-match match-data make-byte-code "\301\300\302\"\207" vconcat vector [set-match-data evaporate] 3 nil 1 sql-starts-with-prompt-re replace-match t "\n" sql-ends-with-prompt-re substring] 10 (#$ . 130339)])
#@49 Display text sent to SQL process pragmatically.
(defvar sql-debug-send nil (#$ . 132000))
#@51 Send the string STR to the SQL process.

(fn STR)
(defalias 'sql-send-string #[257 "\305\306\307\310#\311	!\2039�\212r	q\210\n\203�\312\313\"\210\314\315p!\"\210\316	#\210\f\2032�\312\317	\"\210*\320	!\202<�\321\322!)\207" [comint-input-sender-no-newline sql-buffer sql-debug-send sql-send-terminator sql-pop-to-buffer-after-send-region nil replace-regexp-in-string "[[:space:]\n
]+\\'" "" sql-buffer-live-p message ">>SQL> %S" sql-input-sender get-buffer-process sql-send-magic-terminator "Sent string to buffer %s" sql-display-buffer user-error "No SQL process started"] 7 (#$ . 132096) "sSQL Text: "])
#@51 Send a region to the SQL process.

(fn START END)
(defalias 'sql-send-region #[514 "\300\301\"!\207" [sql-send-string buffer-substring-no-properties] 6 (#$ . 132715) "r"])
#@48 Send the current paragraph to the SQL process.
(defalias 'sql-send-paragraph #[0 "\212\300 \210`)\212\301 \210`)\302\"\207" [backward-paragraph forward-paragraph sql-send-region] 5 (#$ . 132895) nil])
#@46 Send the buffer contents to the SQL process.
(defalias 'sql-send-buffer #[0 "\300ed\"\207" [sql-send-region] 3 (#$ . 133104) nil])
#@67 Send the current line to the SQL process and go to the next line.
(defalias 'sql-send-line-and-next #[0 "\300\301\302!\301\303!\"\210\304\303!\210\305\302!\205�\202
�\207" [sql-send-region line-beginning-position 1 2 beginning-of-line forward-comment] 4 (#$ . 133241) nil])
#@83 Send TERMINATOR to buffer BUF if its not present in STR.

(fn BUF STR TERMINATOR)
(defalias 'sql-send-magic-terminator #[771 "\303\211\211\304=\203�\305	\306\"\262\204�\307\262;\203(�\310!\262\262\2025�:\2035�@\262A\262\205L�\211\205L�\311P\303\304\312#)\266\203?\205W�\313\314!\")\207" [comint-input-sender-no-newline sql-product inhibit-changing-match-data nil t sql-get-product-feature :terminator ";" regexp-quote "\\'" string-match sql-input-sender get-buffer-process] 13 (#$ . 133522)])
#@47 Replace tab characters with spaces.

(fn STR)
(defalias 'sql-remove-tabs-filter #[257 "\300\301\302\303\304%\207" [replace-regexp-in-string "	" " " nil t] 7 (#$ . 134049)])
#@169 Toggle `sql-pop-to-buffer-after-send-region'.

If given the optional parameter VALUE, sets
`sql-toggle-pop-to-buffer-after-send-region' to VALUE.

(fn &optional VALUE)
(defalias 'sql-toggle-pop-to-buffer-after-send-region #[256 "\211\203�\211\211\207?\211\207" [sql-pop-to-buffer-after-send-region] 3 (#$ . 134230) "P"])
#@65 If non-nil, display messages related to the use of redirection.
(defvar sql-debug-redirect nil (#$ . 134561))
#@10

(fn S)
(defalias 'sql-str-literal #[257 "\300\301\302\303#\300Q\207" ["'" replace-regexp-in-string "[']" "''"] 6 (#$ . 134677)])
#@450 Execute the SQL command and send output to OUTBUF.

SQLBUF must be an active SQL interactive buffer.  OUTBUF may be
an existing buffer, or the name of a non-existing buffer.  If
omitted the output is sent to a temporary buffer which will be
killed after the command completes.  COMMAND should be a string
of commands accepted by the SQLi program.  COMMAND may also be a
list of SQLi command strings.

(fn SQLBUF COMMAND &optional OUTBUF SAVE-PRIOR)
(defalias 'sql-redirect #[1026 "\205�\300!?\301\203�\302\303!\210:\2036�\211\2032�\211@\304		$\210\262A\266\202\202�\210\202A�\304$\210\203I�\302\305!\210\306\207" [sql-buffer-hidden-p t message "Executing SQL command..." sql-redirect-one "Executing SQL command...done" nil] 14 (#$ . 134816)])
#@41

(fn SQLBUF COMMAND OUTBUF SAVE-PRIOR)
(defalias 'sql-redirect-one #[1028 "\205\312�rq\210\306\206�\307!\310p!\311\312\"\313rq\210\314\302!\210\315\316\317!\210\204.�\320 \210db\210\321 \322U\204;�\323c\210`\262)\203I�\324\325\"\210\315\313\3261t�\313\327\313\315%\210'\204g�(?\205o�\330\313\331\"\210\202\\�)0\202{�\210\315'\332\333!\210'\203\206�\334 \202\306�rq\210db\210\335\336\"\203\232�\322\224\322\225|\210\211b\210\337\340\341	!\342Q!\203\257�\322\224\322\225|\210\211b\210\343\344\313\315#\203\303�\345\346\315\211#\210\202\262�\211b)+\266\204)\207" [sql-product comint-prompt-regexp view-no-disable-on-exit sql-debug-redirect comint-preoutput-filter-functions inhibit-quit get-buffer-create " *SQL-Redirect*" get-buffer-process sql-get-product-feature :prompt-regexp nil make-local-variable t read-only-mode -1 erase-buffer buffer-size 0 "\n" message ">>SQL> %S" (quit) comint-redirect-send-command-to-process accept-process-output 1 eval (ignore nil) comint-redirect-cleanup looking-back "[ 	\f\n
]*" looking-at "^" regexp-quote "[\\n]" re-search-forward "
+$" replace-match "" quit-flag comint-redirect-completed] 14 (#$ . 135591)])
#@492 Execute the SQL command and return part of result.

SQLBUF must be an active SQL interactive buffer.  COMMAND should
be a string of commands accepted by the SQLi program.  From the
output, the REGEXP is repeatedly matched and the list of
REGEXP-GROUPS submatches is returned.  This behaves much like
\[comint-redirect-results-list-from-process] but instead of
returning a single submatch it returns a list of each submatch
for each match.

(fn SQLBUF COMMAND &optional REGEXP REGEXP-GROUPS)
(defalias 'sql-redirect-value #[1026 "\301\302\303\302$\210rq\210\304\206�\305\302\306#\203k�\204>�\307 G\310\245\302\311V\2039�S\262\312!B\262\202%�\262\202d�\247\203I�\312!\202d�:\203U�\313\314\"\202d�;\203`�\315!\202d�\316\317\"B\262\202�)\203w�\320\321\322!\"\210\211\237\207" [sql-debug-redirect " *SQL-Redirect-values*" nil sql-redirect re-search-forward "^.+$" t match-data 2 0 match-string mapcar #[257 "\211\247\203	�\300!\207\211;\203�\301!\207\302\303\"\207" [match-string match-substitute-replacement error "sql-redirect-value: unknown REGEXP-GROUPS value - %s"] 4 "\n\n(fn C)"] match-substitute-replacement error "sql-redirect-value: unknown REGEXP-GROUPS value - %s" message ">>SQL> = %S" reverse] 11 (#$ . 136773)])
#@450 Execute a command in a SQL interactive buffer and capture the output.

The commands are run in SQLBUF and the output saved in OUTBUF.
COMMAND must be a string, a function or a list of such elements.
Functions are called with SQLBUF, OUTBUF and ARG as parameters;
strings are formatted with ARG and executed.

If the results are empty the OUTBUF is deleted, otherwise the
buffer is popped into a view window.

(fn SQLBUF OUTBUF COMMAND ENHANCED ARG)
(defalias 'sql-execute #[1285 "C\301\302\303\304\305\306\n\n$\307\"\310\311%:\203�\202\"�\312B\"\210\211\313\242!\240\210\314\242!\315U\203;�\316\242!\202t�\317 \320 =r\242q\210\321\312!\210\322\300!\210\302\323\324\305\306%\325\"\326\327%\330 \210)\331\242!\210\211\205r�\332 \262\207" [revert-buffer-function mapc make-byte-code 257 "\211;\203�\304\300\303\203�\305\303\"\202�\301\242#\210\306\207\307!\203'�\211\300\301\242\302\303$\207\310\311\"\207" vconcat vector [sql-redirect format t functionp error "Unknown sql-execute item %s"] 6 "\n\n(fn C)" nil get-buffer buffer-size 0 kill-buffer selected-window get-lru-window set-buffer-modified-p make-local-variable 514 "\305\300\306\301\242!\302\303\304%\207" [sql-execute buffer-name] 8 "\n\n(fn IGNORE-AUTO NOCONFIRM)" special-mode pop-to-buffer shrink-window-if-larger-than-buffer] 17 (#$ . 138034)])
#@96 List objects or details in a separate display buffer.

(fn SQLBUF OUTBUF FEATURE ENHANCED ARG)
(defalias 'sql-execute-feature #[1285 "\300\301\302\303!\"\304\"\262\204�\305\306#\210:\203,�\203(�A\202*�@\262\307%\207" [nil buffer-local-value sql-product get-buffer sql-get-product-feature error "%s does not support %s" sql-execute] 13 (#$ . 139382)])
#@101 A list of database objects used for completion.

The list is maintained in SQL interactive buffers.
(defvar sql-completion-object nil (#$ . 139765))
#@97 A list of column names used for completion.

The list is maintained in SQL interactive buffers.
(defvar sql-completion-column nil (#$ . 139920))
#@105 Generate a list of objects in the database for use as completions.

(fn SCHEMA COMPLETION-LIST FEATURE)
(defalias 'sql-build-completions-1 #[771 "\301\"\211\2056�\302\303J\304p\n\302B#\"\211\203.�\211@\211\235\204'�\211B\262A\266\202\202�\210\305\306\"\262L\207" [sql-product sql-get-product-feature nil append apply sort string<] 13 (#$ . 140072)])
#@79 Generate a list of names in the database for use as completions.

(fn SCHEMA)
(defalias 'sql-build-completions #[257 "\300\301\302#\210\300\303\304#\207" [sql-build-completions-1 sql-completion-object :completion-object sql-completion-column :completion-column] 5 (#$ . 140441)])
(defvar sql-completion-sqlbuf nil)
#@27

(fn STRING PRED ACTION)
(defalias 'sql--completion-table #[771 "\205]�rq\210\302\303\"\205�\304\305\"\227	\204�\306\307!\210\211\203U�\211\310PGT	\307\211\204K�\203K�@GY\205B�\311@\312#\227\230\262A\262\202(�\211\204S�\306!\210\266\210\313	$)\207" [sql-completion-sqlbuf sql-completion-object string-match "\\`\$\\sw\\(:?\\sw\\|\\s_\$*\\)[.]" match-string 1 sql-build-completions nil "." substring 0 complete-with-action] 13 (#$ . 140764)])
#@49 Read the name of a database table.

(fn PROMPT)
(defalias 'sql-read-table-name #[257 "\303\304p\"\205�\305\306!\205�\307\310\224\310\225\"\311 \211\205 �rq\210	)\312\211\203?�\313\314\"\2038�\315\316\317\211%\202B�\320\"\202B�\321\322!*\207" [sql-completion-sqlbuf sql-product completion-ignore-case buffer-local-value sql-contains-names thing-at-point-looking-at "\\_<\\sw\$:?\\sw\\|\\s_\$*\$?:[.]+\\sw\\(?:\\sw\\|\\s_\$*\\)*\\_>" buffer-substring-no-properties 0 sql-find-sqli-buffer t sql-get-product-feature :completion-object completing-read sql--completion-table nil read-from-minibuffer user-error "There is no active SQLi buffer"] 10 (#$ . 141237)])
#@178 List all database objects.
With optional prefix argument ENHANCED, displays additional
details or extends the listing to include other schemas objects.

(fn &optional ENHANCED)
(defalias 'sql-list-all #[256 "\302 \211\204\n�\303\304!\210\305\306\307\310%\210r\211q\210\311\300!\210\312\311\301!\210\211\211)\207" [sql-contains-names sql-buffer sql-find-sqli-buffer user-error "No SQL interactive buffer found" sql-execute-feature "*List All*" :list-all nil make-local-variable t] 8 (#$ . 141917) "P"])
#@206 List the details of a database table named NAME.
Displays the columns in the relation.  With optional prefix argument
ENHANCED, displays additional details about each column.

(fn NAME &optional ENHANCED)
(defalias 'sql-list-table #[513 "\300 \211\204\n�\301\302!\210\204�\301\303!\210\304\305\306\"\307%\207" [sql-find-sqli-buffer user-error "No SQL interactive buffer found" "No table name specified" sql-execute-feature format "*List %s*" :list-table] 9 (#$ . 142430) (byte-code "\301\302!D\207" [current-prefix-arg sql-read-table-name "Table name: "] 2)])
(defvar sql-mode-hook nil)
(byte-code "\300\301N\204\f�\302\300\301\303#\210\304\305!\204�\302\305\306\307#\210\300\207" [sql-mode-hook variable-documentation put "Hook run after entering SQL mode.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it.  (This is true for all hook variables.)" boundp sql-mode-map definition-name sql-mode] 4)
(defvar sql-mode-map (make-sparse-keymap))
(byte-code "\300\301N\204�\302\300\301\303\304!#\210\305\306!\204�\302\306\307\310#\210\311\312 !\210\306\301N\204-�\302\306\301\303\313!#\210\302\310\314\315#\210\302\310\316\317#\207" [sql-mode-map variable-documentation put purecopy "Keymap for `sql-mode'." boundp sql-mode-syntax-table definition-name sql-mode (lambda (#1=#:def-tmp-var) (defvar sql-mode-syntax-table #1#)) make-syntax-table "Syntax table for `sql-mode'." derived-mode-parent prog-mode custom-mode-group SQL] 5)
#@1039 Major mode to edit SQL.

You can send SQL statements to the SQLi buffer using
\[sql-send-region].  Such a buffer must exist before you can do this.
See `sql-help' on how to create SQLi buffers.

\{sql-mode-map}
Customization: Entry to this mode runs the `sql-mode-hook'.

When you put a buffer in SQL mode, the buffer stores the last SQLi
buffer created as its destination in the variable `sql-buffer'.  This
will be the buffer \[sql-send-region] sends the region to.  If this
SQLi buffer is killed, \[sql-send-region] is no longer able to
determine where the strings should be sent to.  You can set the
value of `sql-buffer' using \[sql-set-sqli-buffer].

For information on how to create multiple SQLi buffers, see
`sql-interactive-mode'.

Note that SQL doesn't have an escape character unless you specify
one.  If you specify backslash as escape character in SQL, you
must tell Emacs.  Here's how to do that in your init file:

(add-hook \='sql-mode-hook
          (lambda ()
	    (modify-syntax-entry ?\\ "." sql-mode-syntax-table)))
(defalias 'sql-mode #[0 "\306\300!\210\307\310 \210\311\312\310\313N\203�\314\311\313\310\313N#\210\315!\204'�\316\317 \"\210\320\f!\211\2035�\211\321 =\203;�\322\f\323 \"\210\210\324!\210\325\f!\210
()\203Q�\326)!\210\306\327!\210\330\306\331!\210*+\307,\306\332!\210\333\306\334!\210\335\306\336!\210\337\306\340!\210\307 \341-\206\206�\342!\210\343\344\345\307\211$\210)\346\347!\207" [delay-mode-hooks major-mode mode-name sql-mode-map sql-mode-syntax-table sql-mode-abbrev-table make-local-variable t prog-mode sql-mode "SQL" mode-class put keymap-parent set-keymap-parent current-local-map char-table-parent standard-syntax-table set-char-table-parent syntax-table use-local-map set-syntax-table easy-menu-add comment-start "--" sql-buffer paragraph-separate "[\f]*$" paragraph-start "[\n\f]" abbrev-all-caps 1 sql-contains-names sql-set-product ansi add-hook hack-local-variables-hook sql-highlight-product run-mode-hooks sql-mode-hook local-abbrev-table sql-mode-menu sql-imenu-generic-expression imenu-generic-expression imenu-case-fold-search sql-product] 5 (#$ . 143911) nil])
(byte-code "\300\301\302\303#\210\300\301\304\305#\207" [put sql-interactive-mode mode-class special custom-mode-group SQL] 4)
#@2888 Major mode to use a SQL interpreter interactively.

Do not call this function by yourself.  The environment must be
initialized by an entry function specific for the SQL interpreter.
See `sql-help' for a list of available entry functions.

\[comint-send-input] after the end of the process' output sends the
text from the end of process to the end of the current line.
\[comint-send-input] before end of process output copies the current
line minus the prompt to the end of the buffer and sends it.
\[comint-copy-old-input] just copies the current line.
Use \[sql-accumulate-and-indent] to enter multi-line statements.

If you want to make multiple SQL buffers, rename the `*SQL*' buffer
using \[rename-buffer] or \[rename-uniquely] and start a new process.
See `sql-help' for a list of available entry functions.  The last buffer
created by such an entry function is the current SQLi buffer.  SQL
buffers will send strings to the SQLi buffer current at the time of
their creation.  See `sql-mode' for details.

Sample session using two connections:

1. Create first SQLi buffer by calling an entry function.
2. Rename buffer "*SQL*" to "*Connection 1*".
3. Create a SQL buffer "test1.sql".
4. Create second SQLi buffer by calling an entry function.
5. Rename buffer "*SQL*" to "*Connection 2*".
6. Create a SQL buffer "test2.sql".

Now \[sql-send-region] in buffer "test1.sql" will send the region to
buffer "*Connection 1*", \[sql-send-region] in buffer "test2.sql"
will send the region to buffer "*Connection 2*".

If you accidentally suspend your process, use \[comint-continue-subjob]
to continue it.  On some operating systems, this will not work because
the signals are not supported.

\{sql-interactive-mode-map}
Customization: Entry to this mode runs the hooks on `comint-mode-hook'
and `sql-interactive-mode-hook' (in that order).  Before each input, the
hooks on `comint-input-filter-functions' are run.  After each SQL
interpreter output, the hooks on `comint-output-filter-functions' are
run.

Variable `sql-input-ring-file-name' controls the initialization of the
input ring history.

Variables `comint-output-filter-functions', a hook, and
`comint-scroll-to-bottom-on-input' and
`comint-scroll-to-bottom-on-output' control whether input and output
cause the window to scroll to the end of the buffer.

If you want to make SQL buffers limited in length, add the function
`comint-truncate-buffer' to `comint-output-filter-functions'.

Here is an example for your init file.  It keeps the SQLi buffer a
certain length.

(add-hook \='sql-interactive-mode-hook
    (function (lambda ()
        (setq comint-output-filter-functions #\='comint-truncate-buffer))))

Here is another example.  It will always put point back to the statement
you entered, right above the output it created.

(setq comint-output-filter-functions
       (function (lambda (STR) (comint-show-output))))
(defalias 'sql-interactive-mode #[0 "\306\300!\210\307\310 \210)\306\302!\210	\206�\n\311\312\313\n\314\"\206!�\315\n!\316Q\317
!\210<\2032�\320<!\210\321=!\210\322\307\323\"\210\306\324!\210\325>?\326@\327p!\211\203V�\330\331\"\210\210\306\332!\210\306\333!\210\306\334!\210\306\335!\210\306\336!\210\337\336\323\"\210\306\340!\210\307 \306\341!\210\323!\306\342!\210\323\"\306\343!\210\344 #\306\345!\210\313\n\346\"\206\255�\347%\306\350!\210\313\n\351\"(\306\352!\210\313\n\353\"*\306\354!\210\306\355!\210\356\357\360\323\307$\210\306\361!\210\306\362!\210\363\364!\210*\203\357�\365%\366*\367\260\202\361�%A(\206\371�\370B\306\371!\210\372912CD\373\307!*\207" [delay-mode-hooks sql-interactive-product sql-product major-mode mode-name sql-interactive-mode-map make-local-variable t comint-mode sql-interactive-mode "SQLi[" sql-get-product-feature :name symbol-name "]" use-local-map easy-menu-add set-syntax-table sql-product-font-lock nil comment-start "--" 1 get-buffer-process set-process-sentinel sql-stop sql-user sql-database sql-server sql-port sql-connection set-default sql-contains-names sql-completion-object sql-completion-column sql-alternate-buffer-name sql-make-alternate-buffer-name sql-prompt-regexp :prompt-regexp "^" sql-prompt-length :prompt-length sql-prompt-cont-regexp :prompt-cont-regexp sql-output-newline-count sql-preoutput-hold add-hook comint-preoutput-filter-functions sql-interactive-remove-continuation-prompt sql-input-ring-separator sql-input-ring-file-name run-mode-hooks sql-interactive-mode-hook "\$?:\\(?:" "\$\\|\$?:" "\$\\)" 0 comint-input-sender sql-input-sender comint-read-input-ring sql-interactive-mode-menu sql-mode-syntax-table sql-mode-abbrev-table local-abbrev-table abbrev-all-caps comint-prompt-regexp left-margin comint-input-ring-file-name comint-input-ring-separator] 5 (#$ . 146195)])
#@315 Called when the SQL process is stopped.

Writes the input history to a history file using
`comint-write-input-ring' and inserts a short message in the SQL buffer.

This function is a sentinel watching the SQL interpreter process.
Sentinels will always get the two parameters PROCESS and EVENT.

(fn PROCESS EVENT)
(defalias 'sql-stop #[514 "\305\306!!\205)�r\306!q\210	\307 \210*\f\204#�\310\311#c\202(�\312\313#)\207" [sql-input-ring-separator sql-input-ring-file-name comint-input-ring-file-name comint-input-ring-separator buffer-read-only buffer-live-p process-buffer comint-write-input-ring format "\nProcess %s %s\n" message "Process %s %s"] 6 (#$ . 150993)])
#@64 Read a connection name.

(fn PROMPT &optional INITIAL DEFAULT)
(defalias 'sql-read-connection #[769 "\302\303\304\305	\"\306\302\307&)\207" [completion-ignore-case sql-connection-alist t completing-read mapcar car nil sql-connection-history] 11 (#$ . 151674)])
#@287 Connect to an interactive session using CONNECTION settings.

See `sql-connection-alist' to see how to define connections and
their settings.

The user will not be prompted for any login parameters if a value
is specified in the connection settings.

(fn CONNECTION &optional BUF-NAME)
(defalias 'sql-connect #[513 "\203\206�\205\213�\302\303#A\211\203�\304\211\211C\304\211\2032�\211@\211@A@\305\306!\"\266A\266\202\202�\210\305\307\"\210\310	\311\304\303$\262J\262\312\313\"\240\210\314\315\316\317\320\321!\322\"\323\324%\"\262\306\325\326DDC\327\326	D\326\206v�\330\331\"DEE!\266\204\202\205�\332\333\"\210\304\207\332\334!\210\304\207" [sql-connection-alist sql-product assoc-string t nil set-default eval sql-connection sql-get-product-feature :sqli-login mapcar #[257 "\211@\211\300\267\202�\301\202 �\302\202 �\303\202 �\304\202 �\305\202 �\211\211\262\207" [#s(hash-table size 5 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (sql-user 8 sql-password 12 sql-server 16 sql-database 20 sql-port 24)) user password server database port] 4 "\n\n(fn V)"] sql-for-each-login make-byte-code 514 "\300\242\235?\205�\211\203�B\207\207" vconcat vector [] 4 "\n\n(fn VAR VALS)" let quote sql-product-interactive format "<%s>" user-error "SQL Connection <%s> does not exist" "No SQL Connections defined"] 16 (#$ . 151949) (byte-code "\203\n�\302\303!	D\207\304\305!\207" [sql-connection-alist current-prefix-arg sql-read-connection "Connection: " user-error "No SQL Connections defined"] 2)])
#@181 Captures the connection information of the current SQLi session.

The information is appended to `sql-connection-alist' and
optionally is saved to the user's init file.

(fn NAME)
(defalias 'sql-save-connection #[257 "\301\302!\204\n�\303\304!\210p\305\306\"\305\307\"\305\310\"\305\311\"\305\312\"\305\313\"\203/�\314\315!\202\227�\316\317\"\320\321\"\203N�\322\323\324
\"!\203N�\325\"\262\321\"\203^�\303\326\f\"\202\225�\n\327\330B\331\332\333\334\335%\336\"\337\340%\"B\262\341C\"\262\322\342!\203\221�\343\300\"\202\225�\344\300\"\266\203\207" [sql-connection-alist derived-mode-p sql-interactive-mode user-error "Not in a SQL interactive mode!" buffer-local-value sql-connection sql-product sql-user sql-database sql-server sql-port message "This session was started by a connection; it's already been saved." sql-get-product-feature :sqli-login nil assoc yes-or-no-p format "Replace connection definition <%s>? " assq-delete-all "Connection <%s> already exists" sql-for-each-login product make-byte-code 514 "\305\267\202�\306\307\300DD\207\310\301D\207\311\302D\207\312\303D\207\313\304D\207\314\207" vconcat vector [#s(hash-table size 5 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (product 6 user 12 database 16 server 20 port 24)) sql-product quote sql-user sql-database sql-server sql-port nil] 5 "\n\n(fn TOKEN PLIST)" append "Save the connections for future sessions? " customize-save-variable customize-set-variable] 24 (#$ . 153503) "sNew connection name: "])
#@61 Generate menu entries for using each connection.

(fn TAIL)
(defalias 'sql-connection-menu-filter #[257 "\301\302\303\"\"\207" [sql-connection-alist append mapcar #[257 "\304\305\306@\307\211\211\310\311\312A\313BB!,#\314@D\315#\207" [sql-port sql-server sql-database sql-user vector format "Connection <%s>	%s" "" 0 eval let ((sql-make-alternate-buffer-name)) sql-connect t] 9 "\n\n(fn CONN)"]] 5 (#$ . 155047)])
#@498 Run PRODUCT interpreter as an inferior process.

If buffer `*SQL*' exists but no process is running, make a new process.
If buffer exists and a process is running, just switch to buffer `*SQL*'.

To specify the SQL product, prefix the call with
\[universal-argument].  To set the buffer name as well, prefix
the call to \[sql-product-interactive] with
\[universal-argument] \[universal-argument].

(Type \[describe-mode] in the SQL buffer for a list of commands.)

(fn &optional PRODUCT NEW-NAME)
(defalias 'sql-product-interactive #[512 "\204�	\204�\306!\307Y\203�\211\204�\310\262\311\262\306!\312U\203)�\313\314\n\"\2025�\315\"\2034�\2025�\n\262\203\224\316\317\"\205\227\320\f\"\211\203k�\203e�;\203k�\321!\322\323\324#)\266\203\203k�\325!\202\223p\322\211\326\327\316\330\"\"\210\331\322\332\"\262\333\334!\333\335!\333\336!\333\337!\333\340!@\206\223�AA \341!\203\253� \316\317\"\316\342\"\204\304�\343	\322\"\202:\203\330�\343	\344\345\346
!\"\"\202;\203\347\350	\"\204\367�\351\322\323\324#)\266\203\203\374�\202\343		\"\202\343		\"#\210.B\352 \210)p\262\353\354!\210\355!,rq\210\356\357!\2035\355!,\360\361!\210)\362!C\363\203m\364!\365>\203m\366\"\204Z\367Z\211\262X\203mdb\210\370D\371\323#\204m\372!\210\202<\266db\210\370D\322\323#\203\360\373!\210\374!\210db\210\323E\325!\210)\375!\266\203\207\376\377!\207" [executing-kbd-macro noninteractive sql-product sql-product-alist sql-connection inhibit-changing-match-data prefix-numeric-value 16 (4) (4) 4 sql-read-product "SQL product: " assoc sql-get-product-feature :sqli-comint-func sql-find-sqli-buffer regexp-quote nil t string-match sql-display-buffer apply sql-get-login :sqli-login sql-make-progress-reporter "Login" default-value sql-user sql-password sql-server sql-database sql-port functionp :sqli-options sql-generate-unique-sqli-buffer-name read-string "Buffer name (\"*SQL: XXX*\"; enter `XXX'): " sql-make-alternate-buffer-name string-prefix-p " " "\\`[*].*[*]\\'" sql-interactive-mode make-local-variable sql-buffer buffer-name derived-mode-p sql-mode run-hooks sql-set-sqli-hook get-buffer-process 0.3 process-status (open run) accept-process-output 0.0 re-search-backward 0 sql-progress-reporter-update sql-login-hook sql-progress-reporter-done get-buffer user-error "No default SQL product defined: set `sql-product'" sql-default-directory default-directory sql-interactive-product sql-login-delay sql-prompt-regexp sql-display-sqli-buffer-function] 16 (#$ . 155478) "P"])
#@267 Set up a comint buffer to run the SQL processor.

PRODUCT is the SQL product.  PARAMS is a list of strings which are
passed as command line arguments.  BUF-NAME is the name of the new
buffer.  If nil, a name is chosen for it.

(fn PRODUCT PARAMS &optional BUF-NAME)
(defalias 'sql-comint #[770 "\302\303\"\304!\204�\305!\204�\306\307\"\210\2039�\310\311\"\204?�\312\313\314\315#)\266\203\204?�\316\316Q\262\202?�\317\313\"\262\320\321G\313$\210\322\323\324#\325\326\313	&q\262\207" [default-directory inhibit-changing-match-data sql-get-product-feature :sqli-program file-remote-p executable-find error "Unable to locate SQL program `%s'" string-prefix-p " " "\\`[*].*[*]\\'" nil t string-match "*" sql-generate-unique-sqli-buffer-name set-text-properties 0 replace-regexp-in-string "\\`[*]\$.*\$[*]\\'" "\\1" apply make-comint-in-buffer] 12 (#$ . 158061)])
#@1179 Run sqlplus by Oracle as an inferior process.

If buffer `*SQL*' exists but no process is running, make a new process.
If buffer exists and a process is running, just switch to buffer
`*SQL*'.

Interpreter used comes from variable `sql-oracle-program'.  Login uses
the variables `sql-user', `sql-password', and `sql-database' as
defaults, if set.  Additional command line parameters can be stored in
the list `sql-oracle-options'.

The buffer is put in SQL interactive mode, giving commands for sending
input.  See `sql-interactive-mode'.

To set the buffer name directly, use \[universal-argument]
before \[sql-oracle].  Once session has started,
\[sql-rename-buffer] can be called separately to rename the
buffer.

To specify a coding system for converting non-ASCII characters
in the input and output to the process, use \[universal-coding-system-argument]
before \[sql-oracle].  You can also specify this with \[set-buffer-process-coding-system]
in the SQL buffer, after you start the process.
The default comes from `process-coding-system-alist' and
`default-process-coding-system'.

(Type \[describe-mode] in the SQL buffer for a list of commands.)

(fn &optional BUFFER)
(defalias 'sql-oracle #[256 "\300\301\"\207" [sql-product-interactive oracle] 4 (#$ . 158955) "P"])
#@86 Create comint buffer and connect to Oracle.

(fn PRODUCT OPTIONS &optional BUF-NAME)
(defalias 'sql-comint-oracle #[770 "\303\211\211\304\230\204�	\304\230\204�\305	Q\262\202�\262\203+�\n\304\230\204+�\306\nQ\262\2039�\307C\"\262\202<�\262\310#\210\311\312!\206K�\304\262\313\211\203j�\211@\314\315\316@\"\"\203c�\211A\262A\266\202\202N�\206o�\317\262\262\320\321p!\211#\207" [sql-user sql-password sql-database nil "" "/" "@" append sql-comint getenv "NLS_LANG" (("US8PC437" . cp437) ("EL8PC737" . cp737) ("WE8PC850" . cp850) ("EE8PC852" . cp852) ("TR8PC857" . cp857) ("WE8PC858" . cp858) ("IS8PC861" . cp861) ("IW8PC1507" . cp862) ("N8PC865" . cp865) ("RU8PC866" . cp866) ("US7ASCII" . us-ascii) ("UTF8" . utf-8) ("AL32UTF8" . utf-8) ("AL16UTF16" . utf-16)) string-match format "\\.%s\\'" utf-8 set-process-coding-system get-buffer-process] 12 (#$ . 160240)])
#@83 Save most SQL*Plus settings so they may be reset by \[sql-redirect].

(fn SQLBUF)
(defalias 'sql-oracle-save-settings #[257 "\300\301\302\303\304$\301\305\306\307$\301\310\311\312$\313\301\314\315\316$@\317\230\203%�\320\202&�\321PC$\207" [append sql-redirect-value "SHOW ARRAYSIZE AUTOCOMMIT AUTOPRINT AUTORECOVERY AUTOTRACE CMDSEP COLSEP COPYCOMMIT DESCRIBE ECHO EDITFILE EMBEDDED ESCAPE FLAGGER FLUSH HEADING INSTANCE LINESIZE LNO LOBOFFSET LOGSOURCE LONG LONGCHUNKSIZE NEWPAGE NULL NUMFORMAT NUMWIDTH PAGESIZE PAUSE PNO RECSEP SERVEROUTPUT SHIFTINOUT SHOWMODE SPOOL SQLBLANKLINES SQLCASE SQLCODE SQLCONTINUE SQLNUMBER SQLPROMPT SUFFIX TAB TERMOUT TIMING TRIMOUT TRIMSPOOL VERIFY" "^.+$" "SET \\&" "SHOW BLOCKTERMINATOR CONCAT DEFINE SQLPREFIX SQLTERMINATOR UNDERLINE HEADSEP RECSEPCHAR" "^\$.+\$ (hex ..)$" "SET \\1" "SHOW FEEDBACK" "^\$?:FEEDBACK ON for \\([[:digit:]]+\$ or more rows\\|feedback \$OFF\$\\)" "SET FEEDBACK \\1\\2" "SET WRAP " "SHOW WRAP" "^wrap : lines will be \$wrapped\\|truncated\$" 1 "wrapped" "ON" "OFF"] 11 (#$ . 161139)])
#@78 Restore the SQL*Plus settings in SAVED-SETTINGS.

(fn SQLBUF SAVED-SETTINGS)
(defalias 'sql-oracle-restore-settings #[514 "\211C\300\301\302\303\304\305!\306\"\307\310%\311!\"\210\312\242\"\207" [mapc make-byte-code 257 "\300\301\300\242\"\240\207" vconcat vector [delete] 5 "\n\n(fn ONE-CUR-SETTING)" sql-oracle-save-settings sql-redirect] 10 (#$ . 162208)])
#@17

(fn OBJ-NAME)
(defalias 'sql-oracle--list-object-name #[257 "\300\301\211\211$\207" [format "CASE WHEN REGEXP_LIKE (%s, q'/^[A-Z0-9_#$]+$/','c') THEN %s ELSE '\"'|| %s ||'\"' END "] 6 (#$ . 162580)])
#@42

(fn SQLBUF OUTBUF ENHANCED TABLE-NAME)
(defalias 'sql-oracle-list-all #[1028 "\300!\301\302\303!\304Q\301\302\305!\306\302\303!\307\260\310\311\"\210\310\312\313\314\315\n\203*�\316\202+�\317\"E\"\210\310\203;�\202<�#\210\310\320\"\210\321\"\207" [sql-oracle-save-settings "SELECT INITCAP(x.object_type) AS SQL_EL_TYPE , " sql-oracle--list-object-name "x.object_name" " AS SQL_EL_NAME FROM user_objects                    x WHERE x.object_type NOT LIKE '%% BODY' ORDER BY 2, 1;" "x.owner" " ||'.'|| " " AS SQL_EL_NAME FROM all_objects x WHERE x.object_type NOT LIKE '%% BODY' AND x.owner <> 'SYS' ORDER BY 2, 1;" sql-redirect "SET LINESIZE 80 PAGESIZE 50000 TRIMOUT ON TAB OFF TIMING OFF FEEDBACK OFF" "COLUMN SQL_EL_TYPE  HEADING \"Type\" FORMAT A19" "COLUMN SQL_EL_NAME  HEADING \"Name\"" format "COLUMN SQL_EL_NAME  FORMAT A%d" 60 35 ("COLUMN SQL_EL_NAME CLEAR" "COLUMN SQL_EL_TYPE CLEAR") sql-oracle-restore-settings] 14 (#$ . 162789)])
#@78 Implements :list-table under Oracle.

(fn SQLBUF OUTBUF ENHANCED TABLE-NAME)
(defalias 'sql-oracle-list-table #[1028 "\300!\301\302\303\304\305\306 ^]\"\"\210\301\302\307\"#\210\310\"\207" [sql-oracle-save-settings sql-redirect format "SET LINESIZE %d PAGESIZE 50000 DESCRIBE DEPTH 1 LINENUM OFF INDENT ON" 65 120 window-width "DESCRIBE %s" sql-oracle-restore-settings] 12 (#$ . 163758)])
(byte-code "\300\301\302\303\304DD\305\306\307\310\311\312\313&	\207" [custom-declare-variable sql-oracle-completion-types funcall function #[0 "\300\207" [("FUNCTION" "PACKAGE" "PROCEDURE" "SEQUENCE" "SYNONYM" "TABLE" "TRIGGER" "TYPE" "VIEW")] 1] "List of object types to include for completion under Oracle.\n\nSee the distinct values in ALL_OBJECTS.OBJECT_TYPE for possible values." :version "24.1" :type (repeat string) :group SQL] 10)
#@22

(fn SQLBUF SCHEMA)
(defalias 'sql-oracle-completion-object #[514 "\301\302\203$�\303\304\305\306\307\310	\"\203�\311\312	\"\202�\226!\"P\202%�\313\314\315\306\316#\317\260\320\312$\207" [sql-oracle-completion-types sql-redirect-value "SELECT CHR(1)||" "CASE WHEN REGEXP_LIKE (owner, q'/^[A-Z0-9_#$]+$/','c') THEN owner ELSE '\"'|| owner ||'\"' END ||'.'||CASE WHEN REGEXP_LIKE (object_name, q'/^[A-Z0-9_#$]+$/','c') THEN object_name ELSE '\"'|| object_name ||'\"' END  AS o FROM all_objects " format "WHERE owner = %s AND " sql-str-literal string-match "^[\"]\$.+\$[\"]$" match-string 1 "CASE WHEN REGEXP_LIKE (object_name, q'/^[A-Z0-9_#$]+$/','c') THEN object_name ELSE '\"'|| object_name ||'\"' END  AS o FROM user_objects WHERE " "temporary = 'N' AND generated = 'N' AND secondary = 'N' AND object_type IN (" mapconcat "," ");" "^[]\$.+\$$"] 12 (#$ . 164601)])
#@1190 Run isql by Sybase as an inferior process.

If buffer `*SQL*' exists but no process is running, make a new process.
If buffer exists and a process is running, just switch to buffer
`*SQL*'.

Interpreter used comes from variable `sql-sybase-program'.  Login uses
the variables `sql-server', `sql-user', `sql-password', and
`sql-database' as defaults, if set.  Additional command line parameters
can be stored in the list `sql-sybase-options'.

The buffer is put in SQL interactive mode, giving commands for sending
input.  See `sql-interactive-mode'.

To set the buffer name directly, use \[universal-argument]
before \[sql-sybase].  Once session has started,
\[sql-rename-buffer] can be called separately to rename the
buffer.

To specify a coding system for converting non-ASCII characters
in the input and output to the process, use \[universal-coding-system-argument]
before \[sql-sybase].  You can also specify this with \[set-buffer-process-coding-system]
in the SQL buffer, after you start the process.
The default comes from `process-coding-system-alist' and
`default-process-coding-system'.

(Type \[describe-mode] in the SQL buffer for a list of commands.)

(fn &optional BUFFER)
(defalias 'sql-sybase #[256 "\300\301\"\207" [sql-product-interactive sybase] 4 (#$ . 165490) "P"])
#@86 Create comint buffer and connect to Sybase.

(fn PRODUCT OPTIONS &optional BUF-NAME)
(defalias 'sql-comint-sybase #[770 "\304\305\230?\205�\306D	\305\230?\205�\307	D\n\305\230?\205�\310\nD\305\230?\205)�\311D%\312#\207" [sql-user sql-password sql-database sql-server append "" "-U" "-P" "-D" "-S" sql-comint] 9 (#$ . 166786)])
#@1070 Run dbaccess by Informix as an inferior process.

If buffer `*SQL*' exists but no process is running, make a new process.
If buffer exists and a process is running, just switch to buffer
`*SQL*'.

Interpreter used comes from variable `sql-informix-program'.  Login uses
the variable `sql-database' as default, if set.

The buffer is put in SQL interactive mode, giving commands for sending
input.  See `sql-interactive-mode'.

To set the buffer name directly, use \[universal-argument]
before \[sql-informix].  Once session has started,
\[sql-rename-buffer] can be called separately to rename the
buffer.

To specify a coding system for converting non-ASCII characters
in the input and output to the process, use \[universal-coding-system-argument]
before \[sql-informix].  You can also specify this with \[set-buffer-process-coding-system]
in the SQL buffer, after you start the process.
The default comes from `process-coding-system-alist' and
`default-process-coding-system'.

(Type \[describe-mode] in the SQL buffer for a list of commands.)

(fn &optional BUFFER)
(defalias 'sql-informix #[256 "\300\301\"\207" [sql-product-interactive informix] 4 (#$ . 167133) "P"])
#@88 Create comint buffer and connect to Informix.

(fn PRODUCT OPTIONS &optional BUF-NAME)
(defalias 'sql-comint-informix #[770 "\302\230\203\n�\303\202�	\302\230\203�\202�\304	Q\305\306\307B\"#\207" [sql-database sql-server "" "-" "@" sql-comint append ("-")] 9 (#$ . 168313)])
#@1208 Run sqlite as an inferior process.

SQLite is free software.

If buffer `*SQL*' exists but no process is running, make a new process.
If buffer exists and a process is running, just switch to buffer
`*SQL*'.

Interpreter used comes from variable `sql-sqlite-program'.  Login uses
the variables `sql-user', `sql-password', `sql-database', and
`sql-server' as defaults, if set.  Additional command line parameters
can be stored in the list `sql-sqlite-options'.

The buffer is put in SQL interactive mode, giving commands for sending
input.  See `sql-interactive-mode'.

To set the buffer name directly, use \[universal-argument]
before \[sql-sqlite].  Once session has started,
\[sql-rename-buffer] can be called separately to rename the
buffer.

To specify a coding system for converting non-ASCII characters
in the input and output to the process, use \[universal-coding-system-argument]
before \[sql-sqlite].  You can also specify this with \[set-buffer-process-coding-system]
in the SQL buffer, after you start the process.
The default comes from `process-coding-system-alist' and
`default-process-coding-system'.

(Type \[describe-mode] in the SQL buffer for a list of commands.)

(fn &optional BUFFER)
(defalias 'sql-sqlite #[256 "\300\301\"\207" [sql-product-interactive sqlite] 4 (#$ . 168607) "P"])
#@86 Create comint buffer and connect to SQLite.

(fn PRODUCT OPTIONS &optional BUF-NAME)
(defalias 'sql-comint-sqlite #[770 "\301\302\230?\205
�\303!C\"\304#\207" [sql-database append "" expand-file-name sql-comint] 8 (#$ . 169921)])
#@22

(fn SQLBUF SCHEMA)
(defalias 'sql-sqlite-completion-object #[514 "\300\301\302\303$\207" [sql-redirect-value ".tables" "\\sw\$?:\\sw\\|\\s_\$*" 0] 7 (#$ . 170163)])
#@1231 Run mysql by TcX as an inferior process.

Mysql versions 3.23 and up are free software.

If buffer `*SQL*' exists but no process is running, make a new process.
If buffer exists and a process is running, just switch to buffer
`*SQL*'.

Interpreter used comes from variable `sql-mysql-program'.  Login uses
the variables `sql-user', `sql-password', `sql-database', and
`sql-server' as defaults, if set.  Additional command line parameters
can be stored in the list `sql-mysql-options'.

The buffer is put in SQL interactive mode, giving commands for sending
input.  See `sql-interactive-mode'.

To set the buffer name directly, use \[universal-argument]
before \[sql-mysql].  Once session has started,
\[sql-rename-buffer] can be called separately to rename the
buffer.

To specify a coding system for converting non-ASCII characters
in the input and output to the process, use \[universal-coding-system-argument]
before \[sql-mysql].  You can also specify this with \[set-buffer-process-coding-system]
in the SQL buffer, after you start the process.
The default comes from `process-coding-system-alist' and
`default-process-coding-system'.

(Type \[describe-mode] in the SQL buffer for a list of commands.)

(fn &optional BUFFER)
(defalias 'sql-mysql #[256 "\300\301\"\207" [sql-product-interactive mysql] 4 (#$ . 170341) "P"])
#@85 Create comint buffer and connect to MySQL.

(fn PRODUCT OPTIONS &optional BUF-NAME)
(defalias 'sql-comint-mysql #[770 "\305\306\230?\205
�\307PC	\306\230?\205�\310	PC\n\311U?\205%�\312\313\n!PC\306\230?\2050�\314PC\f\306\230?\2059�\fC&\315#\207" [sql-user sql-password sql-port sql-server sql-database append "" "--user=" "--password=" 0 "--port=" number-to-string "--host=" sql-comint] 11 (#$ . 171676)])
#@1223 Run mysql by MariaDB as an inferior process.

MariaDB is free software.

If buffer `*SQL*' exists but no process is running, make a new process.
If buffer exists and a process is running, just switch to buffer
`*SQL*'.

Interpreter used comes from variable `sql-mariadb-program'.  Login uses
the variables `sql-user', `sql-password', `sql-database', and
`sql-server' as defaults, if set.  Additional command line parameters
can be stored in the list `sql-mariadb-options'.

The buffer is put in SQL interactive mode, giving commands for sending
input.  See `sql-interactive-mode'.

To set the buffer name directly, use \[universal-argument]
before \[sql-mariadb].  Once session has started,
\[sql-rename-buffer] can be called separately to rename the
buffer.

To specify a coding system for converting non-ASCII characters
in the input and output to the process, use \[universal-coding-system-argument]
before \[sql-mariadb].  You can also specify this with \[set-buffer-process-coding-system]
in the SQL buffer, after you start the process.
The default comes from `process-coding-system-alist' and
`default-process-coding-system'.

(Type \[describe-mode] in the SQL buffer for a list of commands.)

(fn &optional BUFFER)
(defalias 'sql-mariadb #[256 "\300\301\"\207" [sql-product-interactive mariadb] 4 (#$ . 172100) "P"])
#@146 Create comint buffer and connect to MariaDB.

Use the MySQL comint driver since the two are compatible.

(fn PRODUCT OPTIONS &optional BUF-NAME)
(defalias 'sql-comint-mariadb #[770 "\300#\207" [sql-comint-mysql] 7 (#$ . 173432)])
#@1088 Run solsql by Solid as an inferior process.

If buffer `*SQL*' exists but no process is running, make a new process.
If buffer exists and a process is running, just switch to buffer
`*SQL*'.

Interpreter used comes from variable `sql-solid-program'.  Login uses
the variables `sql-user', `sql-password', and `sql-server' as
defaults, if set.

The buffer is put in SQL interactive mode, giving commands for sending
input.  See `sql-interactive-mode'.

To set the buffer name directly, use \[universal-argument]
before \[sql-solid].  Once session has started,
\[sql-rename-buffer] can be called separately to rename the
buffer.

To specify a coding system for converting non-ASCII characters
in the input and output to the process, use \[universal-coding-system-argument]
before \[sql-solid].  You can also specify this with \[set-buffer-process-coding-system]
in the SQL buffer, after you start the process.
The default comes from `process-coding-system-alist' and
`default-process-coding-system'.

(Type \[describe-mode] in the SQL buffer for a list of commands.)

(fn &optional BUFFER)
(defalias 'sql-solid #[256 "\300\301\"\207" [sql-product-interactive solid] 4 (#$ . 173673) "P"])
#@85 Create comint buffer and connect to Solid.

(fn PRODUCT OPTIONS &optional BUF-NAME)
(defalias 'sql-comint-solid #[770 "\303\304\230?\205\n�C	\304\230\206�\n\304\230?\205�	\nD#\305#\207" [sql-server sql-user sql-password append "" sql-comint] 8 (#$ . 174865)])
#@1057 Run sql by Ingres as an inferior process.

If buffer `*SQL*' exists but no process is running, make a new process.
If buffer exists and a process is running, just switch to buffer
`*SQL*'.

Interpreter used comes from variable `sql-ingres-program'.  Login uses
the variable `sql-database' as default, if set.

The buffer is put in SQL interactive mode, giving commands for sending
input.  See `sql-interactive-mode'.

To set the buffer name directly, use \[universal-argument]
before \[sql-ingres].  Once session has started,
\[sql-rename-buffer] can be called separately to rename the
buffer.

To specify a coding system for converting non-ASCII characters
in the input and output to the process, use \[universal-coding-system-argument]
before \[sql-ingres].  You can also specify this with \[set-buffer-process-coding-system]
in the SQL buffer, after you start the process.
The default comes from `process-coding-system-alist' and
`default-process-coding-system'.

(Type \[describe-mode] in the SQL buffer for a list of commands.)

(fn &optional BUFFER)
(defalias 'sql-ingres #[256 "\300\301\"\207" [sql-product-interactive ingres] 4 (#$ . 175141) "P"])
#@86 Create comint buffer and connect to Ingres.

(fn PRODUCT OPTIONS &optional BUF-NAME)
(defalias 'sql-comint-ingres #[770 "\301\302\303\230?\205\f�C\"#\207" [sql-database sql-comint append ""] 8 (#$ . 176304)])
#@1177 Run osql by Microsoft as an inferior process.

If buffer `*SQL*' exists but no process is running, make a new process.
If buffer exists and a process is running, just switch to buffer
`*SQL*'.

Interpreter used comes from variable `sql-ms-program'.  Login uses the
variables `sql-user', `sql-password', `sql-database', and `sql-server'
as defaults, if set.  Additional command line parameters can be stored
in the list `sql-ms-options'.

The buffer is put in SQL interactive mode, giving commands for sending
input.  See `sql-interactive-mode'.

To set the buffer name directly, use \[universal-argument]
before \[sql-ms].  Once session has started,
\[sql-rename-buffer] can be called separately to rename the
buffer.

To specify a coding system for converting non-ASCII characters
in the input and output to the process, use \[universal-coding-system-argument]
before \[sql-ms].  You can also specify this with \[set-buffer-process-coding-system]
in the SQL buffer, after you start the process.
The default comes from `process-coding-system-alist' and
`default-process-coding-system'.

(Type \[describe-mode] in the SQL buffer for a list of commands.)

(fn &optional BUFFER)
(defalias 'sql-ms #[256 "\300\301\"\207" [sql-product-interactive ms] 4 (#$ . 176526) "P"])
#@100 Create comint buffer and connect to Microsoft SQL Server.

(fn PRODUCT OPTIONS &optional BUF-NAME)
(defalias 'sql-comint-ms #[770 "\304\305\230?\205�\306D	\305\230?\205�\307	D\n\305\230?\205�\310\nD$\305\230\204/�\311BB\202?�\305\230\203;�\312B\202?�\304\313\"\262\314#\207" [sql-user sql-database sql-server sql-password append "" "-U" "-d" "-S" "-P" "-E" ("-P") sql-comint] 8 (#$ . 177802)])
#@1411 Run psql by Postgres as an inferior process.

If buffer `*SQL*' exists but no process is running, make a new process.
If buffer exists and a process is running, just switch to buffer
`*SQL*'.

Interpreter used comes from variable `sql-postgres-program'.  Login uses
the variables `sql-database' and `sql-server' as default, if set.
Additional command line parameters can be stored in the list
`sql-postgres-options'.

The buffer is put in SQL interactive mode, giving commands for sending
input.  See `sql-interactive-mode'.

To set the buffer name directly, use \[universal-argument]
before \[sql-postgres].  Once session has started,
\[sql-rename-buffer] can be called separately to rename the
buffer.

To specify a coding system for converting non-ASCII characters
in the input and output to the process, use \[universal-coding-system-argument]
before \[sql-postgres].  You can also specify this with \[set-buffer-process-coding-system]
in the SQL buffer, after you start the process.
The default comes from `process-coding-system-alist' and
`default-process-coding-system'.  If your output lines end with ^M,
your might try undecided-dos as a coding system.  If this doesn't help,
Try to set `comint-output-filter-functions' like this:

(add-hook \='comint-output-filter-functions #\='comint-strip-ctrl-m \='append)

(Type \[describe-mode] in the SQL buffer for a list of commands.)

(fn &optional BUFFER)
(defalias 'sql-postgres #[256 "\300\301\"\207" [sql-product-interactive postgres] 4 (#$ . 178220) "P"])
#@88 Create comint buffer and connect to Postgres.

(fn PRODUCT OPTIONS &optional BUF-NAME)
(defalias 'sql-comint-postgres #[770 "\304\305U?\205
�\306\307!D	\310\230?\205�\311	D\n\310\230?\205!�\312\nD\310\230?\205+�C%\313#\207" [sql-port sql-user sql-server sql-database append 0 "-p" number-to-string "" "-U" "-h" sql-comint] 10 (#$ . 179741)])
#@22

(fn SQLBUF SCHEMA)
(defalias 'sql-postgres-completion-object #[514 "\300\301\"\210\302\303\304\305$@\306\230\211\203�\300\303\"\210\302\307\310\305$@\206\"�\311\312\313\314\313\315	\316\315
\317\260\204D�\302\320\321$\202h�\322\302\323\324\"\325$\302\323\326	\"\327$\302\323\330\n\"\331$#\300\332\"\210\204x�\300\303\"\210\333\334\"\266\203\207" [sql-redirect "\\t on" sql-redirect-value "\\a" "Output format is \$.*\$[.]$" 1 "aligned" "\\f" "Field separator is \"\$.\$[.]$" "|" "^\$[^" "]*\$" "\\([^" "[^" "]*" "]*$" "\\d" (1 2) append format "\\dt %s.*" (1 2) "\\dv %s.*" (1 2) "\\ds %s.*" (1 2) "\\t off" mapcar #[257 "\211@\300\230\203�\301\302A@\"\207\301\303@A@#\207" ["public" format "\"%s\"" "\"%s\".\"%s\""] 5 "\n\n(fn TBL)"]] 19 (#$ . 180098)])
#@1104 Run isql by Interbase as an inferior process.

If buffer `*SQL*' exists but no process is running, make a new process.
If buffer exists and a process is running, just switch to buffer
`*SQL*'.

Interpreter used comes from variable `sql-interbase-program'.  Login
uses the variables `sql-user', `sql-password', and `sql-database' as
defaults, if set.

The buffer is put in SQL interactive mode, giving commands for sending
input.  See `sql-interactive-mode'.

To set the buffer name directly, use \[universal-argument]
before \[sql-interbase].  Once session has started,
\[sql-rename-buffer] can be called separately to rename the
buffer.

To specify a coding system for converting non-ASCII characters
in the input and output to the process, use \[universal-coding-system-argument]
before \[sql-interbase].  You can also specify this with \[set-buffer-process-coding-system]
in the SQL buffer, after you start the process.
The default comes from `process-coding-system-alist' and
`default-process-coding-system'.

(Type \[describe-mode] in the SQL buffer for a list of commands.)

(fn &optional BUFFER)
(defalias 'sql-interbase #[256 "\300\301\"\207" [sql-product-interactive interbase] 4 (#$ . 180911) "P"])
#@89 Create comint buffer and connect to Interbase.

(fn PRODUCT OPTIONS &optional BUF-NAME)
(defalias 'sql-comint-interbase #[770 "\303\304\230?\205\n�C	\304\230?\205�\305	D\n\304\230?\205�\306\nD$\307#\207" [sql-database sql-password sql-user append "" "-p" "-u" sql-comint] 8 (#$ . 182127)])
#@1283 Run db2 by IBM as an inferior process.

If buffer `*SQL*' exists but no process is running, make a new process.
If buffer exists and a process is running, just switch to buffer
`*SQL*'.

Interpreter used comes from variable `sql-db2-program'.  There is not
automatic login.

The buffer is put in SQL interactive mode, giving commands for sending
input.  See `sql-interactive-mode'.

If you use \[sql-accumulate-and-indent] to send multiline commands to
db2, newlines will be escaped if necessary.  If you don't want that, set
`comint-input-sender' back to `comint-simple-send' by writing an after
advice.  See the elisp manual for more information.

To set the buffer name directly, use \[universal-argument]
before \[sql-db2].  Once session has started,
\[sql-rename-buffer] can be called separately to rename the
buffer.

To specify a coding system for converting non-ASCII characters
in the input and output to the process, use \[universal-coding-system-argument]
before \[sql-db2].  You can also specify this with \[set-buffer-process-coding-system]
in the SQL buffer, after you start the process.
The default comes from `process-coding-system-alist' and
`default-process-coding-system'.

(Type \[describe-mode] in the SQL buffer for a list of commands.)

(fn &optional BUFFER)
(defalias 'sql-db2 #[256 "\300\301\"\207" [sql-product-interactive db2] 4 (#$ . 182433) "P"])
#@83 Create comint buffer and connect to DB2.

(fn PRODUCT OPTIONS &optional BUF-NAME)
(defalias 'sql-comint-db2 #[770 "\300#\207" [sql-comint] 7 (#$ . 183816)])
#@1168 Run inl by RELEX as an inferior process.

If buffer `*SQL*' exists but no process is running, make a new process.
If buffer exists and a process is running, just switch to buffer
`*SQL*'.

Interpreter used comes from variable `sql-linter-program' - usually `inl'.
Login uses the variables `sql-user', `sql-password', `sql-database' and
`sql-server' as defaults, if set.  Additional command line parameters
can be stored in the list `sql-linter-options'.  Run inl -h to get help on
parameters.

`sql-database' is used to set the LINTER_MBX environment variable for
local connections, `sql-server' refers to the server name from the
`nodetab' file for the network connection (dbc_tcp or friends must run
for this to work).  If `sql-password' is an empty string, inl will use
an empty password.

The buffer is put in SQL interactive mode, giving commands for sending
input.  See `sql-interactive-mode'.

To set the buffer name directly, use \[universal-argument]
before \[sql-linter].  Once session has started,
\[sql-rename-buffer] can be called separately to rename the
buffer.

(Type \[describe-mode] in the SQL buffer for a list of commands.)

(fn &optional BUFFER)
(defalias 'sql-linter #[256 "\300\301\"\207" [sql-product-interactive linter] 4 (#$ . 183984) "P"])
#@86 Create comint buffer and connect to Linter.

(fn PRODUCT OPTIONS &optional BUF-NAME)
(defalias 'sql-comint-linter #[770 "\304\230?\205�\305	Q\306\n\304\230?\205�\307\nD\310D#\304\230?\205#�\311\312!\313\314\315\316\317!\320\"\321$\216\322\312\"\266\323#)\266\202\207" [sql-user sql-password sql-server sql-database "" "/" append "-n" "-u" getenv #1="LINTER_MBX" make-byte-code 0 "\300\301\302\"\210\211\207" vconcat vector [setenv #1#] 4 setenv sql-comint] 13 (#$ . 185258)])
(byte-code "\300\301\302\303\304DD\305\306\307\310\311\312\313&	\210\300\314\302\303\315DD\316\306\307\310\317\312\313&	\210\300\320\302\303\321DD\322\306\307\310\323\312\313&	\207" [custom-declare-variable sql-vertica-program funcall function #[0 "\300\207" [#1="vsql"] 1 #1#] "Command to start the Vertica client." :version "25.1" :type file :group SQL sql-vertica-options #[0 "\300\207" [("-P" "pager=off")] 1] "List of additional options for `sql-vertica-program'.\nThe default value disables the internal pager." (repeat string) sql-vertica-login-params #[0 "\300\207" [(user password database server)] 1] "List of login parameters needed to connect to Vertica." sql-login-params] 10)
#@87 Create comint buffer and connect to Vertica.

(fn PRODUCT OPTIONS &optional BUF-NAME)
(defalias 'sql-comint-vertica #[770 "\304\305\230?\205\f�\306D	\305\230?\205�\307	D\244\n\305\230?\205!�\310\nD\244\305\230?\205,�\311D\244\244#\207" [sql-server sql-database sql-password sql-user sql-comint "" "-h" "-d" "-w" "-U"] 8 (#$ . 186448)])
#@57 Run vsql as an inferior process.

(fn &optional BUFFER)
(defalias 'sql-vertica #[256 "\300\301\"\207" [sql-product-interactive vertica] 4 (#$ . 186798) "P"])
(provide 'sql)

${this.title}

Code Editor : sql.elc