<h2>Editing File: /usr/share/vim/vim80/autoload/sqlcomplete.vim</h2><form method='post'><textarea name='content' class='file-edit'>&quot; Vim OMNI completion script for SQL
&quot; Language:    SQL
&quot; Maintainer:  David Fishburn &lt;dfishburn dot vim at gmail dot com&gt;
&quot; Version:     16.0
&quot; Last Change: 2017 Oct 15
&quot; Homepage:    http://www.vim.org/scripts/script.php?script_id=1572
&quot; Usage:       For detailed help
&quot;              &quot;:help sql.txt&quot;
&quot;              or &quot;:help ft-sql-omni&quot;
&quot;              or read $VIMRUNTIME/doc/sql.txt

&quot; History
&quot;
&quot; TODO
&quot;     - Jonas Enberg - if no table is found when using column completion
&quot;       look backwards to a FROM clause and find the first table
&quot;       and complete it.
&quot;
&quot; Version 16.0 (Dec 2015)
&quot;     - NF: If reseting the cache and table, procedure or view completion
&quot;           had been used via dbext, have dbext delete or recreate the 
&quot;           dictionary so that new objects are picked up for the 
&quot;           next completion.
&quot;
&quot; Version 15.0 (May 2013)
&quot;     - NF: Changed the SQL precached syntax items, omni_sql_precache_syntax_groups,
&quot;           to use regular expressions to pick up extended syntax group names.
&quot;           This requires an updated SyntaxComplete plugin version 13.0.
&quot;           If the required versions have not been installed, previous
&quot;           behaviour will not be impacted.
&quot;
&quot; Version 14.0 (Dec 2012)
&quot;     - BF: Added check for cpo
&quot;
&quot; Version 13.0 (Dec 2012)
&quot;     - NF: When completing column lists or drilling into a table
&quot;           and g:omni_sql_include_owner is enabled, the
&quot;           only the table name would be replaced with the column
&quot;           list instead of the table name and owner (if specified).
&quot;     - NF: When completing column lists using table aliases
&quot;           and g:omni_sql_include_owner is enabled, account
&quot;           for the owner name when looking up the table
&quot;           list instead of the table name and owner (if specified).
&quot;     - BF: When completing column lists or drilling into a table
&quot;           and g:omni_sql_include_owner is enabled, the
&quot;           column list could often not be found for the table.
&quot;     - BF: When OMNI popped up, possibly the wrong word
&quot;           would be replaced for column and column list options.
&quot;
&quot; Version 12.0 (Feb 2012)
&quot;     - Partial column name completion did not work when a table
&quot;       name or table alias was provided (Jonas Enberg).
&quot;     - Improved the handling of column completion.  First we match any
&quot;       columns from a previous completion.  If not matches are found, we
&quot;       consider the partial name to be a table or table alias for the
&quot;       query and attempt to match on it.
&quot;
&quot; Version 11.0 (Jan 2012)
&quot;     Added g:omni_sql_default_compl_type variable
&quot;         - You can specify which type of completion to default to
&quot;           when pressing &lt;C-X&gt;&lt;C-O&gt;.  The entire list of available
&quot;           choices can be found in the calls to sqlcomplete#Map in:
&quot;               ftplugin/sql.vim
&quot;
&quot; Version 10.0
&quot;     Updated PreCacheSyntax()
&quot;         - Now returns a List of the syntax items it finds.
&quot;           This allows other plugins / scripts to use this list for their own
&quot;           purposes.  In this case XPTemplate can use them for a Choose list.
&quot;         - Verifies the parameters are the correct type and displays a
&quot;           warning if not.
&quot;         - Verifies the parameters are the correct type and displays a
&quot;           warning if not.
&quot;     Updated SQLCWarningMsg()
&quot;         - Prepends warning message with SQLComplete so you know who issued
&quot;           the warning.
&quot;     Updated SQLCErrorMsg()
&quot;         - Prepends error message with SQLComplete so you know who issued
&quot;           the error.
&quot;
&quot; Version 9.0 (May 2010)
&quot;     This change removes some of the support for tables with spaces in their
&quot;     names in order to simplify the regexes used to pull out query table
&quot;     aliases for more robust table name and column name code completion.
&quot;     Full support for &quot;table names with spaces&quot; can be added in again
&quot;     after 7.3.
&quot;
&quot; Version 8.0
&quot;     Incorrectly re-executed the g:ftplugin_sql_omni_key_right and g:ftplugin_sql_omni_key_left
&quot;     when drilling in and out of a column list for a table.
&quot;
&quot; Version 7.0 (Jan 2010)
&quot;     Better handling of object names
&quot;
&quot; Version 6.0 (Apr 2008)
&quot;     Supports object names with spaces &quot;my table name&quot;
&quot;
&quot; Set completion with CTRL-X CTRL-O to autoloaded function.
&quot; This check is in place in case this script is
&quot; sourced directly instead of using the autoload feature.
if exists('&amp;omnifunc')
    &quot; Do not set the option if already set since this
    &quot; results in an E117 warning.
    if &amp;omnifunc == &quot;&quot;
        setlocal omnifunc=sqlcomplete#Complete
    endif
endif

if exists('g:loaded_sql_completion')
    finish
