Avoid direct symbol imports

Always use

  import skytools
  def xx():
  	skytools.foo

this allows maximum laziness when importing.

10 files changed, 75 insertions, 88 deletions

diff --git a/python/londiste/setup.py b/python/londiste/setup.py
index 16634c46..053debf2 100644
--- a/python/londiste/setup.py
+++ b/python/londiste/setup.py
@@ -6,7 +6,6 @@
 import sys, os, re, skytools
 
 from pgq.cascade.admin import CascadeAdmin
-from skytools.scripting import UsageError
 
 import londiste.handler
 
@@ -448,7 +447,7 @@ class LondisteSetup(CascadeAdmin):
                     self.log.warning("%s not available" % a)
                     err = 1
         if err:
-            raise UsageError("Cannot proceed")
+            raise skytools.UsageError("Cannot proceed")
         return res_list
 
     def load_extra_status(self, curs, node):
diff --git a/python/skytools/adminscript.py b/python/skytools/adminscript.py
index ec81aa8f..9e03028d 100644
--- a/python/skytools/adminscript.py
+++ b/python/skytools/adminscript.py
@@ -5,12 +5,11 @@
 
 import sys, inspect
 
-from skytools.scripting import DBScript
-from skytools.quoting import quote_statement
+import skytools
 
 __all__ = ['AdminScript']
 
-class AdminScript(DBScript):
+class AdminScript(skytools.DBScript):
     """Contains common admin script tools.
 
     Second argument (first is .ini file) is takes as command
@@ -19,7 +18,7 @@ class AdminScript(DBScript):
     """
     def __init__(self, service_name, args):
         """AdminScript init."""
-        DBScript.__init__(self, service_name, args)
+        skytools.DBScript.__init__(self, service_name, args)
         if self.pidfile:
             self.pidfile = self.pidfile + ".admin"
 
@@ -72,7 +71,7 @@ class AdminScript(DBScript):
                       fieldfmt = {}):
         """Display multirow query as a table."""
 
-        self.log.debug("display_table: %s" % quote_statement(sql, args))
+        self.log.debug("display_table: %s" % skytools.quote_statement(sql, args))
         curs = db.cursor()
         curs.execute(sql, args)
         rows = curs.fetchall()
@@ -111,14 +110,14 @@ class AdminScript(DBScript):
 
     def exec_stmt(self, db, sql, args):
         """Run regular non-query SQL on db."""
-        self.log.debug("exec_stmt: %s" % quote_statement(sql, args))
+        self.log.debug("exec_stmt: %s" % skytools.quote_statement(sql, args))
         curs = db.cursor()
         curs.execute(sql, args)
         db.commit()
 
     def exec_query(self, db, sql, args):
         """Run regular query SQL on db."""
-        self.log.debug("exec_query: %s" % quote_statement(sql, args))
+        self.log.debug("exec_query: %s" % skytools.quote_statement(sql, args))
         curs = db.cursor()
         curs.execute(sql, args)
         res = curs.fetchall()
diff --git a/python/skytools/dbservice.py b/python/skytools/dbservice.py
index c11ff209..931d514e 100755
--- a/python/skytools/dbservice.py
+++ b/python/skytools/dbservice.py
@@ -5,12 +5,8 @@
 
 import re, skytools
 
-from skytools import quote_ident, quote_fqident
-from skytools import db_urldecode, db_urlencode
-from skytools import parse_pgarray
-from skytools.sqltools import dbdict
-from skytools.querybuilder import PLPyQueryBuilder
-        
+from skytools import dbdict
+
 __all__ = ['DBService',  'dbdict',
     'get_record', 'get_record_list',
     'make_record', 'make_record_array', 'log_result', 'transform_fields',
@@ -204,7 +200,7 @@ class DBService:
         """ Returns initialized querybuilder object for building complex dynamic queries
         """
         params = params or kvargs
-        return PLPyQueryBuilder(sql, params, self.global_dict, self.sqls )
+        return skytools.PLPyQueryBuilder(sql, params, self.global_dict, self.sqls )
                             
     def run_query(self, sql, params = None, **kvargs):
         """ Helper function if everything you need is just paramertisized execute
@@ -294,7 +290,7 @@ class DBService:
                 res_rows = make_record_array(rows)
                 results.append([res_name, res_count, res_rows])
         if service_name:
-            sql = "select * from %s( {i_context}, {i_params} );" % quote_fqident(service_name)
+            sql = "select * from %s( {i_context}, {i_params} );" % skytools.quote_fqident(service_name)
             par = dbdict( i_context = self._context, i_params = make_record(params) )
             res = self.run_query( sql, par )
             for r in res:
@@ -344,9 +340,9 @@ class TableAPI:
             Tablename should be in format schema.tablename
         """
         self._ctx = ctx
-        self._table = quote_fqident(table)
+        self._table = skytools.quote_fqident(table)
         self._id = "id_" + skytools.fq_name_parts(table)[1]
-        self._where = quote_ident(self._id) + " = {" + self._id + "}"
+        self._where = skytools.quote_ident(self._id) + " = {" + self._id + "}"
         self._logging = create_log
 
     def _log(self, result, original = None):
@@ -380,7 +376,7 @@ class TableAPI:
         values = []
         for key in data.keys():
             if data[key] is not None:       # ignore empty
-                fields.append(quote_ident(key))
+                fields.append(skytools.quote_ident(key))
                 values.append("{" + key + "}")
         sql = "insert into %s (%s) values (%s) returning *;" % ( self._table, ",".join(fields), ",".join(values))
         result = self._ctx.run_query_row( sql, data )
@@ -548,7 +544,7 @@ class ServiceContext(DBService):
             For example to return data after doing save
         """
         self.raise_if_errors()
-        service_sql = "select * from %s( {i_context}, {i_params} );" % quote_fqident(service_name)
+        service_sql = "select * from %s( {i_context}, {i_params} );" % skytools.quote_fqident(service_name)
         service_params = { "i_context": ctx, "i_params": self.make_record(params) }
         results = self.run_query( service_sql, service_params )
         retval = self.retval()
diff --git a/python/skytools/dbstruct.py b/python/skytools/dbstruct.py
index df09669d..acdb8176 100644
--- a/python/skytools/dbstruct.py
+++ b/python/skytools/dbstruct.py
@@ -3,10 +3,9 @@
 
 import re
 
-from skytools.sqltools import fq_name_parts, get_table_oid, exists_table
-from skytools.quoting import quote_ident, quote_fqident, quote_literal
-from skytools.quoting import unquote_ident, unquote_fqident
-from skytools.parsing import parse_pgarray, parse_acl
+import skytools
+
+from skytools import quote_ident, quote_fqident
 
 __all__ = ['TableStruct', 'SeqStruct',
     'T_TABLE', 'T_CONSTRAINT', 'T_INDEX', 'T_TRIGGER',
@@ -294,8 +293,8 @@ class TGrant(TElem):
         if relacl is None:
             return []
         tup_list = []
-        for sacl in parse_pgarray(relacl):
-            acl = parse_acl(sacl)
+        for sacl in skytools.parse_pgarray(relacl):
+            acl = skytools.parse_acl(sacl)
             if not acl:
                 continue
             tup_list.append(acl)
@@ -381,7 +380,7 @@ class TColumn(TElem):
 
         self.sequence = None
         if row['seqname']:
-            self.seqname = unquote_fqident(row['seqname'])
+            self.seqname = skytools.unquote_fqident(row['seqname'])
 
 
 class TGPDistKey(TElem):
@@ -562,20 +561,20 @@ class TableStruct(BaseStruct):
         self.table_name = table_name
 
         # fill args
-        schema, name = fq_name_parts(table_name)
+        schema, name = skytools.fq_name_parts(table_name)
         args = {
             'schema': schema,
             'table': name,
             'fqname': self.fqname,
-            'fq2name': quote_literal(self.fqname),
-            'oid': get_table_oid(curs, table_name),
-            'pg_class_oid': get_table_oid(curs, 'pg_catalog.pg_class'),
+            'fq2name': skytools.quote_literal(self.fqname),
+            'oid': skytools.get_table_oid(curs, table_name),
+            'pg_class_oid': skytools.get_table_oid(curs, 'pg_catalog.pg_class'),
         }
 
         # load table struct
         self.col_list = self._load_elem(curs, self.name, args, TColumn)
         # if db is GP then read also table distribution keys
-        if exists_table(curs, "pg_catalog.gp_distribution_policy"):
+        if skytools.exists_table(curs, "pg_catalog.gp_distribution_policy"):
             self.dist_key_list = self._load_elem(curs, self.name, args,
                                                  TGPDistKey)
         else:
@@ -588,7 +587,7 @@ class TableStruct(BaseStruct):
         for col in self.col_list:
             if col.seqname:
                 owner = self.fqname + '.' + quote_ident(col.name)
-                seq_args = { 'fqname': col.seqname, 'owner': quote_literal(owner) }
+                seq_args = { 'fqname': col.seqname, 'owner': skytools.quote_literal(owner) }
                 self.seq_list += self._load_elem(curs, col.seqname, seq_args, TSeq)
         self.object_list += self.seq_list
 
diff --git a/python/skytools/parsing.py b/python/skytools/parsing.py
index 80e416be..7ca1c498 100644
--- a/python/skytools/parsing.py
+++ b/python/skytools/parsing.py
@@ -2,9 +2,7 @@
 """Various parsers for Postgres-specific data formats."""
 
 import re
-
-from skytools.quoting import unescape, unquote_literal, unquote_ident
-from skytools.sqltools import dbdict
+import skytools
 
 __all__ = [
     "parse_pgarray", "parse_logtriga_sql", "parse_tabbed_table",
@@ -46,7 +44,7 @@ def parse_pgarray(array):
         else:
             if len(item) > 0 and item[0] == '"':
                 item = item[1:-1]
-            val = unescape(item)
+            val = skytools.unescape(item)
         res.append(val)
 
         pos = pos2 + 1
@@ -156,9 +154,9 @@ class _logtriga_parser:
             # last sanity check
             if len(fields) == 0 or len(fields) != len(values):
                 raise Exception("syntax error, fields do not match values")
-        fields = [unquote_ident(f) for f in fields]
-        values = [unquote_literal(f) for f in values]
-        return dbdict(zip(fields, values))
+        fields = [skytools.unquote_ident(f) for f in fields]
+        values = [skytools.unquote_literal(f) for f in values]
+        return skytools.dbdict(zip(fields, values))
 
 def parse_logtriga_sql(op, sql):
     return parse_sqltriga_sql(op, sql)
@@ -367,11 +365,11 @@ def parse_acl(acl):
     owner = m.group('owner')
 
     if target:
-        target = unquote_ident(target)
+        target = skytools.unquote_ident(target)
     if perm:
         perm = perm[1:]
     if owner:
-        owner = unquote_ident(owner[1:])
+        owner = skytools.unquote_ident(owner[1:])
 
     return (target, perm, owner)
 
diff --git a/python/skytools/psycopgwrapper.py b/python/skytools/psycopgwrapper.py
index db5492c6..753700cd 100644
--- a/python/skytools/psycopgwrapper.py
+++ b/python/skytools/psycopgwrapper.py
@@ -64,8 +64,8 @@ __all__ = ['connect_database', 'set_tcp_keepalive', 'DBError']
 
 import sys, socket
 import psycopg2.extensions, psycopg2.extras
-from skytools.sqltools import dbdict
 from psycopg2 import Error as DBError
+import skytools
 
 class _CompatRow(psycopg2.extras.DictRow):
     """Make DictRow more dict-like."""
@@ -77,7 +77,7 @@ class _CompatRow(psycopg2.extras.DictRow):
 
     def copy(self):
         """Return regular dict."""
-        return dbdict(self.iteritems())
+        return skytools.dbdict(self.iteritems())
     
     def iterkeys(self):
         return self._index.iterkeys()
diff --git a/python/skytools/querybuilder.py b/python/skytools/querybuilder.py
index 8218d794..00fe717f 100755
--- a/python/skytools/querybuilder.py
+++ b/python/skytools/querybuilder.py
@@ -12,8 +12,7 @@ See L{plpy_exec} for examples.
 
 """
 
-from skytools.sqltools import dbdict
-from skytools.quoting import quote_literal
+import skytools
 
 __all__ = [ 
     'QueryBuilder', 'PLPyQueryBuilder', 'PLPyQuery', 'plpy_exec',
@@ -45,7 +44,7 @@ class QArg:
         self.conf = conf
     def __str__(self):
         if self.conf.param_type == PARAM_INLINE:
-            return quote_literal(self.value)
+            return skytools.quote_literal(self.value)
         elif self.conf.param_type == PARAM_DBAPI:
             return "%s"
         elif self.conf.param_type == PARAM_PLPY:
@@ -294,7 +293,7 @@ class PLPyQueryBuilder(QueryBuilder):
             sql = self.get_sql(PARAM_INLINE)
             res = plpy.execute(sql)
         if res:
-            res = [dbdict(r) for r in res]
+            res = [skytools.dbdict(r) for r in res]
         return res
 
 
@@ -371,7 +370,7 @@ def run_query(cur, sql, params = None, **kwargs):
     rows = cur.fetchall()
     # convert result rows to dbdict
     if rows:
-        rows = [dbdict(r) for r in rows]
+        rows = [skytools.dbdict(r) for r in rows]
     return rows
 
 def run_query_row(cur, sql, params = None, **kwargs):
diff --git a/python/skytools/scripting.py b/python/skytools/scripting.py
index 90125f58..298c1efa 100644
--- a/python/skytools/scripting.py
+++ b/python/skytools/scripting.py
@@ -6,10 +6,8 @@
 import sys, os, signal, optparse, time, errno, select
 import logging, logging.handlers, logging.config
 
-from skytools.config import *
-from skytools.psycopgwrapper import connect_database
-from skytools.quoting import quote_statement
-import skytools.skylog, psycopg2
+import skytools
+import skytools.skylog
 
 try:
     import skytools.installer_config
@@ -232,7 +230,7 @@ class DBCachedConn(object):
         # new conn?
         if not self.conn:
             self.isolation_level = isolation_level
-            self.conn = connect_database(self.loc)
+            self.conn = skytools.connect_database(self.loc)
             self.conn.my_name = self.name
 
             self.conn.set_isolation_level(isolation_level)
@@ -458,7 +456,7 @@ class DBScript(object):
             print("need config file, use --help for help.")
             sys.exit(1)
         conf_file = self.args[0]
-        return Config(self.service_name, conf_file, override = self.cf_operride)
+        return skytools.Config(self.service_name, conf_file, override = self.cf_operride)
 
     def init_optparse(self, parser = None):
         """Initialize a OptionParser() instance that will be used to 
@@ -704,7 +702,7 @@ class DBScript(object):
                 self.log.info("got KeyboardInterrupt, exiting")
             self.reset()
             sys.exit(1)
-        except psycopg2.Error, d:
+        except skytools.DBError, d:
             self.send_stats()
             if d.cursor and d.cursor.connection:
                 cname = d.cursor.connection.my_name
@@ -791,7 +789,7 @@ class DBScript(object):
 
     def _exec_cmd(self, curs, sql, args, quiet = False):
         """Internal tool: Run SQL on cursor."""
-        self.log.debug("exec_cmd: %s" % quote_statement(sql, args))
+        self.log.debug("exec_cmd: %s" % skytools.quote_statement(sql, args))
         curs.execute(sql, args)
         ok = True
         rows = curs.fetchall()
@@ -801,7 +799,7 @@ class DBScript(object):
                 msg = row['ret_note']
             except KeyError:
                 self.log.error("Query does not conform to exec_cmd API:")
-                self.log.error("SQL: %s" % quote_statement(sql, args))
+                self.log.error("SQL: %s" % skytools.quote_statement(sql, args))
                 self.log.error("Row: %s" % repr(row.copy()))
                 sys.exit(1)
             level = code / 100
@@ -816,7 +814,7 @@ class DBScript(object):
                 self.log.warning("%s" % (msg,))
             else:
                 self.log.error("%s" % (msg,))
-                self.log.debug("Query was: %s" % quote_statement(sql, args))
+                self.log.debug("Query was: %s" % skytools.quote_statement(sql, args))
                 ok = False
         return (ok, rows)
 
diff --git a/python/skytools/skylog.py b/python/skytools/skylog.py
index 3557cb1d..4ee05ed5 100644
--- a/python/skytools/skylog.py
+++ b/python/skytools/skylog.py
@@ -4,8 +4,7 @@
 import os, time, socket
 import logging, logging.handlers
 
-from skytools.psycopgwrapper import connect_database
-from skytools.quoting import quote_json
+import skytools
 
 _service_name = 'unknown_svc'
 def set_service_name(service_name):
@@ -61,7 +60,7 @@ class UdpLogServerHandler(logging.handlers.DatagramHandler):
             hostaddr = "0.0.0.0"
         jobname = record.name
         svcname = _service_name
-        pkt = self._log_template % (time.time()*1000, txt_level, quote_json(msg),
+        pkt = self._log_template % (time.time()*1000, txt_level, skytools.quote_json(msg),
                 jobname, svcname, hostname, hostaddr)
         return pkt
 
@@ -115,7 +114,7 @@ class LogDBHandler(logging.handlers.SocketHandler):
         """Create server connection.
         In this case its not socket but database connection."""
 
-        db = connect_database(self.connect_string)
+        db = skytools.connect_database(self.connect_string)
         db.set_isolation_level(0) # autocommit
         return db
 
diff --git a/python/skytools/sqltools.py b/python/skytools/sqltools.py
index e2dd17b6..d7b6efbd 100644
--- a/python/skytools/sqltools.py
+++ b/python/skytools/sqltools.py
@@ -3,7 +3,7 @@
 
 import os
 from cStringIO import StringIO
-from skytools.quoting import quote_copy, quote_literal, quote_ident, quote_fqident
+import skytools
 import skytools.installer_config
 try:
     import plpy
@@ -231,14 +231,14 @@ def _gen_dict_copy(tbl, row, fields, qfields):
     tmp = []
     for f in fields:
         v = row.get(f)
-        tmp.append(quote_copy(v))
+        tmp.append(skytools.quote_copy(v))
     return "\t".join(tmp)
 
 def _gen_dict_insert(tbl, row, fields, qfields):
     tmp = []
     for f in fields:
         v = row.get(f)
-        tmp.append(quote_literal(v))
+        tmp.append(skytools.quote_literal(v))
     fmt = "insert into %s (%s) values (%s);"
     return fmt % (tbl, ",".join(qfields), ",".join(tmp))
 
@@ -249,7 +249,7 @@ def _gen_list_copy(tbl, row, fields, qfields):
             v = row[i]
         except IndexError:
             v = None
-        tmp.append(quote_copy(v))
+        tmp.append(skytools.quote_copy(v))
     return "\t".join(tmp)
 
 def _gen_list_insert(tbl, row, fields, qfields):
@@ -259,7 +259,7 @@ def _gen_list_insert(tbl, row, fields, qfields):
             v = row[i]
         except IndexError:
             v = None
-        tmp.append(quote_literal(v))
+        tmp.append(skytools.quote_literal(v))
     fmt = "insert into %s (%s) values (%s);"
     return fmt % (tbl, ",".join(qfields), ",".join(tmp))
 
@@ -293,11 +293,11 @@ def magic_insert(curs, tablename, data, fields = None, use_insert = 0, quoted_ta
         else:
             row_func = _gen_list_copy
 
-    qfields = [quote_ident(f) for f in fields]
+    qfields = [skytools.quote_ident(f) for f in fields]
     if quoted_table:
         qtablename = tablename
     else:
-        qtablename = quote_fqident(tablename)
+        qtablename = skytools.quote_fqident(tablename)
 
     # init processing
     buf = StringIO()
@@ -380,9 +380,9 @@ class CopyPipe(object):
 def full_copy(tablename, src_curs, dst_curs, column_list = [], condition = None):
     """COPY table from one db to another."""
 
-    qtable = quote_fqident(tablename)
+    qtable = skytools.quote_fqident(tablename)
     if column_list:
-        qfields = ",".join([quote_ident(f) for f in column_list])
+        qfields = ",".join([skytools.quote_ident(f) for f in column_list])
         src = dst = "%s (%s)" % (qtable, qfields)
     else:
         qfields = '*'
@@ -527,16 +527,16 @@ def mk_insert_sql(row, tbl, pkey_list = None, field_map = None):
     val_list = []
     if field_map:
         for src, dst in field_map.iteritems():
-            col_list.append(quote_ident(dst))
-            val_list.append(quote_literal(row[src]))
+            col_list.append(skytools.quote_ident(dst))
+            val_list.append(skytools.quote_literal(row[src]))
     else:
         for c, v in row.iteritems():
-            col_list.append(quote_ident(c))
-            val_list.append(quote_literal(v))
+            col_list.append(skytools.quote_ident(c))
+            val_list.append(skytools.quote_literal(v))
     col_str = ", ".join(col_list)
     val_str = ", ".join(val_list)
     return "insert into %s (%s) values (%s);" % (
-                    quote_fqident(tbl), col_str, val_str)
+                    skytools.quote_fqident(tbl), col_str, val_str)
 
 def mk_update_sql(row, tbl, pkey_list, field_map = None):
     r"""Generate UPDATE statement from dict data.
@@ -553,23 +553,23 @@ def mk_update_sql(row, tbl, pkey_list, field_map = None):
     for k in pkey_list:
         pkmap[k] = 1
         new_k = field_map and field_map[k] or k
-        col = quote_ident(new_k)
-        val = quote_literal(row[k])
+        col = skytools.quote_ident(new_k)
+        val = skytools.quote_literal(row[k])
         whe_list.append("%s = %s" % (col, val))
 
     if field_map:
         for src, dst in field_map.iteritems():
             if src not in pkmap:
-                col = quote_ident(dst)
-                val = quote_literal(row[src])
+                col = skytools.quote_ident(dst)
+                val = skytools.quote_literal(row[src])
                 set_list.append("%s = %s" % (col, val))
     else:
         for col, val in row.iteritems():
             if col not in pkmap:
-                col = quote_ident(col)
-                val = quote_literal(val)
+                col = skytools.quote_ident(col)
+                val = skytools.quote_literal(val)
                 set_list.append("%s = %s" % (col, val))
-    return "update only %s set %s where %s;" % (quote_fqident(tbl),
+    return "update only %s set %s where %s;" % (skytools.quote_fqident(tbl),
             ", ".join(set_list), " and ".join(whe_list))
 
 def mk_delete_sql(row, tbl, pkey_list, field_map = None):
@@ -580,11 +580,11 @@ def mk_delete_sql(row, tbl, pkey_list, field_map = None):
     whe_list = []
     for k in pkey_list:
         new_k = field_map and field_map[k] or k
-        col = quote_ident(new_k)
-        val = quote_literal(row[k])
+        col = skytools.quote_ident(new_k)
+        val = skytools.quote_literal(row[k])
         whe_list.append("%s = %s" % (col, val))
     whe_str = " and ".join(whe_list) 
-    return "delete from only %s where %s;" % (quote_fqident(tbl), whe_str)
+    return "delete from only %s where %s;" % (skytools.quote_fqident(tbl), whe_str)
 
 if __name__ == '__main__':
     import doctest