pglib 5.7.0__tar.gz → 5.9.1__tar.gz

{pglib-5.7.0/pglib.egg-info → pglib-5.9.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pglib
-Version: 5.7.0
+Version: 5.9.1
 Summary: A PostgreSQL interface
 Home-page: https://gitlab.com/mkleehammer/pglib
 Maintainer: Michael Kleehammer

{pglib-5.7.0 → pglib-5.9.1}/pglib/__init__.py

@@ -4,7 +4,3 @@ from _pglib import *
 
 # The asynchronous code is in Python.
 from .asyncpglib import connect_async
-
-from ._version import get_versions
-__version__ = get_versions()['version']
-del get_versions

{pglib-5.7.0 → pglib-5.9.1/pglib.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pglib
-Version: 5.7.0
+Version: 5.9.1
 Summary: A PostgreSQL interface
 Home-page: https://gitlab.com/mkleehammer/pglib
 Maintainer: Michael Kleehammer

{pglib-5.7.0 → pglib-5.9.1}/pglib.egg-info/SOURCES.txt

@@ -21,7 +21,6 @@ setup.py
 /home/mkleehammer/dev/pglib/src/type_json.cpp
 /home/mkleehammer/dev/pglib/src/type_ltree.cpp
 pglib/__init__.py
-pglib/_version.py
 pglib/asyncpglib.py
 pglib.egg-info/PKG-INFO
 pglib.egg-info/SOURCES.txt

{pglib-5.7.0 → pglib-5.9.1}/setup.py

@@ -130,7 +130,7 @@ def _get_settings():
 
 setup(
     name='pglib',
-    version='5.7.0',
+    version='5.9.1',
     description='A PostgreSQL interface',
     long_description=long_description,
     maintainer='Michael Kleehammer',

{pglib-5.7.0 → pglib-5.9.1}/src/connection.cpp

@@ -149,6 +149,9 @@ static PGresult* internal_execute(PyObject* self, PyObject* args)
         PyErr_SetString(PyExc_TypeError, "The first argument must be a string.");
         return 0;
     }
+    const char* szSQL = PyUnicode_AsUTF8(pSql);
+    if (!szSQL)
+        return 0;
 
     Params params(cParams);
     if (!BindParams(cnxn, params, args))
@@ -156,7 +159,7 @@ static PGresult* internal_execute(PyObject* self, PyObject* args)
 
     PGresult* result;
     Py_BEGIN_ALLOW_THREADS
-    result = PQexecParams(cnxn->pgconn, PyUnicode_AsUTF8(pSql),
+    result = PQexecParams(cnxn->pgconn, szSQL,
                           cParams,
                           params.types,
                           params.values,
@@ -175,6 +178,7 @@ static PGresult* internal_execute(PyObject* self, PyObject* args)
     return result;
 }
 
+
 static const char doc_script[] = "Connection.script(sql) --> None\n\n"
     "Executes a script which can contain multiple statements separated by semicolons.";
 
@@ -188,7 +192,11 @@ static PyObject* Connection_script(PyObject* self, PyObject* args)
     if (!PyArg_ParseTuple(args, "U", &pScript))
         return 0;
 
-    ResultHolder result = PQexec(cnxn->pgconn, PyUnicode_AsUTF8(pScript));
+    const char* szScript = PyUnicode_AsUTF8(pScript);
+    if (!szScript)
+        return 0;
+
+    ResultHolder result = PQexec(cnxn->pgconn, szScript);
     if (result == 0)
         return 0;
 
@@ -203,6 +211,7 @@ static PyObject* Connection_script(PyObject* self, PyObject* args)
     }
 }
 
+
 const char* doc_copy_from =
     "Connection.copy_from(command, source) --> int\n"
     "\n"
@@ -233,7 +242,7 @@ static PyObject* Connection_copy_from(PyObject* self, PyObject* args)
     // an object with a read method (e.g. file).
     const char* buffer = 0;
     Py_ssize_t buffer_size = 0;
-    PyObject* read_method = 0;
+    Object read_method;
 
     if (PyUnicode_Check(source))
     {
@@ -245,7 +254,7 @@ static PyObject* Connection_copy_from(PyObject* self, PyObject* args)
     {
         if (!PyObject_HasAttrString(source, "read"))
             return PyErr_Format(Error, "CSV source must be a string or file-like object.");
-        read_method = PyObject_GetAttrString(source, "read");
+        read_method.Attach(PyObject_GetAttrString(source, "read"));
     }
 
     Connection* cnxn = CastConnection(self, REQUIRE_OPEN);
@@ -253,6 +262,9 @@ static PyObject* Connection_copy_from(PyObject* self, PyObject* args)
         return 0;
 
     const char* szSQL = PyUnicode_AsUTF8(command);
+    if (!szSQL)
+        return 0;
+
     ResultHolder result;
     Py_BEGIN_ALLOW_THREADS
     result = PQexec(cnxn->pgconn, szSQL);
@@ -353,6 +365,145 @@ static PyObject* Connection_copy_from(PyObject* self, PyObject* args)
 }
 
 
+const char* doc_copy_to_csv =
+    "Connection.copy_to_csv(table, dest, header=0, delimiter=',', quote='\"')\n"
+    "\n"
+    "Execute a COPY TO command and return the number of records copied.\n"
+    "\n"
+    "table\n"
+    "  The table to copy from.\n"
+    "\n"
+    "dest\n"
+    "  The file-like object to write to.  Strings will be written, not bytes, so\n"
+    "  open in text mode.\n"
+    "\n"
+    "header\n"
+    "  If non-zero, a CSV header will be written.\n";
+
+
+static PyObject* Connection_copy_to_csv(PyObject* self, PyObject* args, PyObject* kwargs)
+{
+    // This is not nearly as efficient as I'd like since newer Python versions no longer give
+    // us access to underlying file objects.  We have to write strings through a write method
+    // since there are io layers involved.
+    //
+    // For maximum performance, we should probably offer an option where we open the file given
+    // a filename.  We can either check the parameter type here or we could make a separate
+    // method with "file" in the name like copy_to_file.
+
+    static const char* kwlist[] = {"table", "dest", "header", "delimiter", "quote", 0};
+
+    PyObject* table;
+    PyObject* dest;
+    int header = 0;
+    char* szDelimiter = 0;
+    char* szQuote = 0;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "UO|pzz", (char**)kwlist, &table, &dest, &header,
+                                     &szDelimiter, &szQuote)) {
+        return 0;
+    }
+
+    Connection* cnxn = CastConnection(self, REQUIRE_OPEN);
+    if (!cnxn)
+        return 0;
+
+    if (!PyObject_HasAttrString(dest, "write"))
+        return PyErr_Format(Error, "CSV destination must be a file-like object.");
+    Object write_method(PyObject_GetAttrString(dest, "write"));
+
+    char header_token[] = "header";
+    if (header == 0) {
+        header_token[0] = 0;
+    }
+
+    const char* pszDelimiter = szDelimiter ? szDelimiter : ",";
+    const char* pszQuote = szQuote ? szQuote : "\"";
+
+    Object sql(PyUnicode_FromFormat("copy %U to stdout with csv %s delimiter '%s' quote '%s'",
+                                    table, header_token, pszDelimiter, pszQuote));
+    if (!sql)
+        return 0;
+
+    const char* szSQL = PyUnicode_AsUTF8(sql);
+    if (!szSQL)
+        return 0;
+
+    ResultHolder result;
+    Py_BEGIN_ALLOW_THREADS
+    result = PQexec(cnxn->pgconn, szSQL);
+    Py_END_ALLOW_THREADS
+
+    if (result == 0)
+        return 0;
+
+    switch (PQresultStatus(result)) {
+    case PGRES_COPY_OUT:
+        // This is what we are expecting.
+        break;
+
+    case PGRES_BAD_RESPONSE:
+    case PGRES_NONFATAL_ERROR:
+    case PGRES_FATAL_ERROR:
+        return SetResultError(result.Detach());
+
+    default:
+        return PyErr_Format(Error, "Result was not PGRES_COPY_IN: %d", (int)PQresultStatus(result));
+    }
+
+
+    for (;;) {
+        int cb = 0;
+        char* buffer;
+        Py_BEGIN_ALLOW_THREADS
+        cb = PQgetCopyData(cnxn->pgconn, &buffer, 0);
+        Py_END_ALLOW_THREADS
+
+        if (cb == -2) {
+            return SetResultError(result.Detach());
+        }
+
+        if (cb == -1) {
+            // The copy is complete.
+            break;
+        }
+
+        // We have a buffer of byte data.  We have the length, but the libpq docs say that the
+        // string is also zero terminated, so we're going to try not calling 'write'.
+
+        int err = PyFile_WriteString(buffer, dest);
+
+        //  while (cb > 0) {
+        //      PyObject* res = PyObject_CallObject(write_method)
+        //  }
+
+        PQfreemem(buffer);
+        if (err) {
+            return 0;
+        }
+    }
+
+    // After a copy, you have to get another result to know if it was successful.
+
+    ResultHolder final_result;
+    ExecStatusType status = PGRES_COMMAND_OK;
+    Py_BEGIN_ALLOW_THREADS
+    final_result = PQgetResult(cnxn->pgconn);
+    status = PQresultStatus(final_result);
+    Py_END_ALLOW_THREADS
+
+    if (status != PGRES_COMMAND_OK) {
+      // SetResultError will take ownership of `result`.
+      return SetResultError(final_result.Detach());
+    }
+
+    const char* sz = PQcmdTuples(final_result);
+    if (sz == 0 || *sz == 0)
+      Py_RETURN_NONE;
+    return PyLong_FromLong(atoi(sz));
+}
+
+
 const char* doc_copy_from_csv =
     "Connection.copy_from_csv(table, source, header=0) --> int\n"
     "\n"
