youjo.vim

let s:V= vital#of('vital')
let s:PM= s:V.import('ProcessManager')
let s:D=  s:V.import('Data.Dict')
unlet s:V

""
" @function youjo#connect
" @param config {Dict}
" @return an object (vdbc)
" @see vdbc
"
function! youjo#connect(config)
    let l:obj= {
    \   '_config': deepcopy(a:config),
    \   '_psql': 'youjo-psql',
    \}
    let l:cmd= join([
    \       'psql',
    \       '--host', a:config.host,
    \       '--port', a:config.port,
    \       '--username', a:config.username,
    \       '--dbname', a:config.dbname,
    \       '--no-password',
    \       '--no-align',
    \       '--field-separator=|',
    \       "--record-separator=\n",
    \       '--quiet',
    \   ],
    \   ' '
    \)
    call s:PM.touch('youjo-psql', l:cmd)

    ""
    " @function vdbc.execute
    " @param query {String}
    "
    function! l:obj.execute(query)
        call s:PM.writeln(self._psql, a:query)

        call s:PM.read_wait(self._psql, self._config.timeout_length, ['$'])
    endfunction

    ""
    " @function vdbc.select_as_list
    " @param query {String}
    " @return a list of list
    "
    function! l:obj.select_as_list(query, ...)
        return self._select_as_list({'query': a:query, 'tuples_only': 'on'})
    endfunction

    ""
    " @function vdbc.select_as_dict
    " @param query {String}
    " @return a list of dict
    "
    function! l:obj.select_as_dict(query, ...)
        let l:args= get(a:000, 0, {})
        let l:list= self._select_as_list({'query': a:query, 'tuples_only': 'off'})
        let l:keys= get(l:args, 'keys', l:list[0])

        return map(l:list[1:], 's:D.make(l:keys, v:val)')
    endfunction

    ""
    " @function vdbc.tables
    " @param args {dict}
    " @return a list of string
    function! l:obj.tables(args)
        let l:query= '\dt+'

        return self.select_as_dict('\dtS+', {'keys': ['schema', 'name', 'type', 'owner', 'size', 'remarks']})
    endfunction

    function! l:obj.columns()
    endfunction

    ""
    " 
    " @function vdbc.disconnect
    "
    function! l:obj.disconnect()
        call s:PM.term(self._psql)
    endfunction

    function! l:obj._select_as_list(args)
        call s:PM.writeln(self._psql, '\t ' . get(a:args, 'tuples_only', 'off'))
        call s:PM.writeln(self._psql, a:args.query)

        let l:output= s:PM.read_wait(self._psql, self._config.timeout_length, ['$'])
        let l:records= split(iconv(l:output[0], self._config.encoding, &encoding), "\r\\=\n")

        return map(l:records[1 : len(l:records) - 1], 'split(v:val, "|")')
    endfunction

    return l:obj
endfunction