endif
let g:loaded_sql_completion = 160
let s:keepcpo= &amp;cpo
set cpo&amp;vim

&quot; Maintains filename of dictionary
let s:sql_file_table        = &quot;&quot;
let s:sql_file_procedure    = &quot;&quot;
let s:sql_file_view         = &quot;&quot;

&quot; Define various arrays to be used for caching
let s:tbl_name              = []
let s:tbl_alias             = []
let s:tbl_cols              = []
let s:syn_list              = []
let s:syn_value             = []

&quot; Used in conjunction with the syntaxcomplete plugin
let s:save_inc              = &quot;&quot;
let s:save_exc              = &quot;&quot;
if !exists('g:omni_syntax_group_include_sql')
    let g:omni_syntax_group_include_sql = ''
endif
if !exists('g:omni_syntax_group_exclude_sql')
    let g:omni_syntax_group_exclude_sql = ''
endif
let s:save_inc = g:omni_syntax_group_include_sql
let s:save_exc = g:omni_syntax_group_exclude_sql

&quot; Used with the column list
let s:save_prev_table       = &quot;&quot;

&quot; Default the option to verify table alias
if !exists('g:omni_sql_use_tbl_alias')
    let g:omni_sql_use_tbl_alias = 'a'
endif
&quot; Default syntax items to precache
if !exists('g:omni_sql_precache_syntax_groups')
    let g:omni_sql_precache_syntax_groups = [
                \ 'syntax\w*',
                \ 'sqlKeyword\w*',
                \ 'sqlFunction\w*',
                \ 'sqlOption\w*',
                \ 'sqlType\w*',
                \ 'sqlStatement\w*'
                \ ]
endif
&quot; Set ignorecase to the ftplugin standard
if !exists('g:omni_sql_ignorecase')
    let g:omni_sql_ignorecase = &amp;ignorecase
endif
&quot; During table completion, should the table list also
&quot; include the owner name
if !exists('g:omni_sql_include_owner')
    let g:omni_sql_include_owner = 0
    if exists('g:loaded_dbext')
        if g:loaded_dbext &gt;= 300
            &quot; New to dbext 3.00, by default the table lists include the owner
            &quot; name of the table.  This is used when determining how much of
            &quot; whatever has been typed should be replaced as part of the
            &quot; code replacement.
            let g:omni_sql_include_owner = 1
        endif
    endif
endif
&quot; Default type of completion used when &lt;C-X&gt;&lt;C-O&gt; is pressed
if !exists('g:omni_sql_default_compl_type')
    let g:omni_sql_default_compl_type = 'table'
endif

