LICENSE.txt src/cnxninfo.cpp src/cnxninfo.h src/dbspecific.h @@ -1,7 +1,7 @@ include src\*.h include src\*.cpp include tests\* -include README.txt +include *.txt prune setup.cfg include web\* MANIFEST.in @@ -1,19 +1,19 @@ #!/usr/bin/python import sys, os, re -from distutils.core import setup, Command +from distutils.core import setup from distutils.extension import Extension from distutils.errors import * from os.path import exists, abspath, dirname, join, isdir + OFFICIAL_BUILD = 9999 def main(): version_str, version = get_version() - files = [ 'pyodbcmodule.cpp', 'cursor.cpp', 'row.cpp', 'connection.cpp', 'buffer.cpp', 'params.cpp', 'errors.cpp', 'getdata.cpp' ] - files = [ abspath(join('src', f)) for f in files ] + files = [ abspath(join('src', f)) for f in os.listdir('src') if f.endswith('.cpp') ] libraries = [] extra_compile_args = None @@ -25,9 +25,8 @@ def main(): libraries.append('odbc32') extra_compile_args = [ '/W4' ] - # Add debugging symbols - extra_compile_args = [ '/W4', '/Zi', '/Od' ] - extra_link_args = [ '/DEBUG' ] + # extra_compile_args = [ '/W4', '/Zi', '/Od' ] + # extra_link_args = [ '/DEBUG' ] elif os.environ.get("OS", '').lower().startswith('windows'): # Windows Cygwin (posix on windows) @@ -43,6 +42,22 @@ def main(): # What is the proper way to detect iODBC, MyODBC, unixODBC, etc.? libraries.append('odbc') + macros = [ ('PYODBC_%s' % name, value) for name,value in zip(['MAJOR', 'MINOR', 'MICRO', 'BUILD'], version) ] + + # This isn't the best or right way to do this, but I don't see how someone is supposed to sanely subclass the build + # command. + try: + sys.argv.remove('--assert') + macros.append(('PYODBC_ASSERT', 1)) + except ValueError: + pass + + try: + sys.argv.remove('--trace') + macros.append(('TRACE_ALL', 1)) + except ValueError: + pass + if exists('MANIFEST'): os.remove('MANIFEST') @@ -58,7 +73,7 @@ def main(): ext_modules = [ Extension('pyodbc', files, libraries=libraries, - define_macros = [ ('PYODBC_%s' % name, value) for name,value in zip(['MAJOR', 'MINOR', 'MICRO', 'BUILD'], version) ], + define_macros = macros, extra_compile_args=extra_compile_args, extra_link_args=extra_link_args ) ], @@ -77,6 +92,7 @@ def main(): download_url = 'http://github.com/pyodbc/pyodbc/tree/master') + def get_version(): """ Returns the version of the product as (description, [major,minor,micro,beta]). setup.py @@ -14,6 +14,8 @@ #include "cursor.h" #include "pyodbcmodule.h" #include "errors.h" +#include "wrapper.h" +#include "cnxninfo.h" static char connection_doc[] = "Connection objects manage connections to the database.\n" @@ -171,13 +173,9 @@ PyObject* Connection_New(PyObject* pConnectString, bool fAutoCommit, bool fAnsi) return 0; } - cnxn->hdbc = hdbc; - cnxn->searchescape = 0; - cnxn->odbc_major = 3; - cnxn->odbc_minor = 50; - cnxn->nAutoCommit = fAutoCommit ? SQL_AUTOCOMMIT_ON : SQL_AUTOCOMMIT_OFF; - cnxn->supports_describeparam = false; - cnxn->datetime_precision = 19; // default: "yyyy-mm-dd hh:mm:ss" + cnxn->hdbc = hdbc; + cnxn->nAutoCommit = fAutoCommit ? SQL_AUTOCOMMIT_ON : SQL_AUTOCOMMIT_OFF; + cnxn->searchescape = 0; // // Initialize autocommit mode. @@ -202,43 +200,19 @@ PyObject* Connection_New(PyObject* pConnectString, bool fAutoCommit, bool fAnsi) // Gather connection-level information we'll need later. // - // FUTURE: Measure performance here. Consider caching by connection string if necessary. + Object info(GetConnectionInfo(pConnectString, cnxn)); - char szVer[20]; - SQLSMALLINT cch = 0; - if (SQL_SUCCEEDED(SQLGetInfo(cnxn->hdbc, SQL_DRIVER_ODBC_VER, szVer, _countof(szVer), &cch))) + if (!info.IsValid()) { - char* dot = strchr(szVer, '.'); - if (dot) - { - *dot = '\0'; - cnxn->odbc_major=(char)atoi(szVer); - cnxn->odbc_minor=(char)atoi(dot + 1); - } - } - - char szYN[2]; - if (SQL_SUCCEEDED(SQLGetInfo(cnxn->hdbc, SQL_DESCRIBE_PARAMETER, szYN, _countof(szYN), &cch))) - { - cnxn->supports_describeparam = szYN[0] == 'Y'; + Py_DECREF(cnxn); + return 0; } - // What is the datetime precision? This unfortunately requires a cursor (HSTMT). - - HSTMT hstmt = 0; - if (SQL_SUCCEEDED(SQLAllocHandle(SQL_HANDLE_STMT, cnxn->hdbc, &hstmt))) - { - if (SQL_SUCCEEDED(SQLGetTypeInfo(hstmt, SQL_TYPE_TIMESTAMP)) && SQL_SUCCEEDED(SQLFetch(hstmt))) - { - SQLINTEGER columnsize; - if (SQL_SUCCEEDED(SQLGetData(hstmt, 3, SQL_INTEGER, &columnsize, sizeof(columnsize), 0))) - { - cnxn->datetime_precision = columnsize; - } - } - - SQLFreeStmt(hstmt, SQL_CLOSE); - } + CnxnInfo* p = (CnxnInfo*)info.Get(); + cnxn->odbc_major = p->odbc_major; + cnxn->odbc_minor = p->odbc_minor; + cnxn->supports_describeparam = p->supports_describeparam; + cnxn->datetime_precision = p->datetime_precision; return reinterpret_cast<PyObject*>(cnxn); } src/connection.cpp @@ -1,15 +1,13 @@ -/* - * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated - * documentation files (the "Software"), to deal in the Software without restriction, including without limitation the - * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to - * permit persons to whom the Software is furnished to do so. - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE - * WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS - * OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR - * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. - */ +// Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated +// documentation files (the "Software"), to deal in the Software without restriction, including without limitation the +// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to +// permit persons to whom the Software is furnished to do so. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE +// WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS +// OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. #ifndef CONNECTION_H #define CONNECTION_H src/connection.h @@ -22,6 +22,7 @@ #include "params.h" #include "errors.h" #include "getdata.h" +#include "dbspecific.h" enum { @@ -171,6 +172,7 @@ PythonTypeFromSqlType(const SQLCHAR* name, SQLSMALLINT type) break; case SQL_TYPE_TIME: + case SQL_SS_TIME2: // SQL Server 2008+ pytype = (PyObject*)PyDateTimeAPI->TimeType; break; src/cursor.cpp @@ -7,6 +7,7 @@ #include "cursor.h" #include "connection.h" #include "errors.h" +#include "dbspecific.h" void GetData_init() { @@ -481,6 +482,22 @@ GetDataDouble(Cursor* cur, int iCol) return PyFloat_FromDouble(value); } +static PyObject* +GetSqlServerTime(Cursor* cur, int iCol) +{ + SQL_SS_TIME2_STRUCT value; + + SQLLEN cbFetched = 0; + + if (!SQL_SUCCEEDED(SQLGetData(cur->hstmt, (SQLSMALLINT)(iCol+1), SQL_C_BINARY, &value, sizeof(value), &cbFetched))) + return RaiseErrorFromHandle("SQLGetData", cur->cnxn->hdbc, cur->hstmt); + + if (cbFetched == SQL_NULL_DATA) + Py_RETURN_NONE; + + int micros = value.fraction / 1000; // nanos --> micros + return PyTime_FromTime(value.hour, value.minute, value.second, micros); +} static PyObject* GetDataTimestamp(Cursor* cur, int iCol) @@ -498,15 +515,16 @@ GetDataTimestamp(Cursor* cur, int iCol) switch (cur->colinfos[iCol].sql_type) { case SQL_TYPE_TIME: - return PyTime_FromTime(value.hour, value.minute, value.second, 0); - + { + int micros = value.fraction / 1000; // nanos --> micros + return PyTime_FromTime(value.hour, value.minute, value.second, micros); + } + case SQL_TYPE_DATE: return PyDate_FromDate(value.year, value.month, value.day); } - // The fraction field is in nanoseconds. - int micros = value.fraction / 1000; - + int micros = value.fraction / 1000; // nanos --> micros return PyDateTime_FromDateAndTime(value.year, value.month, value.day, value.hour, value.minute, value.second, micros); } @@ -566,6 +584,9 @@ GetData(Cursor* cur, Py_ssize_t iCol) case SQL_TYPE_TIME: case SQL_TYPE_TIMESTAMP: return GetDataTimestamp(cur, iCol); + + case SQL_SS_TIME2: + return GetSqlServerTime(cur, iCol); } return RaiseErrorV("HY106", ProgrammingError, "ODBC SQL type %d is not yet supported. column-index=%zd type=%d", src/getdata.cpp @@ -7,6 +7,7 @@ #include "buffer.h" #include "wrapper.h" #include "errors.h" +#include "dbspecific.h" struct ParamDesc { @@ -350,6 +351,7 @@ static const char* SqlTypeName(SQLSMALLINT n) _MAKESTR(SQL_TYPE_DATE); _MAKESTR(SQL_TYPE_TIME); _MAKESTR(SQL_TYPE_TIMESTAMP); + _MAKESTR(SQL_SS_TIME2); } return "unknown"; } @@ -564,7 +566,7 @@ static bool BindParam(Cursor* cur, int iParam, const ParamDesc* pDesc, PyObject* // (How many leading digits do we want to keep? With SQL Server 2005, this should be 3: 123000000) int keep = (int)pow(10.0, 9-min(9, precision)); value->fraction = value->fraction / keep * keep; - decimalDigits = precision; + decimalDigits = (SQLSMALLINT)precision; } fSqlType = SQL_TIMESTAMP; src/params.cpp @@ -17,6 +17,7 @@ #ifdef _MSC_VER #include <windows.h> #include <malloc.h> +#pragma warning(disable: 4127) // "conditional expression is constant" testing compilation constants typedef __int64 INT64; typedef unsigned __int64 UINT64; #else src/pyodbc.h @@ -17,6 +17,8 @@ #include "wrapper.h" #include "errors.h" #include "getdata.h" +#include "cnxninfo.h" +#include "dbspecific.h" #include <time.h> #include <stdarg.h> @@ -196,6 +198,7 @@ static bool import_types() OurTimeType = PyDateTimeAPI->TimeType; Cursor_init(); + CnxnInfo_init(); GetData_init(); PyObject* decimalmod = PyImport_ImportModule("decimal"); @@ -499,6 +502,7 @@ static const ConstantDef aConstants[] = { MAKECONST(SQL_TYPE_DATE), MAKECONST(SQL_TYPE_TIME), MAKECONST(SQL_TYPE_TIMESTAMP), + MAKECONST(SQL_SS_TIME2), MAKECONST(SQL_INTERVAL_MONTH), MAKECONST(SQL_INTERVAL_YEAR), MAKECONST(SQL_INTERVAL_YEAR_TO_MONTH), @@ -736,7 +740,7 @@ initpyodbc() ErrorInit(); - if (PyType_Ready(&ConnectionType) < 0 || PyType_Ready(&CursorType) < 0 || PyType_Ready(&RowType) < 0) + if (PyType_Ready(&ConnectionType) < 0 || PyType_Ready(&CursorType) < 0 || PyType_Ready(&RowType) < 0 || PyType_Ready(&CnxnInfoType) < 0) return; pModule = Py_InitModule4("pyodbc", pyodbc_methods, module_doc, NULL, PYTHON_API_VERSION); src/pyodbcmodule.cpp @@ -29,6 +29,8 @@ public: return *this; } + bool IsValid() const { return p != 0; } + PyObject* Detach() { PyObject* pT = p; src/wrapper.h @@ -64,6 +64,14 @@ class SqlServerTestCase(unittest.TestCase): unittest.TestCase.__init__(self, method_name) self.connection_string = connection_string + def get_sqlserver_version(self): + """ + Returns the major version: 8-->2000, 9==2005, 10 == SS2008 + """ + self.cursor.execute("exec master..xp_msver 'ProductVersion'") + row = self.cursor.fetchone() + return int(row.Character_Value.split('.', 1)[0]) + def setUp(self): self.cnxn = pyodbc.connect(self.connection_string) self.cursor = self.cnxn.cursor() @@ -75,6 +83,13 @@ class SqlServerTestCase(unittest.TestCase): except: pass + for i in range(3): + try: + self.cursor.execute("drop procedure proc%d" % i) + self.cnxn.commit() + except: + pass + self.cnxn.rollback() def tearDown(self): @@ -498,116 +513,78 @@ class SqlServerTestCase(unittest.TestCase): self.assertEqual(value, result) - # Not supported in 2005. Get 2008 beta. - # def test_date(self): - # value = date.today() - # - # self.cursor.execute("create table t1(dt datetime)") - # self.cursor.execute("insert into t1 values (?)", value) - # - # result = self.cursor.execute("select dt from t1").fetchone()[0] - # self.assertEquals(value, result) - - # Not supported in 2005. Get 2008 beta. - # def test_time(self): - # value = datetime.now().time() - # - # self.cursor.execute("create table t1(dt datetime)") - # self.cursor.execute("insert into t1 values (?)", value) - # - # result = self.cursor.execute("select dt from t1").fetchone()[0] - # self.assertEquals(value, result) + def test_date(self): + ver = self.get_sqlserver_version() + if ver < 10: # 2008 only + return # so pass / ignore + + value = date.today() + + self.cursor.execute("create table t1(d date)") + self.cursor.execute("insert into t1 values (?)", value) + + result = self.cursor.execute("select d from t1").fetchone()[0] + self.assertEquals(value, result) + + + def test_time(self): + ver = self.get_sqlserver_version() + if ver < 10: # 2008 only + return # so pass / ignore + + value = datetime.now().time() + + # We aren't yet writing values using the new extended time type so the value written to the database is only + # down to the second. + value = value.replace(microsecond=0) + + self.cursor.execute("create table t1(t time)") + self.cursor.execute("insert into t1 values (?)", value) + + result = self.cursor.execute("select t from t1").fetchone()[0] + self.assertEquals(value, result) # # stored procedures # + # def test_callproc(self): + # "callproc with a simple input-only stored procedure" + # pass + def test_sp_results(self): self.cursor.execute( """ - if exists (select * from dbo.sysobjects where id = object_id(N'[test_select]') and OBJECTPROPERTY(id, N'IsProcedure') = 1) - drop procedure [dbo].[test_select] - """) - self.cursor.execute( - """ - Create procedure test_select + Create procedure proc1 AS select top 10 name, id, xtype, refdate from sysobjects """) - rows = self.cursor.execute("exec test_select").fetchall() + rows = self.cursor.execute("exec proc1").fetchall() self.assertEquals(type(rows), list) self.assertEquals(len(rows), 10) # there has to be at least 10 items in sysobjects self.assertEquals(type(rows[0].refdate), datetime) - # Note: This will fail because the last thing in the stored procedure is an implicit drop, not a select! - # - def test_sp_results_from_temp(self): - self.cursor.execute( - """ - if exists (select * from dbo.sysobjects where id = object_id(N'[test_select]') and OBJECTPROPERTY(id, N'IsProcedure') = 1) - drop procedure [dbo].[test_select] - """) - self.cursor.execute( - """ - Create procedure test_select - AS - select top 10 name, id, xtype, refdate - into #tmptable - from sysobjects - select * from #tmptable - """) - # Because we're using a temporary table, two results are returned: - # - # (1) the results of the drop table, which is the number of rows in the temporary table - # (2) the result set from the select. - # - # Ignore the first result (which is just cursor.rowcount) - - self.cursor.execute("exec test_select") - self.assertEquals(self.cursor.rowcount, 10) # (1) - self.assert_(self.cursor.description is None) - - self.assert_(self.cursor.nextset()) # (2) - self.assert_(self.cursor.description is not None) - self.assert_(len(self.cursor.description) == 4) - - rows = self.cursor.fetchall() - self.assertEquals(type(rows), list) - self.assertEquals(len(rows), 10) # there has to be at least 10 items in sysobjects - self.assertEquals(type(rows[0].refdate), datetime) + def test_sp_results_from_temp(self): + # Note: I've used "set nocount on" so that we don't get the number of rows deleted from #tmptable. + # If you don't do this, you'd need to call nextset() once to skip it. - def test_sp_results_from_temp2(self): self.cursor.execute( """ - if exists (select * from dbo.sysobjects where id = object_id(N'[test_select]') and OBJECTPROPERTY(id, N'IsProcedure') = 1) - drop procedure [dbo].[test_select] - """) - self.cursor.execute( - """ - Create procedure test_select + Create procedure proc1 AS + set nocount on select top 10 name, id, xtype, refdate into #tmptable from sysobjects select * from #tmptable """) - # Because we're using a temporary table, two results are returned: - # - # (1) the results of the drop table, which is the number of rows in the temporary table - # (2) the result set from the select. - # - # Ignore the first result (which is just cursor.rowcount) - - # Note: Try dynamically figuring out whether nextset() is required or not. - - self.cursor.execute("exec test_select") - while self.cursor.description is None: - if not self.cursor.nextset(): - raise SystemExit('No result set!') + self.cursor.execute("exec proc1") + self.assert_(self.cursor.description is not None) + self.assert_(len(self.cursor.description) == 4) rows = self.cursor.fetchall() self.assertEquals(type(rows), list) @@ -618,13 +595,9 @@ class SqlServerTestCase(unittest.TestCase): def test_sp_results_from_vartbl(self): self.cursor.execute( """ - if exists (select * from dbo.sysobjects where id = object_id(N'[test_select]') and OBJECTPROPERTY(id, N'IsProcedure') = 1) - drop procedure [dbo].[test_select] - """) - self.cursor.execute( - """ - Create procedure test_select + Create procedure proc1 AS + set nocount on declare @tmptbl table(name varchar(100), id int, xtype varchar(4), refdate datetime) insert into @tmptbl @@ -633,17 +606,7 @@ class SqlServerTestCase(unittest.TestCase): select * from @tmptbl """) - # Because we're using a temporary table, two results are returned: - # - # (1) the results of the drop table, which is the number of rows in the temporary table - # (2) the result set from the select. - # - # Ignore the first result (which is just cursor.rowcount) - - self.cursor.execute("exec test_select") - self.assertEquals(self.cursor.rowcount, 10) # (1) - self.assert_(self.cursor.nextset()) # (2) - + self.cursor.execute("exec proc1") rows = self.cursor.fetchall() self.assertEquals(type(rows), list) self.assertEquals(len(rows), 10) # there has to be at least 10 items in sysobjects tests/sqlservertests.py bbb51c1a20c0eaa0923e2e0f7767913575237ce7 Michael Kleehammer michael@kleehammer.com http://github.com/mkleehammer/pyodbc/commit/04d8111b80fb00cae4c2677b1bb1ae8e20fec02c 04d8111b80fb00cae4c2677b1bb1ae8e20fec02c 2008-10-12T17:01:43-07:00 2008-10-12T17:01:43-07:00 Added SQL Server 2008 date/time extensions support. Now caches connection info. The connection info is in preparation for querying even more info per connection to implement Cursor.call Fixed the setup.py file so it doesn't build a debug library all the time. You can add --assert and --trace to turn those on instead of modifying pyodbc.h. Also added a license file (feature request). 5774fc0e49a2f59df854f9834a9f38efb5d62a1b Michael Kleehammer michael@kleehammer.com