@@ -389,15 +540,16 @@ static PyObject* Connection_copy_from_csv(PyObject* self, PyObject* args, PyObje
 
     const char* pszDelimiter = szDelimiter ? szDelimiter : ",";
     const char* pszQuote = szQuote ? szQuote : "\"";
-    PyObject* sql = PyUnicode_FromFormat("copy %U from stdin with csv %s delimiter '%s' quote '%s'",
-                                         table, header_token, pszDelimiter, pszQuote);
+    Object sql(PyUnicode_FromFormat("copy %U from stdin with csv %s delimiter '%s' quote '%s'",
+                                    table, header_token, pszDelimiter, pszQuote));
 
     // If source is a string (Unicode), store the UTF-encoded value in buffer. If a byte
     // object, store directly in buffer.  Otherwise, buffer will be zero and `source` must be
     // an object with a read method (e.g. file).
     const char* buffer = 0;
     Py_ssize_t buffer_size = 0;
-    PyObject* read_method = 0;
+    Object read_method;
+    //  PyObject* read_method = 0;
 
     if (PyUnicode_Check(source))
     {
@@ -409,7 +561,7 @@ static PyObject* Connection_copy_from_csv(PyObject* self, PyObject* args, PyObje
     {
         if (!PyObject_HasAttrString(source, "read"))
             return PyErr_Format(Error, "CSV source must be a string or file-like object.");
-        read_method = PyObject_GetAttrString(source, "read");
+        read_method.Attach(PyObject_GetAttrString(source, "read"));
     }
 
     Connection* cnxn = CastConnection(self, REQUIRE_OPEN);
@@ -417,6 +569,9 @@ static PyObject* Connection_copy_from_csv(PyObject* self, PyObject* args, PyObje
         return 0;
 
     const char* szSQL = PyUnicode_AsUTF8(sql);
+    if (!szSQL)
+        return 0;
+
     ResultHolder result;
     Py_BEGIN_ALLOW_THREADS
     result = PQexec(cnxn->pgconn, szSQL);
@@ -998,8 +1153,12 @@ static PyObject* Connection_sendQuery(PyObject* self, PyObject* args)
         return 0;
 
     int sent;
+    const char* szSQL = PyUnicode_AsUTF8(pScript);
+    if (!szSQL)
+        return 0;
+
     Py_BEGIN_ALLOW_THREADS
-    sent = PQsendQuery(cnxn->pgconn, PyUnicode_AsUTF8(pScript));
+    sent = PQsendQuery(cnxn->pgconn, szSQL);
     Py_END_ALLOW_THREADS
 
     if (!sent)
@@ -1038,6 +1197,10 @@ static PyObject* Connection_sendQueryParams(PyObject* self, PyObject* args)
         return 0;
     }
 
+    const char* szSQL = PyUnicode_AsUTF8(pSql);
+    if (!szSQL)
+        return 0;
+
     Params params(cParams);
     if (!BindParams(cnxn, params, args))
         return 0;
@@ -1047,7 +1210,7 @@ static PyObject* Connection_sendQueryParams(PyObject* self, PyObject* args)
     int needs_flush = -1;
 
     Py_BEGIN_ALLOW_THREADS
-    error = PQsendQueryParams(cnxn->pgconn, PyUnicode_AsUTF8(pSql),
+    error = PQsendQueryParams(cnxn->pgconn, szSQL,
                               cParams,
                               params.types,
                               params.values,
@@ -1215,7 +1378,16 @@ static PyObject* Connection_notifications(PyObject* self, PyObject* args, PyObje
     Py_END_ALLOW_THREADS
 
     if (retval == -1) {
-        SetStringError(Error, "An error occurred waiting for notifications");
+        // Allow the Python (or application) signal handler deal with Ctrl-C.  If it raises an
+        // exception, -1 is returned.  This only works on the main Python thread, but it is
+        // just a convenience for command line utilities to raise a KeyboardInterrupt instead a
+        // pglib error that *then* raises a KeyboardInterrupt.  So it is OK if we call on
+        // another thread and it is a no-op.
+
+        if (PyErr_CheckSignals() != -1) {
+            SetStringError(Error, "An error occurred waiting for notifications");
+        }
+
         return 0;
     }
 
@@ -1459,6 +1631,7 @@ static struct PyMethodDef Connection_methods[] =
     { "script",  Connection_script,  METH_VARARGS, doc_script },
     { "copy_from", (PyCFunction) Connection_copy_from, METH_VARARGS | METH_KEYWORDS, doc_copy_from },
     { "copy_from_csv", (PyCFunction) Connection_copy_from_csv, METH_VARARGS | METH_KEYWORDS, doc_copy_from_csv },
+    { "copy_to_csv", (PyCFunction) Connection_copy_to_csv, METH_VARARGS | METH_KEYWORDS, doc_copy_to_csv},
     { "begin",    Connection_begin,   METH_NOARGS, doc_begin },
     { "commit",   Connection_commit,   METH_NOARGS, doc_commit },
     { "rollback", Connection_rollback,   METH_NOARGS, doc_rollback },

{pglib-5.7.0 → pglib-5.9.1}/src/getdata.cpp

@@ -286,8 +286,10 @@ static PyObject* GetInterval(const char* p) // , bool integer_datetimes)
     uint32_t month = swaps4(pinterval->month);
     uint32_t year = month / 12;
 
-    if (month || year)
-        return PyErr_Format(Error, "Years and months are not supported in intervals");
+    if (month || year) {
+        PyErr_SetString(Error, "Years and months are not supported in intervals");
+        return 0;
+    }
 
     int seconds = (second) + (60 * minute) + (3600 * hour);
     int days    = day;
@@ -399,6 +401,9 @@ PyObject* ConvertValue(PGresult* result, int iRow, int iCol, bool integer_dateti
     case TEXTARRAYOID:
         return GetTextArray(p);
 
+    case JSONBARRAYOID:
+        return GetJSONBArray(p);
+
     case DATEARRAYOID:
         return GetDateArray(p);
 

{pglib-5.7.0 → pglib-5.9.1}/src/params.cpp

@@ -124,7 +124,7 @@ WriteBuffer Params::Allocate(size_t amount)
     if (*pp == 0)
     {
         size_t total = amount + 1024;
-        *pp = (Pool*)malloc(total);
+        *pp = (Pool*)malloc(total + (sizeof(Pool) - 1));
 
         if (*pp == 0)
         {