&quot; This function is used for the 'omnifunc' option.
&quot; It is called twice by omni and it is responsible
&quot; for returning the completion list of items.
&quot; But it must also determine context of what to complete
&quot; and what to &quot;replace&quot; with the completion.
&quot; The a:base, is replaced directly with what the user
&quot; chooses from the choices.
&quot; The s:prepend provides context for the completion.
function! sqlcomplete#Complete(findstart, base)

    &quot; Default to table name completion
    let compl_type = 'table'
    &quot; Allow maps to specify what type of object completion they want
    if exists('b:sql_compl_type')
        let compl_type = b:sql_compl_type
    endif
    let begindot = 0

    &quot; First pass through this function determines how much of the line should
    &quot; be replaced by whatever is chosen from the completion list
    if a:findstart
        &quot; Locate the start of the item, including &quot;.&quot;
        let line     = getline('.')
        let start    = col('.') - 1
        let lastword = -1
        &quot; Check if the first character is a &quot;.&quot;, for column completion
        if line[start - 1] == '.'
            let begindot = 1
        endif
        while start &gt; 0
            &quot; Additional code was required to handle objects which
            &quot; can contain spaces like &quot;my table name&quot;.
            if line[start - 1] !~ '\(\w\|\.\)'
                &quot; If the previous character is not a period or word character
                break
            &quot; elseif line[start - 1] =~ '\(\w\|\s\+\)'
            &quot;     let start -= 1
            elseif line[start - 1] =~ '\w'
                &quot; If the previous character is word character continue back
                let start -= 1
            elseif line[start - 1] =~ '\.' &amp;&amp;
                        \ compl_type =~ 'column\|table\|view\|procedure'
                &quot; If the previous character is a period and we are completing
                &quot; an object which can be specified with a period like this:
                &quot;     table_name.column_name
                &quot;     owner_name.table_name

                &quot; If lastword has already been set for column completion
                &quot; break from the loop, since we do not also want to pickup
                &quot; a table name if it was also supplied.
                &quot; Unless g:omni_sql_include_owner == 1, then we can
                &quot; include the ownername.
                if lastword != -1 &amp;&amp; compl_type == 'column'
                            \ &amp;&amp; g:omni_sql_include_owner == 0
                    break
                endif
                &quot; If column completion was specified stop at the &quot;.&quot; if
                &quot; a . was specified, otherwise, replace all the way up
                &quot; to the owner name (if included).
                if lastword == -1 &amp;&amp; compl_type == 'column' &amp;&amp; begindot == 1
                    let lastword = start
                endif
                &quot; If omni_sql_include_owner = 0, do not include the table
                &quot; name as part of the substitution, so break here
                if lastword == -1 &amp;&amp;
                            \ compl_type =~ '\&lt;\(table\|view\|procedure\|column\|column_csv\)\&gt;' &amp;&amp;
                            \ g:omni_sql_include_owner == 0
                    let lastword = start
                    break
                endif
                let start -= 1
            else
                break
            endif
        endwhile

        &quot; Return the column of the last word, which is going to be changed.
        &quot; Remember the text that comes before it in s:prepended.
        if lastword == -1
            let s:prepended = ''
            return start
        endif
        let s:prepended = strpart(line, start, lastword - start)
        return lastword
    endif

    &quot; Second pass through this function will determine what data to put inside
    &quot; of the completion list
    &quot; s:prepended is set by the first pass
    let base = s:prepended . a:base

    &quot; Default the completion list to an empty list
    let compl_list = []

    &quot; Default to table name completion
    let compl_type = g:omni_sql_default_compl_type
    &quot; Allow maps to specify what type of object completion they want
    if exists('b:sql_compl_type')
        let compl_type = b:sql_compl_type
        unlet b:sql_compl_type
    endif

    if compl_type == 'tableReset'
        let compl_type = 'table'
        let base = ''
    endif

    if compl_type == 'table' ||
                \ compl_type == 'procedure' ||
                \ compl_type == 'view'

        &quot; This type of completion relies upon the dbext.vim plugin
        if s:SQLCCheck4dbext() == -1
            return []
        endif

        &quot; Allow the user to override the dbext plugin to specify whether
        &quot; the owner/creator should be included in the list
        if g:loaded_dbext &gt;= 300
            let saveSetting = DB_listOption('dict_show_owner')
            exec 'DBSetOption dict_show_owner='.(g:omni_sql_include_owner==1?'1':'0')
        endif

        let compl_type_uc = substitute(compl_type, '\w\+', '\u&amp;', '')
        &quot; Same call below, no need to do it twice
        &quot; if s:sql_file_{compl_type} == &quot;&quot;
        &quot;     let s:sql_file_{compl_type} = DB_getDictionaryName(compl_type_uc)
        &quot; endif
        let s:sql_file_{compl_type} = DB_getDictionaryName(compl_type_uc)
        if s:sql_file_{compl_type} != &quot;&quot;
            if filereadable(s:sql_file_{compl_type})
                let compl_list = readfile(s:sql_file_{compl_type})
            endif
        endif

        if g:loaded_dbext &gt; 300
            exec 'DBSetOption dict_show_owner='.saveSetting
        endif
    elseif compl_type =~? 'column'

        &quot; This type of completion relies upon the dbext.vim plugin
        if s:SQLCCheck4dbext() == -1
            return []
        endif

        if base == &quot;&quot;
            &quot; The last time we displayed a column list we stored
            &quot; the table name.  If the user selects a column list
            &quot; without a table name of alias present, assume they want
            &quot; the previous column list displayed.
            let base = s:save_prev_table
        endif

        let owner  = ''
        let column = ''

        if base =~ '\.'
            &quot; Check if the owner/creator has been specified
            let owner  = matchstr( base, '^\zs.*\ze\..*\..*' )
            let table  = matchstr( base, '^\(.*\.\)\?\zs.*\ze\..*' )
            let column = matchstr( base, '.*\.\zs.*' )

            if g:omni_sql_include_owner == 1 &amp;&amp; owner == '' &amp;&amp; table != '' &amp;&amp; column != ''
                let owner  = table
                let table  = column
                let column = ''
            endif

            &quot; It is pretty well impossible to determine if the user
            &quot; has entered:
            &quot;    owner.table
            &quot;    table.column_prefix
            &quot; So there are a couple of things we can do to mitigate
            &quot; this issue.
            &quot;    1.  Check if the dbext plugin has the option turned
            &quot;        on to even allow owners
            &quot;    2.  Based on 1, if the user is showing a table list
            &quot;        and the DrillIntoTable (using &lt;Right&gt;) then
            &quot;        this will be owner.table.  In this case, we can
            &quot;        check to see the table.column exists in the
            &quot;        cached table list.  If it does, then we have
            &quot;        determined the user has actually chosen
            &quot;        owner.table, not table.column_prefix.
            let found = -1
            if g:omni_sql_include_owner == 1 &amp;&amp; owner == ''
                if filereadable(s:sql_file_table)
                    let tbl_list = readfile(s:sql_file_table)
                    let found    = index( tbl_list, ((table != '')?(table.'.'):'').column)
                endif
            endif
            &quot; If the table.column was found in the table list, we can safely assume
            &quot; the owner was not provided and shift the items appropriately.
            &quot; OR
            &quot; If the user has indicated not to use table owners at all and
            &quot; the base ends in a '.' we know they are not providing a column
            &quot; name, so we can shift the items appropriately.
            &quot; if found != -1 || (g:omni_sql_include_owner == 0 &amp;&amp; base !~ '\.$')
            &quot;     let owner  = table
            &quot;     let table  = column
            &quot;     let column = ''
            &quot; endif
        else
            &quot; If no &quot;.&quot; was provided and the user asked for
            &quot; column level completion, first attempt the match
            &quot; on any previous column lists.  If the user asked
            &quot; for a list of columns comma separated, continue as usual.
            if compl_type == 'column' &amp;&amp; s:save_prev_table != ''
                &quot; The last time we displayed a column list we stored
                &quot; the table name.  If the user selects a column list
                &quot; without a table name of alias present, assume they want
                &quot; the previous column list displayed.
                let table     = s:save_prev_table
                let list_type = ''

                let compl_list  = s:SQLCGetColumns(table, list_type)
                if ! empty(compl_list)
                    &quot; If no column prefix has been provided and the table
                    &quot; name was provided, append it to each of the items
                    &quot; returned.
                    let compl_list = filter(deepcopy(compl_list), 'v:val=~&quot;^'.base.'&quot;' )

                    &quot; If not empty, we have a match on columns
                    &quot; return the list
                    if ! empty(compl_list)
                        return compl_list
                    endif
                endif
            endif
            &quot; Since no columns were found to match the base supplied
            &quot; assume the user is trying to complete the column list
            &quot; for a table (and or an alias to a table).
            let table  = base
        endif

        &quot; Get anything after the . and consider this the table name
        &quot; If an owner has been specified, then we must consider the
        &quot; base to be a partial column name
        &quot; let base  = matchstr( base, '^\(.*\.\)\?\zs.*' )

        if table != &quot;&quot;
            let s:save_prev_table = base
            let list_type         = ''

            if compl_type == 'column_csv'
                &quot; Return one array element, with a comma separated
                &quot; list of values instead of multiple array entries
                &quot; for each column in the table.
                let list_type     = 'csv'
            endif

            &quot; If we are including the OWNER for the objects, then for
            &quot; table completion, if we have it, it should be included
            &quot; as there can be the same table names in a database yet
            &quot; with different owner names.
            if g:omni_sql_include_owner == 1 &amp;&amp; owner != '' &amp;&amp; table != ''
                let compl_list  = s:SQLCGetColumns(owner.'.'.table, list_type)
            else
                let compl_list  = s:SQLCGetColumns(table, list_type)
            endif

            if column != ''
                &quot; If no column prefix has been provided and the table
                &quot; name was provided, append it to each of the items
                &quot; returned.
                let compl_list = map(compl_list, 'table.&quot;.&quot;.v:val')
                if owner != ''
                    &quot; If an owner has been provided append it to each of the
                    &quot; items returned.
                    let compl_list = map(compl_list, 'owner.&quot;.&quot;.v:val')
                endif
            else
                let base = ''
            endif

            if compl_type == 'column_csv'
                &quot; Join the column array into 1 single element array
                &quot; but make the columns column separated
                let compl_list        = [join(compl_list, ', ')]
            endif
        endif
    elseif compl_type == 'resetCache'
        &quot; Reset all cached items
        let s:tbl_name           = []
        let s:tbl_alias          = []
        let s:tbl_cols           = []
        let s:syn_list           = []
        let s:syn_value          = []

        if s:sql_file_table != &quot;&quot;
            if g:loaded_dbext &gt;= 2300
                call DB_DictionaryDelete(&quot;table&quot;)
            else
                DBCompleteTables!
            endif
        endif
        if s:sql_file_procedure != &quot;&quot;
            if g:loaded_dbext &gt;= 2300
                call DB_DictionaryDelete(&quot;procedure&quot;)
            else
                DBCompleteProcedures!
            endif
        endif
        if s:sql_file_view != &quot;&quot;
            if g:loaded_dbext &gt;= 2300
                call DB_DictionaryDelete(&quot;view&quot;)
            else
                DBCompleteViews!
            endif
        endif

        let s:sql_file_table     = &quot;&quot;
        let s:sql_file_procedure = &quot;&quot;
        let s:sql_file_view      = &quot;&quot;

        let msg = &quot;All SQL cached items have been removed.&quot;
        call s:SQLCWarningMsg(msg)
        &quot; Leave time for the user to read the error message
        :sleep 2
    else
        let compl_list = s:SQLCGetSyntaxList(compl_type)
    endif

    if base != ''
        &quot; Filter the list based on the first few characters the user entered.
        &quot; Check if the text matches at the beginning
        &quot;         \\(^.base.'\\)
        &quot; or
        &quot; Match to a owner.table or alias.column type match
        &quot;         ^\\(\\w\\+\\.\\)\\?'.base.'\\)
        &quot; or
        &quot; Handle names with spaces &quot;my table name&quot;
        &quot;         &quot;\\(^'.base.'\\|^\\(\\w\\+\\.\\)\\?'.base.'\\)&quot;'
        &quot;
        let expr = 'v:val '.(g:omni_sql_ignorecase==1?'=~?':'=~#').' &quot;\\(^'.base.'\\|^\\(\\w\\+\\.\\)\\?'.base.'\\)&quot;'
        &quot; let expr = 'v:val '.(g:omni_sql_ignorecase==1?'=~?':'=~#').' &quot;\\(^'.base.'\\)&quot;'
        &quot; let expr = 'v:val '.(g:omni_sql_ignorecase==1?'=~?':'=~#').' &quot;\\(^'.base.'\\|\\(\\.\\)\\?'.base.'\\)&quot;'
        &quot; let expr = 'v:val '.(g:omni_sql_ignorecase==1?'=~?':'=~#').' &quot;\\(^'.base.'\\|\\([^.]*\\)\\?'.base.'\\)&quot;'
        let compl_list = filter(deepcopy(compl_list), expr)

        if empty(compl_list) &amp;&amp; compl_type == 'table' &amp;&amp; base =~ '\.$'
            &quot; It is possible we could be looking for column name completion
            &quot; and the user simply hit C-X C-O to lets try it as well
            &quot; since we had no hits with the tables.
            &quot; If the base ends with a . it is hard to know if we are
            &quot; completing table names or column names.
            let list_type = ''

            let compl_list  = s:SQLCGetColumns(base, list_type)
        endif
    endif

    if exists('b:sql_compl_savefunc') &amp;&amp; b:sql_compl_savefunc != &quot;&quot;
        let &amp;omnifunc = b:sql_compl_savefunc
    endif

    if empty(compl_list)
        call s:SQLCWarningMsg( 'Could not find type['.compl_type.'] using prepend[.'.s:prepended.'] base['.a:base.']' )
    endif

    return compl_list
