Skip to content

P
Postgres FD Implementation
Commit c5686b29 authored by Bruce Momjian's avatar Bruce Momjian
Browse files
Options

Re-run pgindent to fix breakage when exceeding 150 'else if' clauses. 

Cosmetic fix only.
parent 76ce39e3
Show whitespace changes
Inline Side-by-side
Showing with 393 additions and 2196 deletions
src/bin/psql/tab-complete.c
View file @ c5686b29
...@@ -3,7 +3,7 @@ ...@@ -3,7 +3,7 @@
* *
* Copyright (c) 2000-2005, PostgreSQL Global Development Group * Copyright (c) 2000-2005, PostgreSQL Global Development Group
* *
* $PostgreSQL: pgsql/src/bin/psql/tab-complete.c,v 1.139 2005/11/07 17:36:45 tgl Exp $ * $PostgreSQL: pgsql/src/bin/psql/tab-complete.c,v 1.140 2005/11/14 17:48:43 momjian Exp $
*/ */
/*---------------------------------------------------------------------- /*----------------------------------------------------------------------
...@@ -1783,133 +1783,10 @@ psql_completion(char *text, int start, int end) ...@@ -1783,133 +1783,10 @@ psql_completion(char *text, int start, int end)
/* /*
* * Finally, we look through the list of "things", such as TABLE, INDEX and
* Fi * check if that was the previous word. If so, execute the query to get a
* n * list of them.
* a */
* l
* l
* y
* ,
*
* we
*
* lo
* o
* k
*
* th
* r
* o
* u
* g
* h
*
* th
* e
*
* li
* s
* t
*
* of
*
* "t
* h
* i
* n
* g
* s
* "
* ,
*
* su
* c
* h
*
* as
*
* TA
* B
* L
* E
* ,
*
* IN
* D
* E
* X
*
* an
* d
*
* ch
* e
* c
* k
*
* if
*
* th
* a
* t
*
* wa
* s
*
* th
* e
*
* pr
* e
* v
* i
* o
* u
* s
*
* wo
* r
* d
* .
*
* If
*
* so
* ,
*
* ex
* e
* c
* u
* t
* e
*
* th
* e
*
* qu
* e
* r
* y
*
* to
*
* ge
* t
*
* a
* li
* s
* t
*
* of
*
* th
* e
* m
* .
* */
else else
{ {
int i; int i;
...@@ -1929,175 +1806,10 @@ psql_completion(char *text, int start, int end) ...@@ -1929,175 +1806,10 @@ psql_completion(char *text, int start, int end)
} }
/* /*
* * If we still don't have anything to match we have to fabricate some sort
* If * of default list. If we were to just return NULL, readline automatically
* * attempts filename completion, and that's usually no good.
* we */
*
* st
* i
* l
* l
*
* do
* n
* '
* t
*
* ha
* v
* e
*
* an
* y
* t
* h
* i
* n
* g
*
* to
*
* ma
* t
* c
* h
*
* we
*
* ha
* v
* e
*
* to
*
* fa
* b
* r
* i
* c
* a
* t
* e
*
* so
* m
* e
*
* so
* r
* t
*
* of
*
* de
* f
* a
* u
* l
* t
*
* li
* s
* t
* .
*
* If
*
* we
*
* we
* r
* e
*
* to
*
* ju
* s
* t
*
* re
* t
* u
* r
* n
*
* NU
* L
* L
* ,
*
* re
* a
* d
* l
* i
* n
* e
*
* au
* t
* o
* m
* a
* t
* i
* c
* a
* l
* l
* y
*
* at
* t
* e
* m
* p
* t
* s
*
* fi
* l
* e
* n
* a
* m
* e
*
* co
* m
* p
* l
* e
* t
* i
* o
* n
* ,
*
* an
* d
*
* th
* a
* t
* '
* s
*
* us
* u
* a
* l
* l
* y
*
* no
*
* go
* o
* d
* .
* */
if (matches == NULL) if (matches == NULL)
{ {
COMPLETE_WITH_CONST(""); COMPLETE_WITH_CONST("");
...@@ -2106,58 +1818,16 @@ psql_completion(char *text, int start, int end) ...@@ -2106,58 +1818,16 @@ psql_completion(char *text, int start, int end)
#endif #endif
} }
/* /* free storage */
* f
* r
* e
* e
*
* st
* o
* r
* a
* g
* e
*
*/
free(prev_wd); free(prev_wd);
free(prev2_wd); free(prev2_wd);
free(prev3_wd); free(prev3_wd);
free(prev4_wd); free(prev4_wd);
free(prev5_wd); free(prev5_wd);
/* /* Return our Grand List O' Matches */
* R
* e
* t
* u
* r
* n
*
* ou
* r
*
* Gr
* a
* n
* d
*
* Li
* s
* t
*
* O'
*
* Ma
* t
* c
* h
* e
* s
*
*/
return matches; return matches;
} }
...@@ -2177,152 +1847,43 @@ psql_completion(char *text, int start, int end) ...@@ -2177,152 +1847,43 @@ psql_completion(char *text, int start, int end)
/* This one gives you one from a list of things you can put after CREATE or DROP /* This one gives you one from a list of things you can put after CREATE or DROP
as defined above. as defined above.
*/ */
static char * static char *
create_command_generator(const char *text, int state) create_command_generator(const char *text, int state)
{ {
static int list_index, static int list_index,
string_length; string_length;
const char *name; const char *name;
/* /* If this is the first time for this completion, init some values */
* I
* f
*
* th
* i
* s
*
* is
*
* th
* e
*
* fi
* r
* s
* t
*
* ti
* m
* e
*
* fo
* r
*
* th
* i
* s
*
* co
* m
* p
* l
* e
* t
* i
* o
* n
* ,
*
* in
* i
* t
*
* so
* m
* e
*
* va
* l
* u
* e
* s
*
*/
if (state == 0) if (state == 0)
{ {
list_index = 0; list_index = 0;
string_length = strlen(text); string_length = strlen(text);
} }
/* /* find something that matches */
* f
* i
* n
* d
*
* so
* m
* e
* t
* h
* i
* n
* g
*
* th
* a
* t
*
* ma
* t
* c
* h
* e
* s
*
*/
while ((name = words_after_create[list_index++].name)) while ((name = words_after_create[list_index++].name))
if (pg_strncasecmp(name, text, string_length) == 0) if (pg_strncasecmp(name, text, string_length) == 0)
return pg_strdup(name); return pg_strdup(name);
/* /* if nothing matches, return NULL */
* i
* f
*
* no
* t
* h
* i
* n
* g
*
* ma
* t
* c
* h
* e
* s
* ,
*
* re
* t
* u
* r
* n
*
* NU
* L
* L
*
*/
return NULL; return NULL;
} }
/* The following two functions are wrappers for _complete_from_query */ /* The following two functions are wrappers for _complete_from_query */
static char * static char *
complete_from_query(const char *text, int state) complete_from_query(const char *text, int state)
{ {
return _complete_from_query(0, text, state); return _complete_from_query(0, text, state);
} }
static char * static char *
complete_from_schema_query(const char *text, int state) complete_from_schema_query(const char *text, int state)
{ {
return _complete_from_query(1, text, state); return _complete_from_query(1, text, state);
} }
/* This creates a list of matching things, according to a query pointed to /* This creates a list of matching things, according to a query pointed to
...@@ -2344,93 +1905,17 @@ psql_completion(char *text, int start, int end) ...@@ -2344,93 +1905,17 @@ psql_completion(char *text, int start, int end)
See top of file for examples of both kinds of query. See top of file for examples of both kinds of query.
*/ */
static char * static char *
_complete_from_query(int is_schema_query, const char *text, int state) _complete_from_query(int is_schema_query, const char *text, int state)
{ {
static int list_index, static int list_index,
string_length; string_length;
static PGresult *result = NULL; static PGresult *result = NULL;
/* /*
* * If this is the first time for this completion, we fetch a list of our
* If * "things" from the backend.
* */
* th
* i
* s
*
* is
*
* th
* e
*
* fi
* r
* s
* t
*
* ti
* m
* e
*
* fo
* r
*
* th
* i
* s
*
* co
* m
* p
* l
* e
* t
* i
* o
* n
* ,
*
* we
*
* fe
* t
* c
* h
*
* a
* li
* s
* t
*
* of
*
* ou
* r
*
* "t
* h
* i
* n
* g
* s
* "
*
* fr
* o
* m
*
* th
* e
*
* ba
* c
* k
* e
* n
* d
* .
* */
if (state == 0) if (state == 0)
{ {
PQExpBufferData query_buffer; PQExpBufferData query_buffer;
...@@ -2440,75 +1925,11 @@ psql_completion(char *text, int start, int end) ...@@ -2440,75 +1925,11 @@ psql_completion(char *text, int start, int end)
list_index = 0; list_index = 0;
string_length = strlen(text); string_length = strlen(text);
/* /* Free any prior result */
* F
* r
* e
* e
*
* an
* y
*
* pr
* i
* o
* r
*
* re
* s
* u
* l
* t
*
*/
PQclear(result); PQclear(result);
result = NULL; result = NULL;
/* /* Set up suitably-escaped copies of textual inputs */
* S
* e
* t
*
* up
*
* su
* i
* t
* a
* b
* l
* y
* -
* e
* s
* c
* a
* p
* e
* d
*
* co
* p
* i
* e
* s
*
* of
*
* te
* x
* t
* u
* a
* l
*
* in
* p
* u
* t
* s
*
*/
e_text = pg_malloc(string_length * 2 + 1); e_text = pg_malloc(string_length * 2 + 1);
PQescapeString(e_text, text, string_length); PQescapeString(e_text, text, string_length);
...@@ -2528,102 +1949,13 @@ psql_completion(char *text, int start, int end) ...@@ -2528,102 +1949,13 @@ psql_completion(char *text, int start, int end)
if (is_schema_query) if (is_schema_query)
{ {
/* /* completion_squery gives us the pieces to assemble */
* c
* o
* m
* p
* l
* e
* t
* i
* o
* n
* _
* s
* q
* u
* e
* r
* y
*
* gi
* v
* e
* s
*
* us
*
* th
* e
*
* pi
* e
* c
* e
* s
*
* to
*
* as
* s
* e
* m
* b
* l
* e
*
*/
const char *qualresult = completion_squery->qualresult; const char *qualresult = completion_squery->qualresult;
if (qualresult == NULL) if (qualresult == NULL)
qualresult = completion_squery->result; qualresult = completion_squery->result;
/* /* Get unqualified names matching the input-so-far */
* G
* e
* t
*
* un
* q
* u
* a
* l
* i
* f
* i
* e
* d
*
* na
* m
* e
* s
*
* ma
* t
* c
* h
* i
* n
* g
*
* th
* e
*
* in
* p
* u
* t
* -
* s
* o
* -
* f
* a
* r
*
*/
appendPQExpBuffer(&query_buffer, "SELECT %s FROM %s WHERE ", appendPQExpBuffer(&query_buffer, "SELECT %s FROM %s WHERE ",
completion_squery->result, completion_squery->result,
completion_squery->catname); completion_squery->catname);
...@@ -2637,209 +1969,11 @@ psql_completion(char *text, int start, int end) ...@@ -2637,209 +1969,11 @@ psql_completion(char *text, int start, int end)
completion_squery->viscondition); completion_squery->viscondition);
/* /*
* * When fetching relation names, suppress system catalogs unless
* Wh * the input-so-far begins with "pg_". This is a compromise
* e * between not offering system catalogs for completion at all, and
* n * having them swamp the result when the input is just "p".
* */
* fe
* t
* c
* h
* i
* n
* g
*
* re
* l
* a
* t
* i
* o
* n
*
* na
* m
* e
* s
* ,
*
* su
* p
* p
* r
* e
* s
* s
*
* sy
* s
* t
* e
* m
*
* ca
* t
* a
* l
* o
* g
* s
*
* un
* l
* e
* s
* s
*
* th
* e
*
* in
* p
* u
* t
* -
* s
* o
* -
* f
* a
* r
*
* be
* g
* i
* n
* s
*
* wi
* t
* h
*
* "p
* g
* _
* "
* .
*
* Th
* i
* s
*
* is
*
* a
* co
* m
* p
* r
* o
* m
* i
* s
* e
*
* be
* t
* w
* e
* e
* n
*
* no
* t
*
* of
* f
* e
* r
* i
* n
* g
*
* sy
* s
* t
* e
* m
*
* ca
* t
* a
* l
* o
* g
* s
*
* fo
* r
*
* co
* m
* p
* l
* e
* t
* i
* o
* n
*
* at
*
* al
* l
* ,
*
* an
* d
*
* ha
* v
* i
* n
* g
*
* th
* e
* m
*
* sw
* a
* m
* p
*
* th
* e
*
* re
* s
* u
* l
* t
*
* wh
* e
* n
*
* th
* e
*
* in
* p
* u
* t
*
* is
*
* ju
* s
* t
*
* "p
* "
* .
* */
if (strcmp(completion_squery->catname, if (strcmp(completion_squery->catname,
"pg_catalog.pg_class c") == 0 && "pg_catalog.pg_class c") == 0 &&
strncmp(text, "pg_", 3) !=0) strncmp(text, "pg_", 3) !=0)
...@@ -2850,90 +1984,9 @@ psql_completion(char *text, int start, int end) ...@@ -2850,90 +1984,9 @@ psql_completion(char *text, int start, int end)
} }
/* /*
* * Add in matching schema names, but only if there is more than
* Ad * one potential match among schema names.
* d */
*
* in
*
* ma
* t
* c
* h
* i
* n
* g
*
* sc
* h
* e
* m
* a
*
* na
* m
* e
* s
* ,
*
* bu
* t
*
* on
* l
* y
*
* if
*
* th
* e
* r
* e
*
* is
*
* mo
* r
* e
*
* th
* a
* n
*
* on
* e
*
* po
* t
* e
* n
* t
* i
* a
* l
*
* ma
* t
* c
* h
*
* am
* o
* n
* g
*
* sc
* h
* e
* m
* a
*
* na
* m
* e
* s
* .
* */
appendPQExpBuffer(&query_buffer, "\nUNION\n" appendPQExpBuffer(&query_buffer, "\nUNION\n"
"SELECT pg_catalog.quote_ident(n.nspname) || '.' " "SELECT pg_catalog.quote_ident(n.nspname) || '.' "
"FROM pg_catalog.pg_namespace n " "FROM pg_catalog.pg_namespace n "
...@@ -2947,91 +2000,9 @@ psql_completion(char *text, int start, int end) ...@@ -2947,91 +2000,9 @@ psql_completion(char *text, int start, int end)
string_length, e_text); string_length, e_text);
/* /*
* * Add in matching qualified names, but only if there is exactly
* Ad * one schema matching the input-so-far.
* d */
*
* in
*
* ma
* t
* c
* h
* i
* n
* g
*
* qu
* a
* l
* i
* f
* i
* e
* d
*
* na
* m
* e
* s
* ,
*
* bu
* t
*
* on
* l
* y
*
* if
*
* th
* e
* r
* e
*
* is
*
* ex
* a
* c
* t
* l
* y
*
* on
* e
*
* sc
* h
* e
* m
* a
*
* ma
* t
* c
* h
* i
* n
* g
*
* th
* e
*
* in
* p
* u
* t
* -
* s
* o
* -
* f
* a
* r
* .
* */
appendPQExpBuffer(&query_buffer, "\nUNION\n" appendPQExpBuffer(&query_buffer, "\nUNION\n"
"SELECT pg_catalog.quote_ident(n.nspname) || '.' || %s " "SELECT pg_catalog.quote_ident(n.nspname) || '.' || %s "
"FROM %s, pg_catalog.pg_namespace n " "FROM %s, pg_catalog.pg_namespace n "
...@@ -3047,74 +2018,9 @@ psql_completion(char *text, int start, int end) ...@@ -3047,74 +2018,9 @@ psql_completion(char *text, int start, int end)
string_length, e_text); string_length, e_text);
/* /*
* * This condition exploits the single-matching-schema rule to
* Th * speed up the query
* i */
* s
*
* co
* n
* d
* i
* t
* i
* o
* n
*
* ex
* p
* l
* o
* i
* t
* s
*
* th
* e
*
* si
* n
* g
* l
* e
* -
* m
* a
* t
* c
* h
* i
* n
* g
* -
* s
* c
* h
* e
* m
* a
*
* ru
* l
* e
*
* to
*
* sp
* e
* e
* d
*
* up
*
* th
* e
*
* qu
* e
* r
* y
* */
appendPQExpBuffer(&query_buffer, appendPQExpBuffer(&query_buffer,
" AND substring(pg_catalog.quote_ident(n.nspname) || '.',1,%d) =" " AND substring(pg_catalog.quote_ident(n.nspname) || '.',1,%d) ="
" substring('%s',1,pg_catalog.length(pg_catalog.quote_ident(n.nspname))+1)", " substring('%s',1,pg_catalog.length(pg_catalog.quote_ident(n.nspname))+1)",
...@@ -3126,134 +2032,18 @@ psql_completion(char *text, int start, int end) ...@@ -3126,134 +2032,18 @@ psql_completion(char *text, int start, int end)
" substring('%s',1,pg_catalog.length(pg_catalog.quote_ident(nspname))+1)) = 1", " substring('%s',1,pg_catalog.length(pg_catalog.quote_ident(nspname))+1)) = 1",
string_length, e_text); string_length, e_text);
/* /* If an addon query was provided, use it */
* I
* f
*
* an
*
* ad
* d
* o
* n
*
* qu
* e
* r
* y
*
* wa
* s
*
* pr
* o
* v
* i
* d
* e
* d
* ,
*
* us
* e
*
* it
*
*/
if (completion_charp) if (completion_charp)
appendPQExpBuffer(&query_buffer, "\n%s", completion_charp); appendPQExpBuffer(&query_buffer, "\n%s", completion_charp);
} }
else else
{ {
/* /* completion_charp is an sprintf-style format string */
* c
* o
* m
* p
* l
* e
* t
* i
* o
* n
* _
* c
* h
* a
* r
* p
*
* is
*
* an
*
* sp
* r
* i
* n
* t
* f
* -
* s
* t
* y
* l
* e
*
* fo
* r
* m
* a
* t
*
* st
* r
* i
* n
* g
*
*/
appendPQExpBuffer(&query_buffer, completion_charp, appendPQExpBuffer(&query_buffer, completion_charp,
string_length, e_text, e_info_charp); string_length, e_text, e_info_charp);
} }
/* /* Limit the number of records in the result */
* L
* i
* m
* i
* t
*
* th
* e
*
* nu
* m
* b
* e
* r
*
* of
*
* re
* c
* o
* r
* d
* s
*
* in
*
* th
* e
*
* re
* s
* u
* l
* t
*
*/
appendPQExpBuffer(&query_buffer, "\nLIMIT %d", appendPQExpBuffer(&query_buffer, "\nLIMIT %d",
completion_max_records); completion_max_records);
...@@ -3265,33 +2055,7 @@ psql_completion(char *text, int start, int end) ...@@ -3265,33 +2055,7 @@ psql_completion(char *text, int start, int end)
free(e_info_charp); free(e_info_charp);
} }
/* /* Find something that matches */
* F
* i
* n
* d
*
* so
* m
* e
* t
* h
* i
* n
* g
*
* th
* a
* t
*
* ma
* t
* c
* h
* e
* s
*
*/
if (result && PQresultStatus(result) == PGRES_TUPLES_OK) if (result && PQresultStatus(result) == PGRES_TUPLES_OK)
{ {
const char *item; const char *item;
...@@ -3302,113 +2066,30 @@ psql_completion(char *text, int start, int end) ...@@ -3302,113 +2066,30 @@ psql_completion(char *text, int start, int end)
return pg_strdup(item); return pg_strdup(item);
} }
/* /* If nothing matches, free the db structure and return null */
* I
* f
*
* no
* t
* h
* i
* n
* g
*
* ma
* t
* c
* h
* e
* s
* ,
*
* fr
* e
* e
*
* th
* e
*
* db
*
* st
* r
* u
* c
* t
* u
* r
* e
*
* an
* d
*
* re
* t
* u
* r
* n
*
* nu
* l
* l
*
*/
PQclear(result); PQclear(result);
result = NULL; result = NULL;
return NULL; return NULL;
} }
/* This function returns in order one of a fixed, NULL pointer terminated list /* This function returns in order one of a fixed, NULL pointer terminated list
of strings (if matching). This can be used if there are only a fixed number of strings (if matching). This can be used if there are only a fixed number
SQL words that can appear at certain spot. SQL words that can appear at certain spot.
*/ */
static char * static char *
complete_from_list(const char *text, int state) complete_from_list(const char *text, int state)
{ {
static int string_length, static int string_length,
list_index, list_index,
matches; matches;
static bool casesensitive; static bool casesensitive;
const char *item; const char *item;
/* /* need to have a list */
* n
* e
* e
* d
*
* to
*
* ha
* v
* e
*
* a
* li
* s
* t
*
*/
psql_assert(completion_charpp); psql_assert(completion_charpp);
/* /* Initialization */
* I
* n
* i
* t
* i
* a
* l
* i
* z
* a
* t
* i
* o
* n
*
*/
if (state == 0) if (state == 0)
{ {
list_index = 0; list_index = 0;
...@@ -3419,193 +2100,22 @@ psql_completion(char *text, int start, int end) ...@@ -3419,193 +2100,22 @@ psql_completion(char *text, int start, int end)
while ((item = completion_charpp[list_index++])) while ((item = completion_charpp[list_index++]))
{ {
/* /* First pass is case sensitive */
* F
* i
* r
* s
* t
*
* pa
* s
* s
*
* is
*
* ca
* s
* e
*
* se
* n
* s
* i
* t
* i
* v
* e
*
*/
if (casesensitive && strncmp(text, item, string_length) == 0) if (casesensitive && strncmp(text, item, string_length) == 0)
{ {
matches++; matches++;
return pg_strdup(item); return pg_strdup(item);
} }
/* /* Second pass is case insensitive, don't bother counting matches */
* S
* e
* c
* o
* n
* d
*
* pa
* s
* s
*
* is
*
* ca
* s
* e
*
* in
* s
* e
* n
* s
* i
* t
* i
* v
* e
* ,
*
* do
* n
* '
* t
*
* bo
* t
* h
* e
* r
*
* co
* u
* n
* t
* i
* n
* g
*
* ma
* t
* c
* h
* e
* s
*
*/
if (!casesensitive && pg_strncasecmp(text, item, string_length) == 0) if (!casesensitive && pg_strncasecmp(text, item, string_length) == 0)
return pg_strdup(item); return pg_strdup(item);
} }
/* /*
* * No matches found. If we're not case insensitive already, lets switch to
* No * being case insensitive and try again
* */
* ma
* t
* c
* h
* e
* s
*
* fo
* u
* n
* d
* .
*
* If
*
* we
* '
* r
* e
*
* no
* t
*
* ca
* s
* e
*
* in
* s
* e
* n
* s
* i
* t
* i
* v
* e
*
* al
* r
* e
* a
* d
* y
* ,
*
* le
* t
* s
*
* sw
* i
* t
* c
* h
*
* to
*
* be
* i
* n
* g
*
* ca
* s
* e
*
* in
* s
* e
* n
* s
* i
* t
* i
* v
* e
*
* an
* d
*
* tr
* y
*
* ag
* a
* i
* n
* */
if (casesensitive && matches == 0) if (casesensitive && matches == 0)
{ {
casesensitive = false; casesensitive = false;
...@@ -3614,38 +2124,9 @@ psql_completion(char *text, int start, int end) ...@@ -3614,38 +2124,9 @@ psql_completion(char *text, int start, int end)
return (complete_from_list(text, state)); return (complete_from_list(text, state));
} }
/* /* If no more matches, return null. */
* I
* f
*
* no
*
* mo
* r
* e
*
* ma
* t
* c
* h
* e
* s
* ,
*
* re
* t
* u
* r
* n
*
* nu
* l
* l
* .
*
*/
return NULL; return NULL;
} }
/* This function returns one fixed string the first time even if it doesn't /* This function returns one fixed string the first time even if it doesn't
...@@ -3654,11 +2135,10 @@ psql_completion(char *text, int start, int end) ...@@ -3654,11 +2135,10 @@ psql_completion(char *text, int start, int end)
will be overwritten. will be overwritten.
The string to be passed must be in completion_charp. The string to be passed must be in completion_charp.
*/ */
static char * static char *
complete_from_const(const char *text, int state) complete_from_const(const char *text, int state)
{ {
(void) text; /* We don't care about (void) text; /* We don't care about what was entered
* what was entered
* already. */ * already. */
psql_assert(completion_charp); psql_assert(completion_charp);
...@@ -3666,7 +2146,7 @@ psql_completion(char *text, int start, int end) ...@@ -3666,7 +2146,7 @@ psql_completion(char *text, int start, int end)
return pg_strdup(completion_charp); return pg_strdup(completion_charp);
else else
return NULL; return NULL;
} }
...@@ -3677,9 +2157,9 @@ psql_completion(char *text, int start, int end) ...@@ -3677,9 +2157,9 @@ psql_completion(char *text, int start, int end)
* Execute a query and report any errors. This should be the preferred way of * Execute a query and report any errors. This should be the preferred way of
* talking to the database in this file. * talking to the database in this file.
*/ */
static PGresult * static PGresult *
exec_query(const char *query) exec_query(const char *query)
{ {
PGresult *result; PGresult *result;
if (query == NULL || !pset.db || PQstatus(pset.db) != CONNECTION_OK) if (query == NULL || !pset.db || PQstatus(pset.db) != CONNECTION_OK)
...@@ -3698,7 +2178,7 @@ psql_completion(char *text, int start, int end) ...@@ -3698,7 +2178,7 @@ psql_completion(char *text, int start, int end)
} }
return result; return result;
} }
...@@ -3707,9 +2187,9 @@ psql_completion(char *text, int start, int end) ...@@ -3707,9 +2187,9 @@ psql_completion(char *text, int start, int end)
* skip that many words; e.g. skip=1 finds the word before the * skip that many words; e.g. skip=1 finds the word before the
* previous one. Return value is NULL or a malloc'ed string. * previous one. Return value is NULL or a malloc'ed string.
*/ */
static char * static char *
previous_word(int point, int skip) previous_word(int point, int skip)
{ {
int i, int i,
start = 0, start = 0,
end = -1, end = -1,
...@@ -3718,106 +2198,12 @@ psql_completion(char *text, int start, int end) ...@@ -3718,106 +2198,12 @@ psql_completion(char *text, int start, int end)
while (skip-- >= 0) while (skip-- >= 0)
{ {
/* /* first we look for a space before the current word */
* f
* i
* r
* s
* t
*
* we
*
* lo
* o
* k
*
* fo
* r
*
* a
* sp
* a
* c
* e
*
* be
* f
* o
* r
* e
*
* th
* e
*
* cu
* r
* r
* e
* n
* t
*
* wo
* r
* d
*
*/
for (i = point; i >= 0; i--) for (i = point; i >= 0; i--)
if (rl_line_buffer[i] == ' ') if (rl_line_buffer[i] == ' ')
break; break;
/* /* now find the first non-space which then constitutes the end */
* n
* o
* w
*
* fi
* n
* d
*
* th
* e
*
* fi
* r
* s
* t
*
* no
* n
* -
* s
* p
* a
* c
* e
*
* wh
* i
* c
* h
*
* th
* e
* n
*
* co
* n
* s
* t
* i
* t
* u
* t
* e
* s
*
* th
* e
*
* en
* d
*
*/
for (; i >= 0; i--) for (; i >= 0; i--)
if (rl_line_buffer[i] != ' ') if (rl_line_buffer[i] != ' ')
{ {
...@@ -3826,194 +2212,16 @@ psql_completion(char *text, int start, int end) ...@@ -3826,194 +2212,16 @@ psql_completion(char *text, int start, int end)
} }
/* /*
* * If no end found we return null, because there is no word before the
* If * point
* */
* no
*
* en
* d
*
* fo
* u
* n
* d
*
* we
*
* re
* t
* u
* r
* n
*
* nu
* l
* l
* ,
*
* be
* c
* a
* u
* s
* e
*
* th
* e
* r
* e
*
* is
*
* no
*
* wo
* r
* d
*
* be
* f
* o
* r
* e
*
* th
* e
*
* po
* i
* n
* t
* */
if (end == -1) if (end == -1)
return NULL; return NULL;
/* /*
* * Otherwise we now look for the start. The start is either the last
* Ot * character before any space going backwards from the end, or it's
* h * simply character 0
* e
* r
* w
* i
* s
* e
*
* we
*
* no
* w
*
* lo
* o
* k
*
* fo
* r
*
* th
* e
*
* st
* a
* r
* t
* .
*
* Th
* e
*
* st
* a
* r
* t
*
* is
*
* ei
* t
* h
* e
* r
*
* th
* e
*
* la
* s
* t
*
* ch
* a
* r
* a
* c
* t
* e
* r
*
* be
* f
* o
* r
* e
*
* an
* y
*
* sp
* a
* c
* e
*
* go
* i
* n
* g
*
* ba
* c
* k
* w
* a
* r
* d
* s
*
* fr
* o
* m
*
* th
* e
*
* en
* d
* ,
*
* or
*
* it
* '
* s
*
* si
* m
* p
* l
* y
*
* ch
* a
* r
* a
* c
* t
* e
* r
*
* 0
*/ */
for (start = end; start > 0; start--) for (start = end; start > 0; start--)
{ {
...@@ -4026,25 +2234,14 @@ psql_completion(char *text, int start, int end) ...@@ -4026,25 +2234,14 @@ psql_completion(char *text, int start, int end)
point = start; point = start;
} }
/* /* make a copy */
* m
* a
* k
* e
*
* a
* co
* p
* y
*
*/
s = pg_malloc(end - start + 2); s = pg_malloc(end - start + 2);
strncpy(s, &rl_line_buffer[start], end - start + 1); strncpy(s, &rl_line_buffer[start], end - start + 1);
s[end - start + 1] = '\0'; s[end - start + 1] = '\0';
return s; return s;
} }
...@@ -4055,9 +2252,9 @@ psql_completion(char *text, int start, int end) ...@@ -4055,9 +2252,9 @@ psql_completion(char *text, int start, int end)
* psql internal. Currently disabled because it is reported not to * psql internal. Currently disabled because it is reported not to
* cooperate with certain versions of readline. * cooperate with certain versions of readline.
*/ */
static char * static char *
quote_file_name(char *text, int match_type, char *quote_pointer) quote_file_name(char *text, int match_type, char *quote_pointer)
{ {
char *s; char *s;
size_t length; size_t length;
...@@ -4071,13 +2268,13 @@ psql_completion(char *text, int start, int end) ...@@ -4071,13 +2268,13 @@ psql_completion(char *text, int start, int end)
s[length - 2] = '\''; s[length - 2] = '\'';
s[length - 1] = '\0'; s[length - 1] = '\0';
return s; return s;
} }
static char * static char *
dequote_file_name(char *text, char quote_char) dequote_file_name(char *text, char quote_char)
{ {
char *s; char *s;
size_t length; size_t length;
...@@ -4090,7 +2287,7 @@ psql_completion(char *text, int start, int end) ...@@ -4090,7 +2287,7 @@ psql_completion(char *text, int start, int end)
s[length] = '\0'; s[length] = '\0';
return s; return s;
} }
#endif /* 0 */ #endif /* 0 */
#endif /* USE_READLINE */ #endif /* USE_READLINE */
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment