ikan Uploader :
Directory : /usr/share/emacs/25.2/lisp/progmodes/
Upload File : |
| Current File : //usr/share/emacs/25.2/lisp/progmodes/sql.elc |
;ELC
;;; Compiled
;;; in Emacs version 25.2.1
;;; with all optimizations.
;;; This file uses dynamic docstrings, first added in Emacs 19.29.
;;; This file does not contain utf-8 non-ASCII characters,
;;; and so can be loaded in Emacs versions earlier than 23.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(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) (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) regexp) (list :tag "completion" (const :format #1# database) (const :format #1# :completion) (restricted-sexp :match-alternatives (listp stringp)))) (const port))] 12)
#@39 Product under `sql-interactive-mode'.
(defvar sql-interactive-product nil (#$ . 2858))
#@66 Connection name if interactive session started by `sql-connect'.
(defvar sql-connection nil (#$ . 2951))
#@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) (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-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 "^\\w*=[#>] " :prompt-length 5 :prompt-cont-regexp "^\\w*[-(][#>] " :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 "^ \\.\\.\\.> " :terminator ";") (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 "^\\w*=[#>] " :prompt-length 5 :prompt-cont-regexp "^\\w*[-(][#>] ")) (#$ . 3064))
(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\301\327\303\304\330DD\331\307\317\320\332\"B\325\326\333\334& \210\335\336\327\"\210\301\337\303\304\340DD\341\307\342\323\343\325\326& \210\301\344\303\304\345DD\346\307\347\323\350\325\326& \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 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 defvaralias sql-dialect sql-electric-stuff #[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." (choice (const :tag "Nothing" nil) (const :tag "The semicolon `;'" semicolon) (const :tag "The string `go' by itself" go)) "20.8" 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"] 16)
#@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 (#$ . 17167))
#@75 Maximum number of seconds you are willing to wait for a login connection.
(defvar sql-login-delay 7.5 (#$ . 17387))
(byte-code "\300\301\302\303\304DD\305\306\307\310\311&\207" [custom-declare-variable sql-pop-to-buffer-after-send-region funcall function #[0 "\300\207" [nil] 1] "When non-nil, pop to the buffer SQL statements are sent to.\n\nAfter a call to `sql-sent-string', `sql-send-region',\n`sql-send-paragraph' or `sql-send-buffer', the window is split\nand the SQLi buffer is shown. If this variable is not nil, that\nbuffer's window will be selected by calling `pop-to-buffer'. If\nthis variable is nil, that buffer is shown using\n`display-buffer'." :type boolean :group SQL] 8)
#@277 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)) (#$ . 18087))
(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&\210\300\322\302\303\323DD\324\306\321\310\311&\210\300\325\302\303\326DD\327\306\321\310\311&\210\300\330\302\303\331DD\332\333\334\306\321\310\311& \210\300\335\302\303\336DD\337\333\334\306\315\310\311& \210\300\340\302\303\341DD\342\306\343\310\311&\210\300\344\302\303\345DD\346\306\347\333\350\310\311& \210\300\351\302\303\352DD\353\306\354\333\334\310\311& \210\300\355\302\303\356DD\357\333\334\306\315\310\311& \210\300\360\302\303\361DD\362\333\334\306\363\310\311& \210\300\364\302\303\365DD\366\333\367\306\363\310\311& \210\300\370\302\303\371DD\372\306\343\310\311&\210\300\373\302\303\374DD\375\306\376\333\377\310\311& \210\300\201@ \302\303\201A DD\201B \306\354\333\334\310\311& \210\300\201C \302\303\201D DD\201E \306\343\310\311&\210\300\201F \302\303\201G DD\201H \306\201I \333\377\310\311& \210\300\201J \302\303\201K DD\201L \306\354\333\334\310\311& \210\300\201M \302\303\201N DD\201O \306\343\310\311&\210\300\201P \302\303\201Q DD\201R \306\354\333\334\310\311& \210\300\201S \302\303\201T DD\201U \306\343\310\311&\210\300\201V \302\303\201W DD\201X \306\201Y \333\377\310\311& \210\300\201Z \302\303\201[ DD\201\\ \306\354\333\334\310\311& \210\300\201] \302\303\201^ DD\201_ \306\343\310\311&\210\300\201` \302\303\201a DD\201b \306\354\333\334\310\311& \210\300\201c \302\303\201d DD\201e \306\343\310\311&\210\300\201f \302\303\201g DD\201h \306\354\333\334\310\311& \210\300\201i \302\303\201j DD\201k \306\343\310\311&\210\300\201l \302\303\201m DD\201n \306\201o \333\201p \310\311& \210\300\201q \302\303\201r DD\201s \306\354\333\334\310\311& \210\300\201t \302\303\201u DD\201v \306\343\310\311&\210\300\201w \302\303\201x DD\201y \306\201z \333\377\310\311& \210\300\201{ \302\303\201| DD\201} \306\354\333\334\310\311& \210\300\201~ \302\303\201 DD\201\200 \306\343\310\311&\210\300\201\201 \302\303\201\202 DD\201\203 \306\201\204 \333\377\310\311& \210\300\201\205 \302\303\201\206 DD\201\207 \306\354\333\334\310\311& \210\300\201\210 \302\303\201\211 DD\201\212 \306\343\310\311&\210\300\201\213 \302\303\201\214 DD\201\215 \306\201\216 \333\377\310\311& \210\300\201\217 \302\303\201\220 DD\201\221 \306\354\333\334\310\311& \210\300\201\222 \302\303\201\223 DD\201\224 \306\343\310\311&\210\300\201\225 \302\303\201\226 DD\201\227 \306\201\230 \333\201\231 \310\311& \210\300\201\232 \302\303\201\233 DD\201\234 \306\354\333\334\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" [nil] 1] "Hook for customizing `sql-interactive-mode'." hook sql-mode-hook #[0 "\300\207" [nil] 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." :version "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 ".*\\.\\(db\\|sqlite[23]?\\)"))] 1] "List of login parameters needed to connect to SQLite." sql-mysql-program #[0 "\300\207" [#3="mysql"] 1 #3#] "Command to start mysql by TcX.\n\nStarts `sql-interactive-mode' after doing some setup." sql-mysql-options #[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) sql-mysql-login-params #[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 E\304BB\207" [user :default user-login-name database (server)] 4] "List of login parameters needed to connect to Postgres." sql-interbase-program #[0 "\300\207" [#10="isql"] 1 #10#] "Command to start isql by Interbase.\n\nStarts `sql-interactive-mode' after doing some setup." sql-interbase-options #[0 "\300\207" [nil] 1] "List of additional options for `sql-interbase-program'." (repeat string) sql-interbase-login-params #[0 "\300\207" [(user password database)] 1] "List of login parameters needed to connect to Interbase." sql-db2-program #[0 "\300\207" [#11="db2"] 1 #11#] "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" [#12="inl"] 1 #12#] "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 (#$ . 30814))
#@28 History of databases used.
(defvar sql-database-history nil (#$ . 30890))
#@26 History of servers used.
(defvar sql-server-history nil (#$ . 30970))
#@27 History of products used.
(defvar sql-product-history nil (#$ . 31046))
#@30 History of connections used.
(defvar sql-connection-history nil (#$ . 31124))
#@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 (#$ . 31209))
#@119 Prompt used to initialize `comint-prompt-regexp'.
You can change `sql-prompt-regexp' on `sql-interactive-mode-hook'.
(defvar sql-prompt-regexp nil (#$ . 31620))
#@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 (#$ . 31789))
#@51 Prompt pattern of statement continuation prompts.
(defvar sql-prompt-cont-regexp nil (#$ . 31965))
#@92 Buffer-local string used to possibly rename the SQLi buffer.
Used by `sql-rename-buffer'.
(defvar sql-alternate-buffer-name nil (#$ . 32070))
#@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 "\2056 \302!\262\2056 \303!\2056 \304!\2056 rq\210\305\306!\2055 \203- =\2055 \211?\2065 \211 =)\207" [sql-product sql-connection get-buffer buffer-live-p comint-check-proc derived-mode-p sql-interactive-mode] 5 (#$ . 32220)])
#@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) (#$ . 32851))
#@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) (#$ . 33494))
#@22 Menu for `sql-mode'.
(defvar sql-mode-menu nil (#$ . 34133))
(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\314 DE&\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 (#$ . 35952))
(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) (#$ . 36794))
#@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) (#$ . 37360))
#@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 (#$ . 37910)])
(defalias 'sql-regexp-abbrev #[257 "\300\301\"G\302\303\211\204 \202? \304O\262\305\\\262T\262\211X\203< OQ\262\306\262\211T\262\202! \307P\207" [string-match "[~]" "\\(?:" nil 0 2 "\\|" "\\)?"] 11 "\n\n(fn KEYWORD)"])
(defalias 'sql-regexp-abbrev-list #[128 "\300\301\203 \302@!Q\262\303\262A\262\202 \304P\207" [nil "\\<\\(?:" sql-regexp-abbrev "\\|" "\\)\\>"] 7 "\n\n(fn &rest KEYW-LIST)"])
#@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-ansi-font-lock-keywords'. You may want
to add functions and PL/SQL keywords.
(defvar sql-mode-ansi-font-lock-keywords '(("\\b\\(a\\(?:da\\|s\\(?:ensitive\\|signment\\|ymmetric\\)\\|tomic\\)\\|b\\(?:etween\\|itvar\\)\\|c\\(?:a\\(?:lled\\|talog_name\\)\\|h\\(?:a\\(?:in\\|racter_set_\\(?:catalog\\|name\\|schema\\)\\)\\|ecked\\)\\|lass_origin\\|o\\(?:bol\\|l\\(?:lation_\\(?:catalog\\|name\\|schema\\)\\|umn_name\\)\\|mm\\(?:and_function\\(?:_code\\)?\\|itted\\)\\|n\\(?:dition_number\\|nection_name\\|straint_\\(?:catalog\\|name\\|schema\\)\\|tains\\)\\)\\|ursor_name\\)\\|d\\(?:atetime_interval_\\(?:code\\|precision\\)\\|efine[dr]\\|ispatch\\|ynamic_function\\(?:_code\\)?\\)\\|exist\\(?:ing\\|s\\)\\|f\\(?:inal\\|ortran\\)\\|g\\(?:\\(?:enera\\|ran\\)ted\\)\\|h\\(?:ierarchy\\|old\\)\\|i\\(?:mplementation\\|n\\(?:fix\\|s\\(?:\\(?:ensitiv\\|tan\\(?:c\\|tiabl\\)\\)e\\)\\|voker\\)\\)\\|key_\\(?:member\\|type\\)\\|length\\|m\\(?:e\\(?:ssage_\\(?:length\\|octet_length\\|text\\)\\|thod\\)\\|ore\\|umps\\)?\\|n\\(?:ame\\|u\\(?:llable\\|mber\\)\\)\\|o\\(?:ptions\\|ver\\(?:laps\\|riding\\)\\)\\|p\\(?:a\\(?:rameter_\\(?:mode\\|name\\|ordinal_position\\|specific_\\(?:catalog\\|name\\|schema\\)\\)\\|scal\\)\\|li\\|osition\\)\\|r\\(?:e\\(?:peatable\\|turned_\\(?:length\\|octet_length\\|sqlstate\\)\\)\\|o\\(?:utine_\\(?:catalog\\|name\\|schema\\)\\|w_count\\)\\)\\|s\\(?:c\\(?:\\(?:al\\|hema_nam\\)e\\)\\|e\\(?:curity\\|lf\\|\\(?:nsitiv\\|r\\(?:ializabl\\|ver_nam\\)\\)e\\)\\|im\\(?:ilar\\|ple\\)\\|ource\\|pecific_name\\|tyle\\|ub\\(?:class_origin\\|list\\)\\|y\\(?:mmetric\\|stem\\)\\)\\|t\\(?:able_name\\|r\\(?:ans\\(?:action\\(?:_active\\|s_\\(?:committed\\|rolled_back\\)\\)\\|forms?\\)\\|igger_\\(?:catalog\\|name\\|schema\\)\\)\\|ype\\)\\|u\\(?:n\\(?:\\(?:committ\\|nam\\)ed\\)\\|ser_defined_type_\\(?:catalog\\|name\\|schema\\)\\)\\)\\b" . font-lock-keyword-face) ("\\b\\(a\\(?:bsolute\\|ction\\|d\\(?:d\\|min\\)\\|fter\\|ggregate\\|l\\(?:ias\\|l\\(?:ocate\\)?\\|ter\\)\\|n[dy]\\|re\\|s\\(?:c\\|sertion\\)\\|uthorization\\|[st]\\)\\|b\\(?:e\\(?:fore\\|gin\\)\\|oth\\|readth\\|y\\)\\|c\\(?:a\\(?:ll\\|s\\(?:caded?\\|e\\)\\|talog\\)\\|heck\\|l\\(?:ass\\|ose\\)\\|o\\(?:l\\(?:lat\\(?:e\\|ion\\)\\|umn\\)\\|m\\(?:mit\\|pletion\\)\\|n\\(?:nect\\(?:ion\\)?\\|str\\(?:aints?\\|uctor\\)\\|tinue\\)\\|rresponding\\)\\|r\\(?:eate\\|oss\\)\\|u\\(?:be\\|r\\(?:rent\\|sor\\)\\)\\|ycle\\)\\|d\\(?:a\\(?:ta\\|y\\)\\|e\\(?:allocate\\|clare\\|f\\(?:ault\\|err\\(?:able\\|ed\\)\\)\\|lete\\|pth\\|ref\\|s\\(?:c\\(?:ri\\(?:be\\|ptor\\)\\)?\\|tr\\(?:oy\\|uctor\\)\\)\\|terministic\\)\\|i\\(?:agnostics\\|ctionary\\|s\\(?:\\(?:conne\\|tin\\)ct\\)\\)\\|omain\\|rop\\|ynamic\\)\\|e\\(?:ach\\|lse\\|nd\\|quals\\|scape\\|very\\|x\\(?:cept\\(?:ion\\)?\\|ec\\(?:ute\\)?\\|ternal\\)\\)\\|f\\(?:alse\\|etch\\|irst\\|o\\(?:r\\(?:eign\\)?\\|und\\)\\|r\\(?:ee\\|om\\)\\|u\\(?:ll\\|nction\\)\\)\\|g\\(?:e\\(?:neral\\|t\\)\\|lobal\\|o\\(?:to\\)?\\|r\\(?:ant\\|oup\\(?:ing\\)?\\)\\)\\|h\\(?:aving\\|o\\(?:st\\|ur\\)\\)\\|i\\(?:dentity\\|gnore\\|mmediate\\|n\\(?:dicator\\|itial\\(?:ize\\|ly\\)\\|ner\\|out\\|put\\|sert\\|t\\(?:ersect\\|o\\)\\)\\|solation\\|terate\\|[ns]\\)\\|join\\|key\\|l\\(?:a\\(?:nguage\\|st\\|teral\\)\\|e\\(?:ading\\|ft\\|ss\\|vel\\)\\|i\\(?:ke\\|mit\\)\\|oca\\(?:l\\|tor\\)\\)\\|m\\(?:a\\(?:p\\|tch\\)\\|inute\\|o\\(?:d\\(?:if\\(?:ies\\|y\\)\\|ule\\)\\|nth\\)\\)\\|n\\(?:a\\(?:mes\\|tural\\)\\|e\\(?:w\\|xt\\)\\|o\\(?:ne\\|t\\)?\\|ull\\)\\|o\\(?:ff\\|ld\\|nly\\|p\\(?:\\(?:e\\(?:ratio\\)?\\|tio\\)n\\)\\|rd\\(?:er\\|inality\\)\\|ut\\(?:er\\|put\\)?\\|[fnr]\\)\\|p\\(?:a\\(?:d\\|r\\(?:ameters?\\|tial\\)\\|th\\)\\|ostfix\\|r\\(?:e\\(?:fix\\|order\\|\\(?:par\\|serv\\)e\\)\\|i\\(?:mary\\|or\\|vileges\\)\\|ocedure\\)\\|ublic\\)\\|r\\(?:e\\(?:ads?\\|cursive\\|ferenc\\(?:es\\|ing\\)\\|lative\\|s\\(?:\\(?:tric\\|ul\\)t\\)\\|turns?\\|voke\\)\\|ight\\|o\\(?:l\\(?:e\\|l\\(?:back\\|up\\)\\)\\|utine\\|ws\\)\\)\\|s\\(?:avepoint\\|c\\(?:hema\\|roll\\)\\|e\\(?:arch\\|c\\(?:ond\\|tion\\)\\|lect\\|quence\\|ssion\\|ts?\\)\\|ize\\|ome\\|p\\(?:ace\\|ecific\\(?:type\\)?\\)\\|ql\\(?:exception\\|state\\|warning\\)?\\|t\\(?:a\\(?:rt\\|t\\(?:e\\(?:ment\\)?\\|ic\\)\\)\\|ructure\\)\\)\\|t\\(?:able\\|e\\(?:mporary\\|rminate\\)\\|h\\(?:[ae]n\\)\\|imezone_\\(?:hour\\|minute\\)\\|o\\|r\\(?:a\\(?:iling\\|ns\\(?:\\(?:ac\\|la\\)tion\\)\\)\\|igger\\|ue\\)\\)\\|u\\(?:n\\(?:der\\|i\\(?:on\\|que\\)\\|known\\|nest\\)\\|pdate\\|s\\(?:age\\|ing\\)\\)\\|v\\(?:a\\(?:lues?\\|riable\\)\\|iew\\)\\|w\\(?:he\\(?:n\\(?:ever\\)?\\|re\\)\\|ith\\(?:out\\)?\\|ork\\|rite\\)\\|year\\)\\b" . font-lock-keyword-face) ("\\b\\(a\\(?:bs\\|vg\\)\\|bit_length\\|c\\(?:a\\(?:rdinality\\|st\\)\\|har\\(?:\\(?:acter\\)?_length\\)\\|o\\(?:alesce\\|\\(?:nver\\|un\\)t\\)\\|urrent_\\(?:date\\|path\\|role\\|time\\(?:stamp\\)?\\|user\\)\\)\\|extract\\|lo\\(?:caltime\\(?:stamp\\)?\\|wer\\)\\|m\\(?:ax\\|in\\|od\\)\\|nullif\\|o\\(?:ctet_length\\|verlay\\)\\|placing\\|s\\(?:ession_user\\|u\\(?:bstring\\|m\\)\\|ystem_user\\)\\|tr\\(?:anslate\\|eat\\|im\\)\\|u\\(?:\\(?:pp\\|s\\)er\\)\\)\\b" . font-lock-builtin-face) ("\\b\\(array\\|b\\(?:i\\(?:nary\\|t\\)\\|lob\\|oolean\\)\\|c\\(?:har\\(?:acter\\)?\\|lob\\)\\|d\\(?:ate\\|ec\\(?:imal\\)?\\|ouble\\)\\|float\\|int\\(?:e\\(?:ger\\|rval\\)\\)?\\|large\\|n\\(?:ational\\|c\\(?:har\\|lob\\)\\|umeric\\)\\|object\\|precision\\|r\\(?:e\\(?:al\\|f\\)\\|ow\\)\\|s\\(?:cope\\|mallint\\)\\|time\\(?:stamp\\)?\\|var\\(?:char\\|ying\\)\\|zone\\)\\b" . font-lock-type-face)) (#$ . 38581))
(defalias 'sql--oracle-show-reserved-words #[0 "\302\303!\204\f \302\304!\203 \203 \305=\204 \306\307!\207\310\311\312\313\211%\210r\211q\210\314\301!\210\305\315\316\313\"\210\317\320!)\207" [sql-buffer sql-product derived-mode-p sql-mode sql-interactive-mode oracle user-error "Not an Oracle buffer" "*RESERVED WORDS*" sql-execute "SELECT keyword , reserved AS \"Res\" , res_type AS \"Type\" , res_attr AS \"Attr\" , res_semi AS \"Semi\" , duplicate AS \"Dup\" FROM V$RESERVED_WORDS WHERE length > 1 AND SUBSTR(keyword, 1, 1) BETWEEN 'A' AND 'Z' ORDER BY 2 DESC, 3 DESC, 4 DESC, 5 DESC, 6 DESC, 1;" nil make-local-variable sql-product-font-lock t font-lock-mode 1] 7])
#@354 Oracle 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)) (#$ . 45010))
#@306 Postgres 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-postgres-font-lock-keywords'.
(defvar sql-mode-postgres-font-lock-keywords '(("^\\s-*\\\\.*$" . font-lock-doc-face) ("\\b\\(a\\(?:bs\\(?:ent\\)?\\|ccording\\|da\\|l\\(?:ias\\|locate\\)\\|r\\(?:e\\|ray_agg\\)\\|sensitive\\|t\\(?:omic\\|tributes?\\)\\|vg\\)\\|b\\(?:ase64\\|ernoulli\\|it\\(?:_length\\|var\\)\\|lo\\(?:b\\|cked\\)\\|om\\|readth\\)\\|c\\(?:a\\(?:ll\\|rdinality\\|talog_name\\)\\|eil\\(?:ing\\)?\\|h\\(?:ar\\(?:_length\\|acter\\(?:_\\(?:length\\|set_\\(?:catalog\\|name\\|schema\\)\\)\\|s\\)\\)\\|ecked\\)\\|l\\(?:ass_origin\\|ob\\)\\|o\\(?:bol\\|l\\(?:l\\(?:ation\\(?:_\\(?:catalog\\|name\\|schema\\)\\)?\\|ect\\)\\|umn\\(?:_name\\|s\\)\\)\\|m\\(?:mand_function\\(?:_code\\)?\\|pletion\\)\\|n\\(?:dition\\(?:_number\\)?\\|nect\\(?:ion_name\\)?\\|str\\(?:aint_\\(?:catalog\\|name\\|schema\\)\\|uctor\\)\\|t\\(?:ains\\|rol\\)\\|vert\\)\\|rr\\(?:esponding\\)?\\|unt\\|var_\\(?:\\(?:po\\|sam\\)p\\)\\)\\|u\\(?:be\\|me_dist\\|r\\(?:rent_\\(?:default_transform_group\\|path\\|transform_group_for_type\\)\\|sor_name\\)\\)\\)\\|d\\(?:at\\(?:alink\\|etime_interval_\\(?:code\\|precision\\)\\)\\|b\\|e\\(?:fined\\|gree\\|nse_rank\\|pth\\|r\\(?:ef\\|ived\\)\\|s\\(?:cri\\(?:be\\|ptor\\)\\|tr\\(?:oy\\|uctor\\)\\)\\|terministic\\)\\|i\\(?:agnostics\\|s\\(?:connect\\|patch\\)\\)\\|l\\(?:newcopy\\|previouscopy\\|url\\(?:complete\\(?:only\\|write\\)?\\|path\\(?:only\\|write\\)?\\|s\\(?:cheme\\|erver\\)\\)\\|value\\)\\|ynamic\\(?:_function\\(?:_code\\)?\\)?\\)\\|e\\(?:lement\\|mpty\\|nd-exec\\|quals\\|very\\|x\\(?:ception\\|ec\\|isting\\|p\\)\\)\\|f\\(?:i\\(?:l\\(?:e\\|ter\\)\\|nal\\|rst_value\\)\\|l\\(?:ag\\|oor\\)\\|o\\(?:rtran\\|und\\)\\|ree\\|s\\|usion\\)\\|g\\(?:e\\(?:nera\\(?:l\\|ted\\)\\|t\\)\\|o\\(?:to\\)?\\|rouping\\)\\|h\\(?:ex\\|ierarchy\\|ost\\)\\|i\\(?:d\\|gnore\\|mp\\(?:lementation\\|ort\\)\\|n\\(?:d\\(?:ent\\|icator\\)\\|fix\\|itialize\\|stan\\(?:\\(?:c\\|tiabl\\)e\\)\\|te\\(?:grity\\|rsection\\)\\)\\|terate\\)\\|key_\\(?:member\\|type\\)\\|l\\(?:a\\(?:g\\|st_value\\|teral\\)\\|e\\(?:ad\\|ngth\\|ss\\)\\|i\\(?:brary\\|ke_regex\\|nk\\)\\|n\\|o\\(?:\\(?:cato\\|we\\)r\\)\\)\\|m\\(?:a\\(?:tched\\|x_cardinality\\|[px]\\)\\|e\\(?:mber\\|rge\\|ssage_\\(?:length\\|octet_length\\|text\\)\\|thod\\)\\|in\\|o\\(?:d\\(?:if\\(?:ies\\|y\\)\\|ule\\)?\\|re\\)\\|u\\(?:ltiset\\|mps\\)\\)\\|n\\(?:amespace\\|clob\\|e\\(?:sting\\|w\\)\\|f\\(?:k[cd]\\|[cd]\\)\\|il\\|ormalized?\\|t\\(?:\\(?:h_valu\\|il\\)e\\)\\|u\\(?:llable\\|mber\\)\\)\\|o\\(?:c\\(?:currences_regex\\|tet\\(?:_length\\|s\\)\\)\\|ld\\|pe\\(?:\\(?:ratio\\)?n\\)\\|rd\\(?:ering\\|inality\\)\\|thers\\|utput\\|verriding\\)\\|p\\(?:a\\(?:d\\|rameter\\(?:_\\(?:mode\\|name\\|ordinal_position\\|specific_\\(?:catalog\\|name\\|schema\\)\\)\\|s\\)?\\|s\\(?:cal\\|s\\(?:ing\\|through\\)\\)\\)\\|er\\(?:cent\\(?:_rank\\|ile_\\(?:cont\\|disc\\)\\)\\|mission\\)\\|li\\|o\\(?:s\\(?:\\(?:ition_rege\\|tfi\\)x\\)\\|wer\\)\\|re\\(?:fix\\|order\\)\\|ublic\\)\\|r\\(?:ank\\|e\\(?:ads\\|covery\\|f\\(?:erencing\\)?\\|gr_\\(?:avg[xy]\\|count\\|intercept\\|r2\\|s\\(?:lope\\|x[xy]\\|yy\\)\\)\\|quiring\\|s\\(?:pect\\|tore\\|ult\\)\\|turn\\(?:ed_\\(?:cardinality\\|length\\|octet_length\\|sqlstate\\)\\)?\\)\\|o\\(?:llup\\|utine\\(?:_\\(?:catalog\\|name\\|schema\\)\\)?\\|w_\\(?:count\\|number\\)\\)\\)\\|s\\(?:c\\(?:ale\\|hema_name\\|ope\\(?:_\\(?:catalog\\|name\\|schema\\)\\)?\\)\\|e\\(?:ction\\|l\\(?:ective\\|f\\)\\|nsitive\\|rver_name\\|ts\\)\\|ize\\|ource\\|p\\(?:ace\\|ecific\\(?:\\(?:_nam\\|typ\\)e\\)?\\)\\|q\\(?:l\\(?:code\\|e\\(?:rror\\|xception\\)\\|state\\|warning\\)?\\|rt\\)\\|t\\(?:at\\(?:e\\|ic\\)\\|ddev_\\(?:\\(?:po\\|sam\\)p\\)\\|\\(?:ructur\\|yl\\)e\\)\\|u\\(?:b\\(?:class_origin\\|list\\|multiset\\|string_regex\\)\\|m\\)\\|ystem_user\\)\\|t\\(?:able\\(?:\\(?:_nam\\|sampl\\)e\\)\\|erminate\\|han\\|i\\(?:es\\|mezone_\\(?:hour\\|minute\\)\\)\\|o\\(?:ken\\|p_level_count\\)\\|r\\(?:ans\\(?:action\\(?:_active\\|s_\\(?:committed\\|rolled_back\\)\\)\\|forms?\\|lat\\(?:e\\(?:_regex\\)?\\|ion\\)\\)\\|i\\(?:gger_\\(?:catalog\\|name\\|schema\\)\\|m_array\\)\\)\\)\\|u\\(?:escape\\|n\\(?:der\\|link\\|n\\(?:amed\\|est\\)\\|typed\\)\\|pper\\|ri\\|s\\(?:age\\|er_defined_type_\\(?:c\\(?:atalog\\|ode\\)\\|name\\|schema\\)\\)\\)\\|var\\(?:_\\(?:\\(?:po\\|sam\\)p\\)\\|binary\\|iable\\)\\|w\\(?:henever\\|i\\(?:dth_bucket\\|thin\\)\\)\\|xml\\(?:agg\\|binary\\|c\\(?:\\(?:as\\|ommen\\)t\\)\\|d\\(?:eclaration\\|ocument\\)\\|exists\\|iterate\\|namespaces\\|query\\|schema\\|t\\(?:able\\|ext\\)\\|validate\\)\\|[acgkmpt]\\)\\b" . font-lock-builtin-face) ("\\b\\(a\\(?:b\\(?:ort\\|solute\\)\\|c\\(?:cess\\|tion\\)\\|d\\(?:d\\|min\\)\\|fter\\|ggregate\\|l\\(?:so\\|ter\\|ways\\)\\|ss\\(?:ertion\\|ignment\\)\\|t\\(?:tribute\\)?\\)\\|b\\(?:ackward\\|e\\(?:fore\\|\\(?:gi\\|twee\\)n\\)\\|y\\)\\|c\\(?:a\\(?:che\\|lled\\|scaded?\\|talog\\)\\|h\\(?:a\\(?:in\\|racteristics\\)\\|eckpoint\\)\\|l\\(?:ass\\|ose\\|uster\\)\\|o\\(?:alesce\\|mm\\(?:ents?\\|it\\(?:ted\\)?\\)\\|n\\(?:figuration\\|nection\\|straints\\|t\\(?:ent\\|inue\\)\\|version\\)\\|py\\|st\\)\\|reate\\(?:db\\|role\\|user\\)\\|sv\\|ur\\(?:rent\\|sor\\)\\|ycle\\)\\|d\\(?:a\\(?:ta\\(?:base\\)?\\|y\\)\\|e\\(?:allocate\\|c\\(?:lare\\)?\\|f\\(?:aults\\|erred\\|iner\\)\\|l\\(?:ete\\|imiters?\\)\\)\\|i\\(?:ctionary\\|s\\(?:able\\|card\\)\\)\\|o\\(?:cument\\|main\\)\\|rop\\)\\|e\\(?:ach\\|n\\(?:able\\|c\\(?:oding\\|rypted\\)\\|um\\)\\|scape\\|x\\(?:clu\\(?:d\\(?:e\\|ing\\)\\|sive\\)\\|ecute\\|ists\\|plain\\|t\\(?:e\\(?:nsion\\|rnal\\)\\|ract\\)\\)\\)\\|f\\(?:amily\\|irst\\|loat\\|o\\(?:llowing\\|r\\(?:ce\\|ward\\)\\)\\|unctions?\\)\\|g\\(?:lobal\\|r\\(?:anted\\|eatest\\)\\)\\|h\\(?:andler\\|eader\\|o\\(?:ld\\|ur\\)\\)\\|i\\(?:dentity\\|f\\|m\\(?:m\\(?:\\(?:ediat\\|utabl\\)e\\)\\|plicit\\)\\|n\\(?:c\\(?:luding\\|rement\\)\\|dex\\(?:es\\)?\\|herits?\\|line\\|out\\|put\\|s\\(?:e\\(?:nsitive\\|rt\\)\\|tead\\)\\|voker\\)\\|solation\\)\\|key\\|l\\(?:a\\(?:bel\\|nguage\\|rge\\|st\\)\\|c_c\\(?:\\(?:ollat\\|typ\\)e\\)\\|e\\(?:a\\(?:kproof\\|st\\)\\|vel\\)\\|isten\\|o\\(?:ad\\|c\\(?:a\\(?:l\\|tion\\)\\|k\\)\\|gin\\)\\)\\|m\\(?:a\\(?:pping\\|tch\\|xvalue\\)\\|in\\(?:\\(?:ut\\|valu\\)e\\)\\|o\\(?:de\\|nth\\|ve\\)\\)\\|n\\(?:a\\(?:mes\\|tional\\)\\|char\\|ext\\|o\\(?:create\\(?:db\\|role\\|user\\)\\|inherit\\|login\\|ne\\|replication\\|superuser\\|t\\(?:hing\\|ify\\)\\|wait\\)?\\|ull\\(?:if\\|s\\)\\)\\|o\\(?:bject\\|ff?\\|ids\\|p\\(?:erator\\|tions?\\)\\|ut\\|verlay\\|wne[dr]\\)\\|p\\(?:a\\(?:r\\(?:ser\\|ti\\(?:al\\|tion\\)\\)\\|ss\\(?:ing\\|word\\)\\)\\|lans\\|osition\\|r\\(?:e\\(?:c\\(?:eding\\|ision\\)\\|pared?\\|serve\\)\\|i\\(?:or\\|vileges\\)\\|ocedur\\(?:al\\|e\\)\\)\\)\\|quote\\|r\\(?:ange\\|e\\(?:a\\(?:d\\|ssign\\)\\|c\\(?:heck\\|ursive\\)\\|f\\|index\\|l\\(?:\\(?:ativ\\|eas\\)e\\)\\|name\\|p\\(?:eatable\\|l\\(?:ace\\|ica\\(?:tion\\)?\\)\\)\\|s\\(?:\\(?:e\\|t\\(?:ar\\|ric\\)\\)t\\)\\|turns\\|voke\\)\\|o\\(?:l\\(?:e\\|lback\\)\\|ws?\\)\\|ule\\)\\|s\\(?:avepoint\\|c\\(?:hema\\|roll\\)\\|e\\(?:arch\\|c\\(?:ond\\|urity\\)\\|quence\\|r\\(?:ializable\\|ver\\)\\|ssion\\|t\\(?:of\\)?\\)\\|h\\(?:are\\|ow\\)\\|imple\\|napshot\\|t\\(?:a\\(?:ble\\|ndalone\\|rt\\|t\\(?:ement\\|istics\\)\\)\\|d\\(?:in\\|out\\)\\|orage\\|ri\\(?:ct\\|p\\)\\)\\|u\\(?:bstring\\|peruser\\)\\|ys\\(?:id\\|tem\\)\\)\\|t\\(?:ables\\(?:pace\\)?\\|emp\\(?:late\\|orary\\)?\\|r\\(?:ansaction\\|eat\\|im\\|u\\(?:ncate\\|sted\\)\\)\\|ypes?\\)\\|u\\(?:n\\(?:bounded\\|committed\\|encrypted\\|l\\(?:isten\\|ogged\\)\\|til\\)\\|pdate\\)\\|v\\(?:a\\(?:cuum\\|l\\(?:id\\(?:at\\(?:e\\|or\\)\\)?\\|ues?\\)\\|rying\\)\\|ersion\\|iew\\|olatile\\)\\|w\\(?:hitespace\\|ithout\\|ork\\|r\\(?:apper\\|ite\\)\\)\\|xml\\(?:attributes\\|concat\\|e\\(?:lement\\|xists\\)\\|forest\\|p\\(?:arse\\|i\\)\\|root\\|serialize\\)\\|ye\\(?:ar\\|s\\)\\|zone\\)\\b" . font-lock-builtin-face) ("\\b\\(a\\(?:ll\\|n\\(?:aly\\(?:[sz]e\\)\\|d\\)\\|rray\\|s\\(?:\\(?:ymmetri\\)?c\\)?\\|uthorization\\)\\|b\\(?:inary\\|oth\\)\\|c\\(?:as[et]\\|heck\\|o\\(?:l\\(?:late\\|umn\\)\\|n\\(?:currently\\|straint\\)\\)\\|r\\(?:eate\\|oss\\)\\|urrent_\\(?:catalog\\|date\\|role\\|schema\\|time\\(?:stamp\\)?\\|user\\)\\)\\|d\\(?:e\\(?:f\\(?:ault\\|errable\\)\\|sc\\)\\|istinct\\|o\\)\\|e\\(?:lse\\|nd\\|xcept\\)\\|f\\(?:alse\\|etch\\|or\\(?:eign\\)?\\|r\\(?:eeze\\|om\\)\\|ull\\)\\|gr\\(?:ant\\|oup\\)\\|having\\|i\\(?:like\\|n\\(?:itially\\|ner\\|t\\(?:ersect\\|o\\)\\)\\|snull\\|[ns]\\)\\|join\\|l\\(?:e\\(?:ading\\|ft\\)\\|i\\(?:ke\\|mit\\)\\|ocaltime\\(?:stamp\\)?\\)\\|n\\(?:atural\\|ot\\(?:null\\)?\\|ull\\)\\|o\\(?:ffset\\|nly\\|rder\\|uter\\|ver\\(?:laps\\)?\\|[nr]\\)\\|p\\(?:lacing\\|rimary\\)\\|r\\(?:e\\(?:ferences\\|turning\\)\\|ight\\)\\|s\\(?:e\\(?:lect\\|ssion_user\\)\\|imilar\\|ome\\|ymmetric\\)\\|t\\(?:able\\|hen\\|o\\|r\\(?:ailing\\|ue\\)\\)\\|u\\(?:ni\\(?:on\\|que\\)\\|s\\(?:er\\|ing\\)\\)\\|v\\(?:ariadic\\|erbose\\)\\|w\\(?:he\\(?:n\\|re\\)\\|i\\(?:ndow\\|th\\)\\)\\)\\b" . font-lock-keyword-face) ("\\b\\(assign\\|c\\(?:\\(?:a\\|lo\\)se\\)\\|dynexecute\\|e\\(?:lsif\\|x\\(?:ecsql\\|it\\)\\)\\|f\\(?:etch\\|or\\(?:each\\)?\\)\\|getdiag\\|if\\|loop\\|move\\|open\\|perform\\|r\\(?:aise\\|eturn\\)\\|while\\)\\b" . font-lock-keyword-face) ("\\b\\(b\\(?:i\\(?:g\\(?:int\\|serial\\)\\|t\\)\\|o\\(?:ol\\(?:ean\\)?\\|x\\)\\|ytea\\)\\|c\\(?:har\\(?:acter\\)?\\|i\\(?:dr\\|rcle\\)\\)\\|d\\(?:ate\\|ecimal\\|ouble\\)\\|float[48]\\|in\\(?:et\\|t\\(?:e\\(?:ger\\|rval\\)\\|[248]\\)?\\)\\|l\\(?:ine\\|seg\\)\\|m\\(?:acaddr\\|oney\\)\\|n\\(?:ame\\|umeric\\)\\|p\\(?:ath\\|o\\(?:int\\|lygon\\)\\|recision\\)\\|real\\|s\\(?:e\\(?:quences\\|rial[48]?\\)\\|mallint\\)\\|t\\(?:ext\\|ime\\(?:stamp\\(?:tz\\)?\\|tz\\)?\\|s\\(?:query\\|vector\\)\\|xid_snapshot\\)\\|u\\(?:nknown\\|uid\\)\\|var\\(?:bit\\|char\\|ying\\)\\|without\\|xml\\|zone\\)\\b" . font-lock-type-face)) (#$ . 64182))
#@199 Linter 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'.
(defvar sql-mode-linter-font-lock-keywords '(("\\b\\(auto\\(?:commit\\|inc\\|rowid\\)\\|c\\(?:a\\(?:ncel\\|scade\\)\\|hannel\\|o\\(?:mmitted\\|unt\\(?:blob\\)?\\)\\|ross\\|urrent\\)\\|d\\(?:at\\(?:a\\(?:base\\|files?\\)?\\|esplit\\)\\|b\\(?:a\\|name\\)\\|e\\(?:f\\(?:ault\\|erred\\)\\|nied\\|scription\\|vice\\)\\|i\\(?:fference\\|rectory\\)\\)\\|e\\(?:rror\\|scape\\|uc\\|x\\(?:clusive\\|t\\(?:ernal\\|file\\)\\)\\)\\|f\\(?:alse\\|i\\(?:l\\(?:e\\(?:\\(?:nam\\|siz\\|tim\\)e\\)?\\|ter\\)\\|ndblob\\|rst\\)\\|oreign\\|u\\(?:ll\\|zzy\\)\\)\\|g\\(?:lobal\\|ranted\\)\\|i\\(?:gnore\\|mmediate\\|n\\(?:crement\\|dex\\(?:es\\|files?\\|time\\)\\|itial\\|te\\(?:grity\\|rnal\\)\\)\\)\\|key\\|l\\(?:ast_\\(?:autoinc\\|rowid\\)\\|i\\(?:mit\\|nter\\(?:_\\(?:file_\\(?:\\(?:devic\\|siz\\)e\\)\\|name_length\\)\\)?\\)\\|n\\|o\\(?:cal\\|gin\\)\\)\\|m\\(?:ax\\(?:isn\\|row\\(?:id\\)?\\|value\\)\\|\\(?:essag\\|invalu\\|odul\\)e\\)\\|n\\(?:a\\(?:mes\\|t\\(?:\\(?:ion\\|ur\\)al\\)\\)\\|ew\\(?:_table\\)?\\|o\\(?:de\\|neuc\\)?\\|u\\(?:lliferror\\|mbers\\)\\)\\|o\\(?:ff\\|ld\\(?:_table\\)?\\|nly\\|p\\(?:eration\\|ti\\(?:mistic\\|on\\)\\)\\)\\|p\\(?:a\\(?:ge\\|rtially\\|ssword\\)\\|hrase\\|lan\\|r\\(?:ecision\\|i\\(?:mary\\|ority\\|vileges\\)\\|o\\(?:c_\\(?:info_size\\|par_name_len\\)\\|tocol\\)\\)\\)\\|quant\\|r\\(?:a\\(?:nge\\|w\\)\\|e\\(?:ad\\|cords?\\|ferences\\|mote\\|name\\|plication\\|start\\|write\\)\\|o\\(?:ot\\|w\\)\\|ule\\)\\|s\\(?:avepoint\\|e\\(?:curity\\|nsitive\\|quence\\|r\\(?:ializable\\|ver\\)\\)\\|i\\(?:\\(?:nc\\|z\\)e\\)\\|ome\\|ta\\(?:rtup\\|t\\(?:ement\\|ion\\)\\)\\|uccess\\|ys_guid\\)\\|t\\(?:ables\\|est\\|imeout\\|r\\(?:a\\(?:ce\\|ns\\(?:\\(?:ac\\|la\\)tion\\)\\)\\|igger\\(?:_info_size\\)?\\|u\\(?:e\\|nc\\)\\)\\)\\|u\\(?:n\\(?:committed\\|icode\\|known\\|li\\(?:\\(?:mi\\|s\\)ted\\)\\)\\|ser\\|tf8\\)\\|v\\(?:a\\(?:lue\\|rying\\)\\|olumes\\)\\|w\\(?:ait\\|\\(?:indows_cod\\|orkspac\\|rit\\)e\\)\\|xml\\)\\b" . font-lock-keyword-face) ("\\b\\(a\\(?:c\\(?:cess\\|tion\\)\\|dd\\(?:ress\\)?\\|fter\\|l\\(?:l\\|ter\\|ways\\)\\|n[dy]\\|ppend\\|s\\(?:\\(?:ci\\|yn\\)?c\\)?\\|t_\\(?:begin\\|end\\)\\|ud\\(?:_obj_name_len\\|it\\)\\)\\|b\\(?:a\\(?:ckup\\|se\\)\\|e\\(?:fore\\|tween\\)\\|lob\\(?:files?\\|pct\\)\\|r\\(?:ief\\|owse\\)\\|y\\)\\|c\\(?:as[et]\\|heck\\|l\\(?:ear\\|ose\\)\\|o\\(?:lumn\\|mm\\(?:\\(?:en\\|i\\)t\\)\\|n\\(?:nect\\|tains\\)\\|rrect\\)\\|reate\\)\\|d\\(?:e\\(?:lete\\|sc\\)\\|is\\(?:able\\|\\(?:conne\\|tin\\)ct\\)\\|rop\\)\\|e\\(?:ach\\|f\\|lse\\|n\\(?:able\\|d\\)\\|vent\\|x\\(?:c\\(?:ept\\|lude\\)\\|ecute\\|ists\\|tract\\)\\)\\|f\\(?:etch\\|inish\\|or\\|rom\\)\\|g\\(?:et\\|r\\(?:ant\\|oup\\)\\)\\|having\\|i\\(?:dentified\\|n\\(?:dex\\|ner\\|s\\(?:ert\\|tead\\)\\|t\\(?:ersect\\|o\\)\\)\\|solation\\|[ns]\\)\\|join\\|l\\(?:e\\(?:ft\\|vel\\)\\|ike\\|ock\\)\\|mod\\(?:e\\|ify\\)\\|n\\(?:o\\(?:\\(?:wai\\)?t\\)\\|ull\\)\\|o\\(?:pen\\|\\(?:rd\\|ut\\|wn\\)er\\|[fnr]\\)\\|p\\(?:r\\(?:ess\\|ior\\|ocedure\\)\\|u\\(?:blic\\|rge\\)\\)\\|r\\(?:e\\(?:build\\|s\\(?:ource\\|trict\\)\\|voke\\)\\|ight\\|o\\(?:l\\(?:e\\|lback\\)\\|wnum\\)\\)\\|s\\(?:e\\(?:lect\\|ssion\\|t\\)\\|h\\(?:are\\|utdown\\)\\|t\\(?:art\\|op\\)\\|y\\(?:n\\(?:c\\(?:hronize\\)?\\|onym\\)\\|sdate\\)\\)\\|t\\(?:able\\|hen\\|o\\)\\|u\\(?:n\\(?:i\\(?:on\\|que\\)\\|lock\\|til\\)\\|pdate\\|sing\\)\\|v\\(?:alues\\|iew\\)\\|w\\(?:he\\(?:n\\|re\\)\\|ith\\(?:out\\)?\\)\\)\\b" . font-lock-keyword-face) ("\\b\\(a\\(?:bs\\|cos\\|sin\\|tan2?\\|vg\\)\\|c\\(?:eil\\|hr\\|osh?\\)\\|d\\(?:ay\\(?:name\\|s\\)\\|\\(?:ecod\\|ivtim\\)e\\)\\|exp\\|floor\\|g\\(?:et\\(?:b\\(?:its\\|lob\\|yte\\)\\|long\\|raw\\|str\\|text\\|word\\)\\|reatest\\)\\|hex\\(?:toraw\\)?\\|in\\(?:itcap\\|str\\)\\|l\\(?:e\\(?:ast\\|n\\(?:blob\\|gth\\)\\)\\|o\\(?:g\\|wer\\)\\|pad\\|trim\\)\\|m\\(?:ax\\|in\\|o\\(?:d\\|nthname\\)\\|ultime\\)\\|nvl\\|octet_length\\|power\\|r\\(?:a\\(?:nd\\|wtohex\\)\\|ep\\(?:eat_string\\|lace\\)\\|ight_substr\\|ound\\|pad\\|trim\\)\\|s\\(?:i\\(?:gn\\|nh?\\)\\|oundex\\|qrt\\|u\\(?:bstr\\(?:ing\\)?\\|m\\)\\)\\|t\\(?:anh?\\|imeint_to_days\\|o_\\(?:char\\|date\\|gmtime\\|localtime\\|number\\)\\|rim\\)\\|upper\\|width\\)\\b" . font-lock-builtin-face) ("\\b\\(b\\(?:i\\(?:gint\\|tmap\\)\\|lob\\|oolean\\|yte\\)\\|c\\(?:\\(?:ha\\(?:racte\\)?\\|urso\\)r\\)\\|d\\(?:ate\\(?:time\\)?\\|ec\\(?:imal\\)?\\|ouble\\)\\|float\\|int\\(?:eger\\)?\\|long\\|n\\(?:char\\|um\\(?:ber\\|eric\\)\\)\\|real\\|smallint\\|var\\(?:byte\\|char\\)\\)\\b" . font-lock-type-face)) (#$ . 74220))
#@311 Microsoft SQLServer 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-ms-font-lock-keywords'.
(defvar sql-mode-ms-font-lock-keywords '(("^\\(?:\\(?:set\\s-+\\(?:\\(a\\(?:nsi_\\(?:defaults\\|null\\(?:_dflt_o\\(?:ff\\|n\\)\\|s\\)\\|padding\\|warnings\\)\\|rith\\(?:abort\\|ignore\\)\\)\\|c\\(?:oncat_null_yields_null\\|ursor_close_on_commit\\)\\|d\\(?:atef\\(?:\\(?:irs\\|orma\\)t\\)\\|eadlock_priority\\|isable_def_cnst_chk\\)\\|f\\(?:ips_flagger\\|mtonly\\|orceplan\\)\\|i\\(?:dentity_insert\\|mplicit_transactions\\)\\|l\\(?:anguage\\|ock_timeout\\)\\|n\\(?:o\\(?:count\\|exec\\)\\|umeric_roundabort\\)\\|offsets\\|parseonly\\|qu\\(?:ery_governor_cost_limit\\|oted_identifier\\)\\|r\\(?:emote_proc_transactions\\|owcount\\)\\|s\\(?:howplan_\\(?:all\\|text\\)\\|tatistics\\)\\|t\\(?:extsize\\|ransaction\\)\\|xact_abort\\)\\)\\)\\|go\\s-*\\|use\\s-+\\|setuser\\s-+\\|dbcc\\s-+\\).*$" . font-lock-doc-face) ("\\b\\(a\\(?:bsolute\\|dd\\|l\\(?:l\\|ter\\)\\|n[dy]\\|sc?\\|uthorization\\|vg\\)\\|b\\(?:ackup\\|e\\(?:\\(?:gi\\|twee\\)n\\)\\|r\\(?:eak\\|owse\\)\\|ulk\\|y\\)\\|c\\(?:as\\(?:\\(?:cad\\)?e\\)\\|heck\\(?:point\\)?\\|l\\(?:ose\\|ustered\\)\\|o\\(?:alesce\\|l\\(?:late\\|umn\\)\\|m\\(?:mit\\(?:ted\\)?\\|pute\\)\\|n\\(?:firm\\|straint\\|t\\(?:ains\\(?:table\\)?\\|inue\\|rolrow\\)\\|vert\\)\\|unt\\)\\|r\\(?:eate\\|oss\\)\\|urrent\\(?:_\\(?:date\\|time\\(?:stamp\\)?\\|user\\)\\)?\\)\\|d\\(?:atabase\\|e\\(?:allocate\\|clare\\|fault\\|lete\\|ny\\|sc\\)\\|is\\(?:k\\|t\\(?:inct\\|ributed\\)\\)\\|ouble\\|rop\\|um\\(?:my\\|p\\)\\)\\|e\\(?:lse\\|nd\\|rr\\(?:lvl\\|orexit\\)\\|scape\\|x\\(?:cept\\|ec\\(?:ute\\)?\\|i\\(?:sts\\|t\\)\\)\\)\\|f\\(?:etch\\|i\\(?:l\\(?:e\\|lfactor\\)\\|rst\\)\\|loppy\\|or\\(?:eign\\)?\\|r\\(?:eetext\\(?:table\\)?\\|om\\)\\|u\\(?:ll\\|nction\\)\\)\\|g\\(?:oto\\|r\\(?:ant\\|oup\\)\\)\\|h\\(?:aving\\|oldlock\\)\\|i\\(?:dentity\\(?:_insert\\|col\\)?\\|n\\(?:dex\\|ner\\|sert\\|t\\(?:ersect\\|o\\)\\)\\|solation\\|[fns]\\)\\|join\\|k\\(?:ey\\|ill\\)\\|l\\(?:ast\\|e\\(?:ft\\|vel\\)\\|i\\(?:ke\\|neno\\)\\|oad\\)\\|m\\(?:ax\\|i\\(?:n\\|rrorexit\\)\\)\\|n\\(?:ational\\|ext\\|o\\(?:check\\|lock\\|nclustered\\|t\\)\\|ull\\(?:if\\)?\\)\\|o\\(?:ff\\(?:sets\\)?\\|n\\(?:ce\\|ly\\)\\|p\\(?:en\\(?:datasource\\|query\\|rowset\\|xml\\)?\\|tion\\)\\|rder\\|ut\\(?:er\\|put\\)\\|ver\\|[fnr]\\)\\|p\\(?:aglock\\|er\\(?:cent\\|m\\(?:anent\\)?\\)\\|ipe\\|lan\\|r\\(?:e\\(?:cision\\|pare\\)\\|i\\(?:mary\\|nt\\|or\\|vileges\\)\\|oc\\(?:e\\(?:dure\\|ssexit\\)\\)?\\)\\|ublic\\)\\|r\\(?:aiserror\\|e\\(?:ad\\(?:committed\\|past\\|text\\|uncommitted\\)?\\|configure\\|ferences\\|lative\\|p\\(?:eatable\\(?:read\\)?\\|lication\\)\\|st\\(?:ore\\|rict\\)\\|turns?\\|voke\\)\\|ight\\|o\\(?:llback\\|w\\(?:count\\|guidcol\\|lock\\)\\)\\|ule\\)\\|s\\(?:ave\\|chema\\|e\\(?:lect\\|rializable\\|ssion_user\\|t\\)\\|hutdown\\|ome\\|tatistics\\|um\\|ystem_user\\)\\|t\\(?:a\\(?:bl\\(?:e\\|ockx?\\)\\|pe\\)\\|e\\(?:mp\\(?:orary\\)?\\|xtsize\\)\\|hen\\|op?\\|r\\(?:an\\(?:saction\\)?\\|igger\\|uncate\\)\\|sequal\\)\\|u\\(?:n\\(?:committed\\|i\\(?:on\\|que\\)\\)\\|pd\\(?:ate\\(?:text\\)?\\|lock\\)\\|ser?\\)\\|v\\(?:alues\\|iew\\)\\|w\\(?:aitfor\\|h\\(?:e\\(?:n\\|re\\)\\|ile\\)\\|ith\\|ork\\|ritetext\\)\\)\\b" . font-lock-keyword-face) ("\\b\\(@@\\(?:c\\(?:onnections\\|pu_busy\\|ursor_rows\\)\\|d\\(?:atefirst\\|bts\\)\\|error\\|fetch_status\\|i\\(?:d\\(?:entity\\|le\\)\\|o_busy\\)\\|l\\(?:ang\\(?:id\\|uage\\)\\|ock_timeout\\)\\|max_\\(?:connections\\|precision\\)\\|nestlevel\\|options\\|p\\(?:ack\\(?:_\\(?:received\\|sent\\)\\|et_errors\\)\\|rocid\\)\\|r\\(?:emserver\\|owcount\\)\\|s\\(?:erv\\(?:\\(?:er\\|ice\\)name\\)\\|pid\\)\\|t\\(?:extsize\\|imeticks\\|otal_\\(?:errors\\|read\\|write\\)\\|rancount\\)\\|version\\)\\|a\\(?:bs\\|cos\\|nd\\|pp_name\\|s\\(?:cii\\|in\\)\\|t\\(?:an\\|n2\\)\\|vg\\)\\|c\\(?:as[et]\\|eiling\\|har\\(?:index\\)?\\|o\\(?:alesce\\|l\\(?:_\\(?:length\\|name\\)\\|umnproperty\\)\\|n\\(?:tainstable\\|vert\\)\\|unt\\|[st]\\)\\|ur\\(?:rent_\\(?:timestamp\\|user\\)\\|sor_status\\)\\)\\|d\\(?:a\\(?:t\\(?:a\\(?:baseproperty\\|length\\)\\|e\\(?:add\\|diff\\|name\\|part\\)\\)\\|y\\)\\|b_\\(?:id\\|name\\)\\|egrees\\|ifference\\)\\|exp\\|f\\(?:ile\\(?:_\\(?:id\\|name\\)\\|group\\(?:_\\(?:id\\|name\\)\\|property\\)\\|property\\)\\|loor\\|ormatmessage\\|reetexttable\\|ulltext\\(?:\\(?:catalog\\|service\\)property\\)\\)\\|g\\(?:et\\(?:ansinull\\|date\\)\\|rouping\\)\\|host_\\(?:id\\|name\\)\\|i\\(?:dent\\(?:_\\(?:incr\\|seed\\)\\|ity\\)\\|ndex\\(?:_col\\|property\\)\\|s\\(?:_\\(?:\\(?:srvrole\\)?member\\)\\|date\\|nu\\(?:ll\\|meric\\)\\)\\)\\|l\\(?:e\\(?:ft\\|n\\)\\|o\\(?:g\\(?:10\\)?\\|wer\\)\\|trim\\)\\|m\\(?:ax\\|in\\|onth\\)\\|n\\(?:char\\|ewid\\|ullif\\)\\|o\\(?:bject\\(?:_\\(?:id\\|name\\)\\|property\\)\\|pen\\(?:query\\|rowset\\)\\)\\|p\\(?:a\\(?:rsename\\|tindex\\)\\|ermissions\\|i\\|ower\\)\\|quotename\\|r\\(?:a\\(?:dians\\|nd\\)\\|e\\(?:\\(?:pl\\(?:ac\\|icat\\)\\|vers\\)e\\)\\|ight\\|ound\\|trim\\)\\|s\\(?:ession_user\\|i\\(?:g?n\\)\\|oundex\\|pace\\|q\\(?:rt\\|uare\\)\\|t\\(?:ats_date\\|devp?\\|r\\|uff\\)\\|u\\(?:bstring\\|m\\|ser_\\(?:id\\|name\\|s\\(?:id\\|name\\)\\)\\)\\|ystem_user\\)\\|t\\(?:an\\|ext\\(?:ptr\\|valid\\)\\|ypeproperty\\)\\|u\\(?:nicode\\|pper\\|ser\\(?:_\\(?:id\\|name\\)\\)?\\)\\|varp?\\|year\\)\\b" . font-lock-builtin-face) ("\\b@[a-zA-Z0-9_]*\\b" . font-lock-variable-name-face) ("\\b\\(bi\\(?:nary\\|t\\)\\|c\\(?:\\(?:ha\\(?:racte\\)?\\|urso\\)r\\)\\|d\\(?:atetime\\|ec\\(?:imal\\)?\\|ouble\\)\\|float\\|i\\(?:mage\\|nt\\(?:eger\\)?\\)\\|money\\|n\\(?:ational\\|char\\|text\\|umeric\\|varchar\\)\\|precision\\|real\\|small\\(?:datetime\\|int\\|money\\)\\|t\\(?:ext\\|i\\(?:mestamp\\|nyint\\)\\)\\|uniqueidentifier\\|var\\(?:binary\\|char\\|ying\\)\\)\\b" . font-lock-type-face)) (#$ . 78881))
#@302 Sybase 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-sybase-font-lock-keywords'.
(defvar sql-mode-sybase-font-lock-keywords nil (#$ . 84881))
#@306 Informix 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-informix-font-lock-keywords'.
(defvar sql-mode-informix-font-lock-keywords nil (#$ . 85250))
#@308 Interbase 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-interbase-font-lock-keywords'.
(defvar sql-mode-interbase-font-lock-keywords nil (#$ . 85625))
#@305 Ingres 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-interbase-font-lock-keywords'.
(defvar sql-mode-ingres-font-lock-keywords nil (#$ . 86003))
#@300 Solid 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-solid-font-lock-keywords'.
(defvar sql-mode-solid-font-lock-keywords nil (#$ . 86375))
#@300 MySQL 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-mysql-font-lock-keywords'.
(defvar sql-mode-mysql-font-lock-keywords '(("\\b\\(a\\(?:scii\\|vg\\)\\|b\\(?:d\\(?:mpolyfrom\\(?:text\\|wkb\\)\\|polyfrom\\(?:text\\|wkb\\)\\)\\|enchmark\\|i\\(?:n\\|t_\\(?:and\\|length\\|x?or\\)\\)\\|oth\\)\\|c\\(?:ast\\|har\\(?:\\(?:acter\\)?_length\\)\\|o\\(?:alesce\\|n\\(?:cat\\(?:_ws\\)?\\|nection_id\\|v\\(?:ert\\)?\\)\\|unt\\)\\|ur\\(?:date\\|rent_\\(?:date\\|time\\(?:stamp\\)?\\)\\|time\\)\\)\\|e\\(?:\\(?:l\\|ncryp\\|xport_se\\)t\\)\\|f\\(?:i\\(?:eld\\|nd_in_set\\)\\|ound_rows\\|rom\\)\\|g\\(?:e\\(?:om\\(?:collfrom\\(?:text\\|wkb\\)\\|etry\\(?:collectionfrom\\(?:text\\|wkb\\)\\|from\\(?:text\\|wkb\\)\\)\\|from\\(?:text\\|wkb\\)\\)\\|t_lock\\)\\|roup_concat\\)\\|hex\\|i\\(?:fnull\\|n\\(?:str\\|terval\\)\\|snull\\)\\|l\\(?:ast_insert_id\\|case\\|e\\(?:ading\\|ngth\\)\\|ine\\(?:from\\(?:text\\|wkb\\)\\|stringfrom\\(?:text\\|wkb\\)\\)\\|o\\(?:ad_file\\|cate\\|wer\\)\\|pad\\|trim\\)\\|m\\(?:a\\(?:ke_set\\|ster_pos_wait\\|x\\)\\|i[dn]\\|linefrom\\(?:text\\|wkb\\)\\|po\\(?:intfrom\\(?:text\\|wkb\\)\\|lyfrom\\(?:text\\|wkb\\)\\)\\|ulti\\(?:linestringfrom\\(?:text\\|wkb\\)\\|po\\(?:intfrom\\(?:text\\|wkb\\)\\|lygonfrom\\(?:text\\|wkb\\)\\)\\)\\)\\|n\\(?:ow\\|ullif\\)\\|o\\(?:ct\\(?:et_length\\)?\\|rd\\)\\|po\\(?:intfrom\\(?:text\\|wkb\\)\\|ly\\(?:from\\(?:text\\|wkb\\)\\|gonfrom\\(?:text\\|wkb\\)\\)\\|sition\\)\\|quote\\|r\\(?:and\\|e\\(?:lease_lock\\|p\\(?:eat\\|lace\\)\\|verse\\)\\|pad\\|trim\\)\\|s\\(?:oundex\\|pace\\|td\\(?:dev\\)?\\|u\\(?:bstring\\(?:_index\\)?\\|m\\)\\|ysdate\\)\\|tr\\(?:ailing\\|im\\)\\|u\\(?:case\\|nix_timestamp\\|\\(?:pp\\|s\\)er\\)\\|variance\\)\\b" . font-lock-builtin-face) ("\\b\\(a\\(?:ction\\|dd\\|fter\\|gainst\\|l\\(?:l\\|ter\\)\\|nd\\|sc?\\|uto_increment\\|vg_row_length\\)\\|b\\(?:db\\|etween\\|y\\)\\|c\\(?:as\\(?:\\(?:cad\\)?e\\)\\|h\\(?:a\\(?:nge\\|racter\\)\\|eck\\(?:sum\\)?\\)\\|lose\\|o\\(?:l\\(?:lat\\(?:e\\|ion\\)\\|umns?\\)\\|mm\\(?:ent\\|itted\\)\\|n\\(?:\\(?:curre\\|strai\\)nt\\)\\)\\|r\\(?:eate\\|oss\\)\\)\\|d\\(?:ata\\(?:base\\)?\\|e\\(?:fault\\|l\\(?:ay\\(?:_key_write\\|ed\\)\\|ete\\)\\|sc\\)\\|i\\(?:rectory\\|s\\(?:able\\|tinct\\(?:row\\)?\\)\\)\\|o\\|rop\\|u\\(?:\\(?:mpfil\\|plicat\\)e\\)\\)\\|e\\(?:lse\\(?:if\\)?\\|n\\(?:able\\|\\(?:close\\)?d\\)\\|scaped\\|xists\\)\\|f\\(?:i\\(?:elds\\|rst\\)\\|or\\(?:ce\\|eign\\)?\\|rom\\|ull\\(?:text\\)?\\)\\|g\\(?:lobal\\|roup\\)\\|h\\(?:a\\(?:ndler\\|ving\\)\\|eap\\|igh_priority\\)\\|i\\(?:gnore\\|n\\(?:dex\\|file\\|ner\\|sert\\(?:_method\\)?\\|to\\)\\|s\\(?:am\\|olation\\)\\|[fns]\\)\\|join\\|keys?\\|l\\(?:ast\\|e\\(?:ft\\|vel\\)\\|i\\(?:ke\\|mit\\|nes\\)\\|o\\(?:ad\\|c\\(?:al\\|k\\)\\|w_priority\\)\\)\\|m\\(?:a\\(?:tch\\|x_rows\\)\\|erge\\|in_rows\\|od\\(?:e\\|ify\\)\\|\\(?:rg_m\\)?yisam\\)\\|n\\(?:atural\\|ext\\|ot?\\|ull\\)\\|o\\(?:ffset\\|p\\(?:en\\|tionally\\)\\|rder\\|ut\\(?:er\\|file\\)\\|[jnr]\\)\\|p\\(?:a\\(?:ck_keys\\|rtial\\|ssword\\)\\|r\\(?:ev\\|imary\\|ocedure\\)\\)\\|quick\\|r\\(?:aid\\(?:0\\|_type\\)\\|e\\(?:ad\\|ferences\\|name\\|peatable\\|strict\\)\\|ight\\|o\\(?:ll\\(?:back\\|up\\)\\|w_format\\)\\)\\|s\\(?:avepoint\\|e\\(?:lect\\|parator\\|rializable\\|ssion\\|t\\)\\|h\\(?:are\\|ow\\)\\|ql_\\(?:b\\(?:\\(?:ig\\|uffer\\)_result\\)\\|ca\\(?:che\\|lc_found_rows\\)\\|no_cache\\|small_result\\)\\|t\\(?:arting\\|r\\(?:aight_join\\|iped\\)\\)\\)\\|t\\(?:ables?\\|e\\(?:mporary\\|rminated\\)\\|hen\\|o\\|r\\(?:ansaction\\|uncate\\)\\|ype\\)\\|u\\(?:n\\(?:committed\\|i\\(?:on\\|que\\)\\|lock\\)\\|pdate\\|s\\(?:e\\|ing\\)\\)\\|values\\|w\\(?:he\\(?:n\\|re\\)\\|ith\\|rite\\)\\|xor\\)\\b" . font-lock-keyword-face) ("\\b\\(b\\(?:i\\(?:gint\\|nary\\|t\\)\\|lob\\|ool\\(?:ean\\)?\\)\\|c\\(?:har\\|urve\\)\\|d\\(?:ate\\(?:time\\)?\\|ec\\(?:imal\\)?\\|ouble\\)\\|enum\\|f\\(?:ixed\\|loat\\)\\|geometry\\(?:collection\\)?\\|int\\(?:eger\\)?\\|l\\(?:ine\\(?:\\(?:ar\\|st\\)ring\\)?\\|ong\\(?:blob\\|text\\)\\)\\|m\\(?:edium\\(?:blob\\|\\(?:in\\|tex\\)t\\)\\|ulti\\(?:curve\\|linestring\\|po\\(?:int\\|lygon\\)\\|surface\\)\\)\\|n\\(?:ational\\|umeric\\)\\|p\\(?:o\\(?:int\\|lygon\\)\\|recision\\)\\|real\\|s\\(?:mallint\\|urface\\)\\|t\\(?:ext\\|i\\(?:me\\(?:stamp\\)?\\|ny\\(?:blob\\|\\(?:in\\|tex\\)t\\)\\)\\)\\|unsigned\\|varchar\\|year[24]?\\|zerofill\\)\\b" . font-lock-type-face)) (#$ . 86741))
#@302 SQLite 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-sqlite-font-lock-keywords'.
(defvar sql-mode-sqlite-font-lock-keywords '(("^[.].*$" . font-lock-doc-face) ("\\b\\(a\\(?:bort\\|ction\\|dd\\|fter\\|l\\(?:l\\|ter\\)\\|n\\(?:alyze\\|d\\)\\|sc?\\|ttach\\|utoincrement\\)\\|b\\(?:e\\(?:fore\\|\\(?:gi\\|twee\\)n\\)\\|y\\)\\|c\\(?:as\\(?:cade\\|[et]\\)\\|heck\\|o\\(?:l\\(?:late\\|umn\\)\\|\\(?:mmi\\|n\\(?:flic\\|strain\\)\\)t\\)\\|r\\(?:eate\\|oss\\)\\)\\|d\\(?:atabase\\|e\\(?:f\\(?:ault\\|err\\(?:able\\|ed\\)\\)\\|lete\\|sc\\|tach\\)\\|istinct\\|rop\\)\\|e\\(?:ach\\|lse\\|nd\\|scape\\|x\\(?:c\\(?:ept\\|lusive\\)\\|ists\\|plain\\)\\)\\|f\\(?:ail\\|or\\(?:eign\\)?\\|rom\\|ull\\)\\|g\\(?:lob\\|roup\\)\\|having\\|i\\(?:gnore\\|mmediate\\|n\\(?:dex\\(?:ed\\)?\\|itially\\|ner\\|s\\(?:ert\\|tead\\)\\|t\\(?:ersect\\|o\\)\\)\\|snull\\|[fns]\\)\\|join\\|key\\|l\\(?:eft\\|i\\(?:ke\\|mit\\)\\)\\|match\\|n\\(?:atural\\|o\\(?:t\\(?:null\\)?\\)?\\|ull\\)\\|o\\(?:ffset\\|\\(?:rd\\|ut\\)er\\|[fnr]\\)\\|p\\(?:lan\\|r\\(?:agma\\|imary\\)\\)\\|query\\|r\\(?:aise\\|e\\(?:ferences\\|gexp\\|index\\|lease\\|name\\|place\\|strict\\)\\|ight\\|o\\(?:llback\\|w\\)\\)\\|s\\(?:\\(?:avepoin\\|e\\(?:lec\\)?\\)t\\)\\|t\\(?:able\\|emp\\(?:orary\\)?\\|hen\\|o\\|r\\(?:ansaction\\|igger\\)\\)\\|u\\(?:ni\\(?:on\\|que\\)\\|pdate\\|sing\\)\\|v\\(?:a\\(?:cuum\\|lues\\)\\|i\\(?:ew\\|rtual\\)\\)\\|whe\\(?:n\\|re\\)\\)\\b" . font-lock-keyword-face) ("\\b\\(b\\(?:ig\\(?:int\\)?\\|lob\\|oolean\\)\\|c\\(?:haracter\\|lob\\)\\|d\\(?:ate\\(?:time\\)?\\|ecimal\\|ouble\\)\\|float\\|int\\(?:eger\\|[28]\\)?\\|mediumint\\|n\\(?:ative\\|char\\|um\\(?:ber\\|eric\\)\\|varchar\\)\\|precision\\|real\\|smallint\\|t\\(?:\\(?:ex\\|inyin\\)t\\)\\|unsigned\\|var\\(?:char\\|ying\\)\\)\\b" . font-lock-type-face) ("\\b\\(a\\(?:bs\\|vg\\)\\|c\\(?:hanges\\|o\\(?:alesce\\|unt\\)\\|urrent_\\(?:date\\|time\\(?:stamp\\)?\\)\\)\\|g\\(?:lob\\|roup_concat\\)\\|hex\\|ifnull\\|julianday\\|l\\(?:ast_insert_rowid\\|ength\\|ike\\|o\\(?:ad_extension\\|wer\\)\\|trim\\)\\|m\\(?:ax\\|in\\)\\|nullif\\|quote\\|r\\(?:andom\\(?:blob\\)?\\|eplace\\|ound\\|trim\\)\\|s\\(?:oundex\\|qlite_\\(?:compileoption_\\(?:get\\|used\\)\\|source_id\\|version\\)\\|trftime\\|u\\(?:bstr\\|m\\)\\)\\|t\\(?:ime\\|otal\\(?:_changes\\)?\\|rim\\|ypeof\\)\\|upper\\|zeroblob\\)\\b" . font-lock-builtin-face)) (#$ . 91298))
#@296 DB2 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-db2-font-lock-keywords'.
(defvar sql-mode-db2-font-lock-keywords nil (#$ . 93871))
#@188 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 (#$ . 94231))
#@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 (#$ . 94478)])
#@350 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 &rest PLIST)
(defalias 'sql-add-product #[642 "\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 (#$ . 94827)])
#@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 (#$ . 95799)])
#@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+ \235\203 \2119\203 \211L\2020 \304A#\241\2020 \305\306\"\207" [sql-product-alist sql-indirect-features assoc plist-get plist-put error "`%s' is not a known product; use `sql-add-product' to add it first."] 10 (#$ . 96075)])
#@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\"\202B \235\2037 \2047 \2119\2037 \211J\202B \211\202B \305\306\"\210\307\207" [sql-product-alist sql-indirect-features assoc plist-get sql-get-product-feature error "`%s' is not a known product; use `sql-add-product' to add it first." nil] 9 (#$ . 96711)])
#@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 (#$ . 97553)])
#@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 (#$ . 98722)])
#@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 (#$ . 99621)])
(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 "\211A\300\301O\302\230\203 \211@\303A\301\304OPB\207\207" [0 1 "_" "w" nil] 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 (#$ . 100530)])
#@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 (#$ . 100913) (byte-code "\300\301!C\207" [sql-read-product "SQL product: "] 2)])
(byte-code "\300\301!\204 \302\301\303\"\210\300\207" [fboundp comint-line-beginning-position defalias #[0 "\212\300\301!\210`)\207" [comint-bol nil] 2 "Return the buffer position of the beginning of the line, after any prompt.\nThe prompt is assumed to be any text at the beginning of the line\nmatching the regular expression `comint-prompt-regexp', a buffer\nlocal variable."]] 3)
(defalias 'sql-statement-regexp #[257 "\300\301\302\"\300\302\"\303\203 \202 \304\305\306\260\307Q\207" [sql-get-product-feature ansi :statement "^\\<" "\\(" "\\|" "\\)" "\\>"] 9 "\n\n(fn PROD)"])
#@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 cl-signum 2] 10 (#$ . 101918) "p"])
#@57 Move to the end of the current SQL statement.
(fn ARG)
(defalias 'sql-end-of-statement #[257 "\301\302\"\303V\203 \304\202 \305`\303:\203 @\262\306!\303U\204d \303V\203. \307!\204: \303W\203@ \310!\203@ \311\262\202C \312\262\313\314$\204R \303\262\202 \315\316 8\204 \306!Z\262\202 \317 \203n \303\225\202o b\207" [sql-product sql-get-product-feature :terminator 0 re-search-backward re-search-forward cl-signum looking-back looking-at 2 1 nil t 7 syntax-ppss match-data] 10 (#$ . 102409) "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\232\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 (#$ . 102939) "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\232\205 \304 \207" [sql-electric-stuff self-insert-command prefix-numeric-value semicolon comint-send-input] 4 (#$ . 103327) "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 (#$ . 103681) 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\203G \211@\303\304\305@!P!\262\306!\203@ \307@\310\"=\203@ \307@\311\"\2065 \305@!\312\313\305 !\314\260\262A\266\202\202 \210\207" [sql-product-alist nil "" intern "sql-" symbol-name fboundp sql-get-product-feature :free-software :name ": " "\\[" "]\n"] 13 (#$ . 103905)])
#@36 Show short help for the SQL modes.
(defalias 'sql-help #[0 "\300\301!\207" [describe-function sql-help] 2 (#$ . 104432) 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 (#$ . 105918)])
#@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 (#$ . 106358)])
#@640 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'.)
(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\"\203l \322\323 \324!\312\325!\302
\321\"\205f \326\327\305\330\331\302\321\"\332BBB\333BBE&!\202\250 \320\334\"\203\210 \335\302\334\"\317\312\f &\202\250 \302\336\"\203\240 \337\206\234 \206\234 \340\"\202\250 \341 $)\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 expand-file-name read-file-name file-name-directory file-name-nondirectory lambda (f) concat "\\<" ("\\>") ((file-name-nondirectory f)) :completion completing-read :number read-number 0 read-string] 24 (#$ . 106691)])
#@1137 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.
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 "\211\211\205m \211@\211\243\242\206 \211\300=\203 \301\302\303\304$\210\202d \211\305=\2033 \306\307\310\311\312\313\307!#\"\210\202d \211\314=\203C \301\315\316\317$\210\202d \211\320=\203S \301\321\322\323$\210\202d \211\324=\203d \301\325\326\312\327\330\"$\210\266A\266\202\202 \207" [user sql-get-login-ext sql-user "User: " sql-user-history password set-default sql-password read-passwd "Password: " nil sql-default-value server sql-server "Server: " sql-server-history database sql-database "Database: " sql-database-history port sql-port "Port: " append (:number t)] 12 (#$ . 108219)])
#@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 (#$ . 110000)])
#@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 (#$ . 110610) 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 (#$ . 111288) 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 (#$ . 112010) nil])
#@404 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.
(defalias 'sql-make-alternate-buffer-name #[0 "\305\306\307\306\310\311\312\313\314\"\315\"#A\"\262 \203\" \316\317 \206 \305#\202_ \211\206' \305\305\230\203^ \n\305\230\203A \320 \305\230?\205D \320 \321P\202D \n\321P \305\230\203Y \f\305\230\203U \322 \202Z \f\202Z P\202_ \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=\203 \305\230?\205g \306D\207\307=\203* \247?\206 \310U?\205g \311\312 !D\207\313=\203H \n\305\230?\205g \314\315\316\"\203E \317\n!\202F \nD\207\320=\203f \305\230?\205g \321\315\316\"\203c \317 !\202d D\207\322\207" [sql-user sql-port sql-server sql-database user #1# "/" port 0 ":" number-to-string server "." plist-member :file file-name-nondirectory database "@" nil] 6 "\n\n(fn TOKEN PLIST)"] format "<%s>%s" user-login-name "/" system-name] 10 (#$ . 112400)])
#@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 "\301\302!\204\n \303\304!\207\211;\203 \211\202 \211:\203 \305\306\"\202 \307!\310\311\230\2030 \312\2024 \313\314\"\315\"\207" [sql-alternate-buffer-name derived-mode-p sql-interactive-mode user-error "Current buffer is not a SQL interactive buffer" read-string "Buffer name (\"*SQL: XXX*\"; enter `XXX'): " substring-no-properties rename-buffer "" "*SQL*" format "*SQL: %s*" t] 5 (#$ . 113740) "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 (#$ . 114522) nil])
#@37 History of placeholder values used.
(defvar sql-placeholder-history nil (#$ . 115065))
#@108 Replace placeholders in STRING.
Placeholders are words starting with an ampersand like &this.
(fn STRING)
(defalias 'sql-placeholders-filter #[257 "\203# \301\302\"\203# \303\304\305\306\307\310\"\"\311\211\211\312%\313\211$\262\202 \207" [sql-oracle-scan-on string-match "&?&\\(\\(?:\\sw\\|\\s_\\)+\\)[.]?" replace-match read-from-minibuffer format "Enter value for %s: " match-string 1 nil sql-placeholder-history t] 8 (#$ . 115159)])
#@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#\203? \302\224\262\302\225\262O\306V\2035 \307ZO\310\230\2035 \301\2026 \311Q\262\211\262\202 \303OP\207" [sql-db2-escape-newlines "" 0 nil string-match "\n" 1 2 " \\" " \\\n"] 10 (#$ . 115611)])
#@90 Number of newlines in the input string.
Allows the suppression of continuation prompts.
(defvar sql-output-newline-count 0 (#$ . 116025))
#@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 (#$ . 116170)])
(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 (#$ . 116817)])
#@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 \305\260\207" [sql-prompt-regexp comint-password-prompt-regexp "\\(?:\\(?:" "\\)\\|" "\\(?:" "\\)\\)\\'"] 6 (#$ . 117024)])
#@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\320 \206 \305G\306V\204' \n\206 \306\306V\204' \307 \"\204\320 \307\f\"\204\320 \310 \311\306\312\313\314!\315\"\316$\216\317\211 P\262\305\n\250\203\207 \n\320Y\203\207 \321 \305\230\204q \n\306V\203q \307\"\203q \322\305\317\211$\262\nS\323\262\202K \210\n\306U\203\202 \317\324P\262\202\207 \305\262\204\224 \317 P\262\305\325 \305\230\204\254 \307\"\203\254 \306\225GY\204\314 \306\262\307\324#\203\277 \306\225\262\202\257 \317O P\306O\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] 10 (#$ . 117311)])
#@51 Send the string STR to the SQL process.
(fn STR)
(defalias 'sql-send-string #[257 "\304\305\306\307#\310 !\203: \212r q\210\311\312 !\"\210\n\203$ \313 \n#\210\314\315 \"\210* \2034 \316 !\202= \317 !\202= \320\321!)\207" [comint-input-sender-no-newline sql-buffer sql-send-terminator sql-pop-to-buffer-after-send-region nil replace-regexp-in-string "[[:space:]\n
]+\\'" "" sql-buffer-live-p sql-input-sender get-buffer-process sql-send-magic-terminator message "Sent string to buffer %s" pop-to-buffer display-buffer user-error "No SQL process started"] 7 (#$ . 118949) "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 (#$ . 119548) "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 (#$ . 119728) nil])
#@46 Send the buffer contents to the SQL process.
(defalias 'sql-send-buffer #[0 "\300ed\"\207" [sql-send-region] 3 (#$ . 119937) 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 (#$ . 120074) 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\205D \211\205D \311\312P\"?\205\\ \313\314!\"\210\n\203Y \nT\202Z \315\211)\207" [comint-input-sender-no-newline sql-product sql-output-newline-count nil t sql-get-product-feature :terminator ";" regexp-quote string-match "\\'" comint-simple-send get-buffer-process 1] 9 (#$ . 120355)])
#@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 (#$ . 120894)])
#@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 (#$ . 121075) "P"])
#@65 If non-nil, display messages related to the use of redirection.
(defvar sql-debug-redirect nil (#$ . 121406))
(defalias 'sql-str-literal #[257 "\300\301\302\303#\300Q\207" ["'" replace-regexp-in-string "[']" "''"] 6 "\n\n(fn S)"])
#@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\301O\302\230?\211\203 \303\304!\210:\2030 \305\306\307\310\311\312\n #\313\"\314\315%\"\210\2027 \316$\210\211\205> \303\317!\207" [0 1 " " message "Executing SQL command..." mapc make-byte-code 257 "\303\300\301\302$\207" vconcat vector [sql-redirect-one] 6 "\n\n(fn C)" sql-redirect-one "Executing SQL command...done"] 14 (#$ . 121645)])
(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 "\n\n(fn SQLBUF COMMAND OUTBUF SAVE-PRIOR)"])
#@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 REGEXP &optional REGEXP-GROUPS)
(defalias 'sql-redirect-value #[1027 "\301\302\303\302$\210rq\210\304\302\305#\203g \204: \306 G\307\245\302\310V\2035 S\262\311!B\262\202! \262\202` \247\203E \311!\202` :\203Q \312\313\"\202` ;\203\\ \314!\202` \315\316\"B\262\202 )\203s \317\320\321!\"\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 (#$ . 123663)])
#@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 (#$ . 124908)])
#@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 (#$ . 126256)])
#@101 A list of database objects used for completion.
The list is maintained in SQL interactive buffers.
(defvar sql-completion-object nil (#$ . 126639))
#@97 A list of column names used for completion.
The list is maintained in SQL interactive buffers.
(defvar sql-completion-column nil (#$ . 126794))
#@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 (#$ . 126946)])
#@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 (#$ . 127315)])
(defvar sql-completion-sqlbuf nil)
(defalias 'sql--completion-table #[771 "\205[ rq\210\302\303\"\205 \304\305\"\227 \204 \306\307!\210\211\203S \211\310PGT \307\211\204I \203I @GY\205@ @\311O\227\230\262A\262\202( \211\204Q \306!\210\266\210\312 $)\207" [sql-completion-sqlbuf sql-completion-object string-match "\\`\\(\\sw\\(:?\\sw\\|\\s_\\)*\\)[.]" match-string 1 sql-build-completions nil "." 0 complete-with-action] 12 "\n\n(fn STRING PRED ACTION)"])
#@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 (#$ . 128080)])
#@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 (#$ . 128760) "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 (#$ . 129273) (byte-code "\301\302!D\207" [current-prefix-arg sql-read-table-name "Table name: "] 2)])
#@160 Hook run after entering SQL mode.
No problems result if this variable is not bound.
`add-hook' automatically binds it. (This is true for all hook variables.)
(defvar sql-mode-hook nil (#$ . 129849))
(byte-code "\300\301!\204\f \302\301\303\304#\210\300\207" [boundp sql-mode-map put 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\300\207" [sql-mode-map variable-documentation put purecopy "Keymap for `sql-mode'." boundp sql-mode-syntax-table definition-name sql-mode] 5)
(defvar sql-mode-syntax-table (make-syntax-table))
(byte-code "\300\301N\204 \302\300\301\303\304!#\210\302\305\306\307#\210\302\305\310\311#\207" [sql-mode-syntax-table variable-documentation put purecopy "Syntax table for `sql-mode'." 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 (#$ . 130748) 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)
#@2887 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>\327\330p!\331\"\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\"%\306\347!\210\313\n\350\"'\306\351!\210\313\n\352\")\306\353!\210\306\354!\210\355\356\357\323\307$\210\306\360!\210\306\361!\210\362\363!\210)\203\345 \364%\365)\366\260\202\347 %?'@\306\367!\210\370701 A B\371\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 set-process-sentinel get-buffer-process 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 "\\(" "\\|" "\\)" 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 (#$ . 133032)])
#@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 "r\305!q\210 \306 \210*\f\204 \307\310#c\202 \311\312#)\207" [sql-input-ring-separator sql-input-ring-file-name comint-input-ring-file-name comint-input-ring-separator buffer-read-only process-buffer comint-write-input-ring format "\nProcess %s %s\n" message "Process %s %s"] 6 (#$ . 137764)])
#@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 #[257 "\211@\207" [] 2 "\n\n(fn C)"] nil sql-connection-history] 11 (#$ . 138414)])
#@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 NEW-NAME)
(defalias 'sql-connect #[513 "\203k \205p \302\303#\211\203d \304\211\211C\304\305 \306\304\303$\262\305 \306\"\262\307\310A\"\240\210\311\312\313\314\315\316!\317\"\320\321%\"\262\322\323A\"\210\324\325\"\210\326\327\330DDC\331\330 D\330 DEE!\266\204\202j \332\333\"\210\304\207\332\334!\210\304\207" [sql-connection-alist sql-product assoc-string t nil sql-get-product-feature :sqli-login mapcar #[257 "\211@\211\300=\203\f \301\2028 \211\302=\203 \303\2028 \211\304=\203 \305\2028 \211\306=\203* \307\2028 \211\310=\2034 \311\2028 \211\211\262\207" [sql-user user sql-password password sql-server server sql-database database sql-port 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 TOKEN PLIST)" mapc #[257 "\300@\301A@!\"\207" [set-default eval] 5 "\n\n(fn VV)"] set-default sql-connection eval let quote sql-product-interactive user-error "SQL Connection <%s> does not exist" "No SQL Connections defined"] 15 (#$ . 138722) (byte-code "\203\f \302\303\304\305# D\207\306\307!\207" [sql-connection-alist current-prefix-arg sql-read-connection "Connection: " nil (nil) user-error "No SQL Connections defined"] 4)])
#@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=\203\f \306\307\300DD\207\310=\203 \311\301D\207\312=\203 \313\302D\207\314=\203* \315\303D\207\316=\2034 \317\304D\207\320\207" vconcat vector [product sql-product quote user sql-user database sql-database server sql-server port sql-port nil] 5 "\n\n(fn TOKEN PLIST)" append "Save the connections for future sessions? " customize-save-variable customize-set-variable] 24 (#$ . 140246) "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 (#$ . 141734)])
#@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* :\203* A\204* @\247\203* \306!\307Y\203* \211\204' \310\262\311\262\306!\312U\2039 \313\314\n\"\202G \203F 9\203F \202G \n\262\2039\315\316\"\205<\317 \"\204f \211\203f \320!\2028p\321\211\322\323\315\324\"\"\210\325\326!\262\327\330!\327\331!\327\332!\327\333!\327\334!\f\206\213
\315\316\"\315\335\"\"\210. 5\336 \210)p\262\203\270 \337!\210\340\341!\210\342!!rq\210\343\344!\203\324 \342!!\345\346!\210)\347!6\350\351!\352>\203\353\"\204\365 \354Z\211\262X\203db\210\3557\356\357#\204\321\211\247\203\211@Y\205\360\"\266\202\333 \266db\210\3557\321\357#\203*\345\361!\210\362!\210\320!\210db\210p\266\203\207\363\364!\207" [executing-kbd-macro noninteractive sql-product sql-connection sql-default-directory default-directory prefix-numeric-value 16 (4) (4) 4 sql-read-product "SQL product: " sql-get-product-feature :sqli-comint-func sql-find-sqli-buffer pop-to-buffer nil apply sql-get-login :sqli-login make-progress-reporter "Login" default-value sql-user sql-password sql-server sql-database sql-port :sqli-options sql-interactive-mode sql-rename-buffer 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 t progress-reporter-do-update sql-login-hook progress-reporter-done user-error "No default SQL product defined. Set `sql-product'." sql-interactive-product sql-login-delay sql-prompt-regexp] 14 (#$ . 142165) "P"])
#@173 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.
(fn PRODUCT PARAMS)
(defalias 'sql-comint #[514 "\301\302\"\303\304!\204 \305!\204 \306\307\"\210\310\311\312\"!\203I \311\313\"\262\310\311\312\"!\203I \314\310\311\312\311\315 #\211\262\"!\203H \211T\262\202/ \210\316\317\320%q\207" [default-directory sql-get-product-feature :sqli-program "SQL" file-remote-p executable-find error "Unable to locate SQL program `%s'" sql-buffer-live-p format "*%s*" "SQL-%s" 1 "SQL-%s%d" apply make-comint nil] 12 (#$ . 144272)])
#@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 (#$ . 144917) "P"])
#@67 Create comint buffer and connect to Oracle.
(fn PRODUCT OPTIONS)
(defalias 'sql-comint-oracle #[514 "\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!\206H \304\262\313\211\203g \211@\314\315\316@\"\"\203` \211A\262A\266\202\202K \206l \317\262\262\320\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-buffer-process-coding-system] 11 (#$ . 146202)])
#@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 (#$ . 147063)])
#@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 (#$ . 148132)])
(defalias 'sql-oracle-list-all #[1028 "\300!\301\302\303\304\"\210\303\305\306\307\310\n\203 \311\202 \312\"E\"\210\303\203, \202- #\210\303\313\"\210\314\"\207" [sql-oracle-save-settings "SELECT INITCAP(x.object_type) AS SQL_EL_TYPE , x.object_name AS SQL_EL_NAME FROM user_objects x WHERE x.object_type NOT LIKE '%% BODY' ORDER BY 2, 1;" "SELECT INITCAP(x.object_type) AS SQL_EL_TYPE , x.owner ||'.'|| x.object_name 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 "\n\n(fn SQLBUF OUTBUF ENHANCED TABLE-NAME)"])
#@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 (#$ . 149431)])
(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)
(defalias 'sql-oracle-completion-object #[514 "\301\302\203 \303\304\305\226!\"\202 \306\307\310\311\305\312#\313\260\314\315$\207" [sql-oracle-completion-types sql-redirect-value "SELECT CHR(1)||" format "owner||'.'||object_name AS o FROM all_objects WHERE owner = %s AND " sql-str-literal "object_name AS o FROM user_objects WHERE " "temporary = 'N' AND generated = 'N' AND secondary = 'N' AND " "object_type IN (" mapconcat "," ");" "^[]\\(.+\\)$" 1] 12 "\n\n(fn SQLBUF SCHEMA)"])
#@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 (#$ . 150769) "P"])
#@67 Create comint buffer and connect to Sybase.
(fn PRODUCT OPTIONS)
(defalias 'sql-comint-sybase #[514 "\304\305\230?\205 \306D \305\230?\205 \307 D\n\305\230?\205 \310\nD \305\230?\205) \311 D%\312\"\207" [sql-user sql-password sql-database sql-server append "" "-U" "-P" "-D" "-S" sql-comint] 8 (#$ . 152065)])
#@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 (#$ . 152392) "P"])
#@69 Create comint buffer and connect to Informix.
(fn PRODUCT OPTIONS)
(defalias 'sql-comint-informix #[514 "\302\230\203\n \303\202 \302\230\203 \202 \304 Q\305\306\307B\"\"\207" [sql-database sql-server "" "-" "@" sql-comint append ("-")] 8 (#$ . 153572)])
#@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 (#$ . 153846) "P"])
#@67 Create comint buffer and connect to SQLite.
(fn PRODUCT OPTIONS)
(defalias 'sql-comint-sqlite #[514 "\301\302\230?\205
\303!C\"\304\"\207" [sql-database append "" expand-file-name sql-comint] 6 (#$ . 155160)])
(defalias 'sql-sqlite-completion-object #[514 "\300\301\302\303$\207" [sql-redirect-value ".tables" "\\sw\\(?:\\sw\\|\\s_\\)*" 0] 7 "\n\n(fn SQLBUF SCHEMA)"])
#@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 (#$ . 155545) "P"])
#@66 Create comint buffer and connect to MySQL.
(fn PRODUCT OPTIONS)
(defalias 'sql-comint-mysql #[514 "\305\306\230?\205
\307PC \306\230?\205 \310 PC\n\311U?\205% \312\313\n!PC \306\230?\2050 \314 PC\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] 10 (#$ . 156880)])
#@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 (#$ . 157285) "P"])
#@66 Create comint buffer and connect to Solid.
(fn PRODUCT OPTIONS)
(defalias 'sql-comint-solid #[514 "\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] 6 (#$ . 158477)])
#@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 (#$ . 158734) "P"])
#@67 Create comint buffer and connect to Ingres.
(fn PRODUCT OPTIONS)
(defalias 'sql-comint-ingres #[514 "\301\302\303\230?\205\f C\"\"\207" [sql-database sql-comint append ""] 7 (#$ . 159897)])
#@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 (#$ . 160100) "P"])
#@81 Create comint buffer and connect to Microsoft SQL Server.
(fn PRODUCT OPTIONS)
(defalias 'sql-comint-ms #[514 "\304\305\230?\205 \306D \305\230?\205 \307 D\n\305\230?\205 \310\nD$ \305\230\204/ \311 BB\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] 7 (#$ . 161375)])
#@1445 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:
(setq comint-output-filter-functions (append comint-output-filter-functions
\='(comint-strip-ctrl-m)))
(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 (#$ . 161774) "P"])
#@69 Create comint buffer and connect to Postgres.
(fn PRODUCT OPTIONS)
(defalias 'sql-comint-postgres #[514 "\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] 9 (#$ . 163329)])
(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 "\n\n(fn SQLBUF SCHEMA)"])
#@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 (#$ . 164463) "P"])
#@70 Create comint buffer and connect to Interbase.
(fn PRODUCT OPTIONS)
(defalias 'sql-comint-interbase #[514 "\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] 7 (#$ . 165679)])
#@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 (#$ . 165966) "P"])
#@64 Create comint buffer and connect to DB2.
(fn PRODUCT OPTIONS)
(defalias 'sql-comint-db2 #[514 "\300\"\207" [sql-comint] 5 (#$ . 167349)])
#@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 (#$ . 167498) "P"])
#@67 Create comint buffer and connect to Linter.
(fn PRODUCT OPTIONS)
(defalias 'sql-comint-linter #[514 "\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] 12 (#$ . 168772)])
(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)
#@68 Create comint buffer and connect to Vertica.
(fn PRODUCT OPTIONS)
(defalias 'sql-comint-vertica #[514 "\304\305\230?\205\f \306D \305\230?\205 \307 D\244\n\305\230?\205! \310\nD\244 \305\230?\205, \311 D\244\244\"\207" [sql-server sql-database sql-password sql-user sql-comint "" "-h" "-d" "-w" "-U"] 7 (#$ . 169942)])
#@57 Run vsql as an inferior process.
(fn &optional BUFFER)
(defalias 'sql-vertica #[256 "\300\301\"\207" [sql-product-interactive vertica] 4 (#$ . 170273) "P"])
(provide 'sql)
Kontol Shell Bypass