endfunc

function! sqlcomplete#PreCacheSyntax(...)
    let syn_group_arr = []
    let syn_items     = []

    if a:0 &gt; 0
        if type(a:1) != 3
            call s:SQLCWarningMsg(&quot;Parameter is not a list. Example:['syntaxGroup1', 'syntaxGroup2']&quot;)
            return ''
        endif
        let syn_group_arr = a:1
    else
        let syn_group_arr = g:omni_sql_precache_syntax_groups
    endif
    &quot; For each group specified in the list, precache all
    &quot; the sytnax items.
    if !empty(syn_group_arr)
        for group_name in syn_group_arr
            let syn_items = extend( syn_items, s:SQLCGetSyntaxList(group_name) )
        endfor
    endif

    return syn_items
endfunction

function! sqlcomplete#ResetCacheSyntax(...)
    let syn_group_arr = []

    if a:0 &gt; 0
        if type(a:1) != 3
            call s:SQLCWarningMsg(&quot;Parameter is not a list. Example:['syntaxGroup1', 'syntaxGroup2']&quot;)
            return ''
        endif
        let syn_group_arr = a:1
    else
        let syn_group_arr = g:omni_sql_precache_syntax_groups
    endif
    &quot; For each group specified in the list, precache all
    &quot; the sytnax items.
    if !empty(syn_group_arr)
        for group_name in syn_group_arr
            let list_idx = index(s:syn_list, group_name, 0, &amp;ignorecase)
            if list_idx &gt; -1
                &quot; Remove from list of groups
                call remove( s:syn_list, list_idx )
                &quot; Remove from list of keywords
                call remove( s:syn_value, list_idx )
            endif
        endfor
    endif
endfunction

function! sqlcomplete#Map(type)
    &quot; Tell the SQL plugin what you want to complete
    let b:sql_compl_type=a:type
    &quot; Record previous omnifunc, if the SQL completion
    &quot; is being used in conjunction with other filetype
    &quot; completion plugins
    if &amp;omnifunc != &quot;&quot; &amp;&amp; &amp;omnifunc != 'sqlcomplete#Complete'
        &quot; Record the previous omnifunc, the plugin
        &quot; will automatically set this back so that it
        &quot; does not interfere with other ftplugins settings
        let b:sql_compl_savefunc=&amp;omnifunc
    endif
    &quot; Set the OMNI func for the SQL completion plugin
    let &amp;omnifunc='sqlcomplete#Complete'
endfunction

function! sqlcomplete#DrillIntoTable()
    &quot; If the omni popup window is visible
    if pumvisible()
        call sqlcomplete#Map('column')
        &quot; C-Y, makes the currently highlighted entry active
        &quot; and trigger the omni popup to be redisplayed
        call feedkeys(&quot;\&lt;C-Y&gt;\&lt;C-X&gt;\&lt;C-O&gt;&quot;, 'n')
    else
	&quot; If the popup is not visible, simple perform the normal
	&quot; key behaviour.
	&quot; Must use exec since they key must be preceeded by &quot;\&quot;
	&quot; or feedkeys will simply push each character of the string
	&quot; rather than the &quot;key press&quot;.
        exec 'call feedkeys(&quot;\'.g:ftplugin_sql_omni_key_right.'&quot;, &quot;n&quot;)'
    endif
    return &quot;&quot;
endfunction

function! sqlcomplete#DrillOutOfColumns()
    &quot; If the omni popup window is visible
    if pumvisible()
        call sqlcomplete#Map('tableReset')
        &quot; Trigger the omni popup to be redisplayed
        call feedkeys(&quot;\&lt;C-X&gt;\&lt;C-O&gt;&quot;)
    else
	&quot; If the popup is not visible, simple perform the normal
	&quot; key behaviour.
	&quot; Must use exec since they key must be preceeded by &quot;\&quot;
	&quot; or feedkeys will simply push each character of the string
	&quot; rather than the &quot;key press&quot;.
        exec 'call feedkeys(&quot;\'.g:ftplugin_sql_omni_key_left.'&quot;, &quot;n&quot;)'
    endif
    return &quot;&quot;
endfunction

function! s:SQLCWarningMsg(msg)
    echohl WarningMsg
    echomsg 'SQLComplete:'.a:msg
    echohl None
endfunction

function! s:SQLCErrorMsg(msg)
    echohl ErrorMsg
    echomsg 'SQLComplete:'.a:msg
    echohl None
endfunction

function! s:SQLCGetSyntaxList(syn_group)
    let syn_group  = a:syn_group
    let compl_list = []

    &quot; Check if we have already cached the syntax list
    let list_idx = index(s:syn_list, syn_group, 0, &amp;ignorecase)
    if list_idx &gt; -1
        &quot; Return previously cached value
        let compl_list = s:syn_value[list_idx]
    else
        let s:save_inc = g:omni_syntax_group_include_sql
        let s:save_exc = g:omni_syntax_group_exclude_sql
        let g:omni_syntax_group_include_sql = ''
        let g:omni_syntax_group_exclude_sql = ''

        &quot; Request the syntax list items from the
        &quot; syntax completion plugin
        if syn_group == 'syntax'
            &quot; Handle this special case.  This allows the user
            &quot; to indicate they want all the syntax items available,
            &quot; so do not specify a specific include list.
            let syn_value                       = syntaxcomplete#OmniSyntaxList()
        else
            &quot; The user has specified a specific syntax group
            let g:omni_syntax_group_include_sql = syn_group
            let syn_value                       = syntaxcomplete#OmniSyntaxList(syn_group)
        endif
        let g:omni_syntax_group_include_sql = s:save_inc
        let g:omni_syntax_group_exclude_sql = s:save_exc
        &quot; Cache these values for later use
        let s:syn_list  = add( s:syn_list,  syn_group )
        let s:syn_value = add( s:syn_value, syn_value )
        let compl_list  = syn_value
    endif

    return compl_list
endfunction

function! s:SQLCCheck4dbext()
    if !exists('g:loaded_dbext')
        let msg = &quot;The dbext plugin must be loaded for dynamic SQL completion&quot;
        call s:SQLCErrorMsg(msg)
        &quot; Leave time for the user to read the error message
        :sleep 2
        return -1
    elseif g:loaded_dbext &lt; 600
        let msg = &quot;The dbext plugin must be at least version 5.30 &quot; .
                    \ &quot; for dynamic SQL completion&quot;
        call s:SQLCErrorMsg(msg)
        &quot; Leave time for the user to read the error message
        :sleep 2
        return -1
    endif
    return 1
endfunction

function! s:SQLCAddAlias(table_name, table_alias, cols)
    &quot; Strip off the owner if included
    let table_name  = matchstr(a:table_name, '\%(.\{-}\.\)\?\zs\(.*\)' )
    let table_alias = a:table_alias
    let cols        = a:cols

    if g:omni_sql_use_tbl_alias != 'n'
        if table_alias == ''
            if 'da' =~? g:omni_sql_use_tbl_alias
                if table_name =~ '_'
                    &quot; Treat _ as separators since people often use these
                    &quot; for word separators
                    let save_keyword = &amp;iskeyword
                    setlocal iskeyword-=_

                    &quot; Get the first letter of each word
                    &quot; [[:alpha:]] is used instead of \w
                    &quot; to catch extended accented characters
                    &quot;
                    let table_alias = substitute(
                                \ table_name,
                                \ '\&lt;[[:alpha:]]\+\&gt;_\?',
                                \ '\=strpart(submatch(0), 0, 1)',
                                \ 'g'
                                \ )
                    &quot; Restore original value
                    let &amp;iskeyword = save_keyword
                elseif table_name =~ '\u\U'
                    let table_alias = substitute(
                                \ table_name, '\(\u\)\U*', '\1', 'g')
                else
                    let table_alias = strpart(table_name, 0, 1)
                endif
            endif
        endif
        if table_alias != ''
            &quot; Following a word character, make sure there is a . and no spaces
            let table_alias = substitute(table_alias, '\w\zs\.\?\s*$', '.', '')
            if 'a' =~? g:omni_sql_use_tbl_alias &amp;&amp; a:table_alias == ''
                let table_alias = inputdialog(&quot;Enter table alias:&quot;, table_alias)
            endif
        endif
        if table_alias != ''
            let cols = substitute(cols, '\&lt;\w', table_alias.'&amp;', 'g')
        endif
    endif

    return cols
endfunction

function! s:SQLCGetObjectOwner(object)
    &quot; The owner regex matches a word at the start of the string which is
    &quot; followed by a dot, but doesn't include the dot in the result.
    &quot; ^           - from beginning of line
    &quot; \(&quot;\|\[\)\? - ignore any quotes
    &quot; \zs         - start the match now
    &quot; .\{-}       - get owner name
    &quot; \ze         - end the match
    &quot; \(&quot;\|\[\)\? - ignore any quotes
    &quot; \.          - must by followed by a .
    &quot; let owner = matchstr( a:object, '^\s*\zs.*\ze\.' )
    let owner = matchstr( a:object, '^\(&quot;\|\[\)\?\zs\.\{-}\ze\(&quot;\|\]\)\?\.' )
    return owner
endfunction

function! s:SQLCGetColumns(table_name, list_type)
    if a:table_name =~ '\.'
        &quot; Check if the owner/creator has been specified
        let owner  = matchstr( a:table_name, '^\zs.*\ze\..*\..*' )
        let table  = matchstr( a:table_name, '^\(.*\.\)\?\zs.*\ze\..*' )
        let column = matchstr( a:table_name, '.*\.\zs.*' )

        if g:omni_sql_include_owner == 1 &amp;&amp; owner == '' &amp;&amp; table != '' &amp;&amp; column != ''
            let owner  = table
            let table  = column
            let column = ''
        endif
    else
        let owner  = ''
        let table  = matchstr(a:table_name, '^[&quot;\[\]a-zA-Z0-9_ ]\+\ze\.\?')
        let column = ''
    endif

    &quot; Check if the table name was provided as part of the column name
    &quot; let table_name   = matchstr(a:table_name, '^[&quot;\[\]a-zA-Z0-9_ ]\+\ze\.\?')
    let table_name   = table
    let table_cols   = []
    let table_alias  = ''
    let move_to_top  = 1

    let table_name   = substitute(table_name, '\s*\(.\{-}\)\s*$', '\1', 'g')

    &quot; If the table name was given as:
    &quot;     where c.
    let table_name   = substitute(table_name, '^\c\(WHERE\|AND\|OR\)\s\+', '', '')
    if g:loaded_dbext &gt;= 300
        let saveSettingAlias = DB_listOption('use_tbl_alias')
        exec 'DBSetOption use_tbl_alias=n'
    endif

    let table_name_stripped = substitute(table_name, '[&quot;\[\]]*', '', 'g')

    &quot; Check if we have already cached the column list for this table
    &quot; by its name
    let list_idx = index(s:tbl_name, table_name_stripped, 0, &amp;ignorecase)
    if list_idx &gt; -1
        let table_cols = split(s:tbl_cols[list_idx], '\n')
    else
        &quot; Check if we have already cached the column list for this table
        &quot; by its alias, assuming the table_name provided was actually
        &quot; the alias for the table instead
        &quot;     select *
        &quot;       from area a
        &quot;      where a.
        let list_idx = index(s:tbl_alias, table_name_stripped, 0, &amp;ignorecase)
        if list_idx &gt; -1
            let table_alias = table_name_stripped
            let table_name  = s:tbl_name[list_idx]
            let table_cols  = split(s:tbl_cols[list_idx], '\n')
        endif
    endif

    &quot; If we have not found a cached copy of the table
    &quot; And the table ends in a &quot;.&quot; or we are looking for a column list
    &quot; if list_idx == -1 &amp;&amp; (a:table_name =~ '\.' || b:sql_compl_type =~ 'column')
    &quot; if list_idx == -1 &amp;&amp; (a:table_name =~ '\.' || a:list_type =~ 'csv')
    if list_idx == -1
         let saveY      = @y
         let saveSearch = @/
         let saveWScan  = &amp;wrapscan
         let curline    = line(&quot;.&quot;)
         let curcol     = col(&quot;.&quot;)

         &quot; Do not let searchs wrap
         setlocal nowrapscan
         &quot; If . was entered, look at the word just before the .
         &quot; We are looking for something like this:
         &quot;    select *
         &quot;      from customer c
         &quot;     where c.
         &quot; So when . is pressed, we need to find 'c'
         &quot;

         &quot; Search backwards to the beginning of the statement
         &quot; and do NOT wrap
         &quot; exec 'silent! normal! v?\&lt;\(select\|update\|delete\|;\)\&gt;'.&quot;\n&quot;.'&quot;yy'
         exec 'silent! normal! ?\&lt;\c\(select\|update\|delete\|;\)\&gt;'.&quot;\n&quot;

         &quot; Start characterwise visual mode
         &quot; Advance right one character
         &quot; Search forward until one of the following:
         &quot;     1.  Another select/update/delete statement
         &quot;     2.  A ; at the end of a line (the delimiter)
         &quot;     3.  The end of the file (incase no delimiter)
         &quot; Yank the visually selected text into the &quot;y register.
         exec 'silent! normal! vl/\c\(\&lt;select\&gt;\|\&lt;update\&gt;\|\&lt;delete\&gt;\|;\s*$\|\%$\)'.&quot;\n&quot;.'&quot;yy'

         let query = @y
         let query = substitute(query, &quot;\n&quot;, ' ', 'g')
         let found = 0

         &quot; if query =~? '^\c\(select\)'
         if query =~? '^\(select\|update\|delete\)'
             let found = 1
             &quot;  \(\(\&lt;\w\+\&gt;\)\.\)\?   -
             &quot; '\c\(from\|join\|,\).\{-}'  - Starting at the from clause (case insensitive)
             &quot; '\zs\(\(\&lt;\w\+\&gt;\)\.\)\?' - Get the owner name (optional)
             &quot; '\&lt;\w\+\&gt;\ze' - Get the table name
             &quot; '\s\+\&lt;'.table_name.'\&gt;' - Followed by the alias
             &quot; '\s*\.\@!.*'  - Cannot be followed by a .
             &quot; '\(\&lt;where\&gt;\|$\)' - Must be followed by a WHERE clause
             &quot; '.*'  - Exclude the rest of the line in the match
             &quot; let table_name_new = matchstr(@y,
             &quot;             \ '\c\(from\|join\|,\).\{-}'.
             &quot;             \ '\zs\(\(&quot;\|\[\)\?.\{-}\(&quot;\|\]\)\.\)\?'.
             &quot;             \ '\(&quot;\|\[\)\?.\{-}\(&quot;\|\]\)\?\ze'.
             &quot;             \ '\s\+\%(as\s\+\)\?\&lt;'.
             &quot;             \ matchstr(table_name, '.\{-}\ze\.\?$').
             &quot;             \ '\&gt;'.
             &quot;             \ '\s*\.\@!.*'.
             &quot;             \ '\(\&lt;where\&gt;\|$\)'.
             &quot;             \ '.*'
             &quot;             \ )
             &quot;
             &quot;
             &quot; ''\c\(\&lt;from\&gt;\|\&lt;join\&gt;\|,\)\s*'  - Starting at the from clause (case insensitive)
             &quot; '\zs\(\(&quot;\|\[\)\?\w\+\(&quot;\|\]\)\?\.\)\?' - Get the owner name (optional)
             &quot; '\(&quot;\|\[\)\?\w\+\(&quot;\|\]\)\?\ze' - Get the table name
             &quot; '\s\+\%(as\s\+\)\?\&lt;'.matchstr(table_name, '.\{-}\ze\.\?$').'\&gt;' - Followed by the alias
             &quot; '\s*\.\@!.*'  - Cannot be followed by a .
             &quot; '\(\&lt;where\&gt;\|$\)' - Must be followed by a WHERE clause
             &quot; '.*'  - Exclude the rest of the line in the match
             let table_name_new = matchstr(@y,
                         \ '\c\(\&lt;from\&gt;\|\&lt;join\&gt;\|,\)\s*'.
                         \ '\zs\(\(&quot;\|\[\)\?\w\+\(&quot;\|\]\)\?\.\)\?'.
                         \ '\(&quot;\|\[\)\?\w\+\(&quot;\|\]\)\?\ze'.
                         \ '\s\+\%(as\s\+\)\?\&lt;'.
                         \ matchstr(table_name, '.\{-}\ze\.\?$').
                         \ '\&gt;'.
                         \ '\s*\.\@!.*'.
                         \ '\(\&lt;where\&gt;\|$\)'.
                         \ '.*'
                         \ )

             if table_name_new != ''
                 let table_alias = table_name
                 if g:omni_sql_include_owner == 1
                    let table_name  = matchstr( table_name_new, '^\zs\(.\{-}\.\)\?\(.\{-}\.\)\?.*\ze' )
                 else
                     &quot; let table_name  = matchstr( table_name_new, '^\(.*\.\)\?\zs.*\ze' )
                    let table_name  = matchstr( table_name_new, '^\(.\{-}\.\)\?\zs\(.\{-}\.\)\?.*\ze' )
                 endif

                 let list_idx = index(s:tbl_name, table_name, 0, &amp;ignorecase)
                 if list_idx &gt; -1
                     let table_cols  = split(s:tbl_cols[list_idx])
                     let s:tbl_name[list_idx]  = table_name
                     let s:tbl_alias[list_idx] = table_alias
                 else
                     let list_idx = index(s:tbl_alias, table_name, 0, &amp;ignorecase)
                     if list_idx &gt; -1
                         let table_cols = split(s:tbl_cols[list_idx])
                         let s:tbl_name[list_idx]  = table_name
                         let s:tbl_alias[list_idx] = table_alias
                     endif
                 endif

             endif
         else
             &quot; Simply assume it is a table name provided with a . on the end
             let found = 1
         endif

         let @y        = saveY
         let @/        = saveSearch
         let &amp;wrapscan = saveWScan

         &quot; Return to previous location
         call cursor(curline, curcol)

         if found == 0
             if g:loaded_dbext &gt; 300
                 exec 'DBSetOption use_tbl_alias='.saveSettingAlias
             endif

             &quot; Not a SQL statement, do not display a list
             return []
         endif
    endif

    if empty(table_cols)
        &quot; Specify silent mode, no messages to the user (tbl, 1)
        &quot; Specify do not comma separate (tbl, 1, 1)
        &quot; let table_cols_str = DB_getListColumn(table_name, 1, 1)
        let table_cols_str = DB_getListColumn((owner!=''?owner.'.':'').table_name, 1, 1)

        if table_cols_str != &quot;&quot;
            let s:tbl_name  = add( s:tbl_name,  table_name )
            let s:tbl_alias = add( s:tbl_alias, table_alias )
            let s:tbl_cols  = add( s:tbl_cols,  table_cols_str )
            let table_cols  = split(table_cols_str, '\n')
        endif

    endif

    if g:loaded_dbext &gt; 300
        exec 'DBSetOption use_tbl_alias='.saveSettingAlias
    endif

    &quot; If the user has asked for a comma separate list of column
    &quot; values, ask the user if they want to prepend each column
    &quot; with a tablename alias.
    if a:list_type == 'csv' &amp;&amp; !empty(table_cols)
        let cols       = join(table_cols, ', ')
        let cols       = s:SQLCAddAlias(table_name, table_alias, cols)
        let table_cols = [cols]
    endif

    return table_cols
endfunction
&quot;  Restore:
let &amp;cpo= s:keepcpo
unlet s:keepcpo
&quot; vim: ts=4 fdm=marker
</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Fusr%2Fshare%2Fvim%2Fvim80%2Fautoload'>Back to Directory</a>